steamutils 1.3.45 → 1.3.46

package/SteamClient.js

@@ -1,2337 +1,2356 @@
-import NodeSteamUser from "steam-user";
-import _ from "lodash";
-import fs from "fs";
-import {protoDecode, protoEncode} from "./helpers/util.js";
-import SteamID from "steamid";
-import FriendCode from "csgo-friendcode";
-import axios from "axios";
-import helpers, {loadProfos} from "./helpers/protos.js";
-import {fileURLToPath} from "url";
-import path from "path";
-import SteamUser from "./index.js";
-import {v4 as uuidv4} from 'uuid';
-import EFriendRelationship from "steam-user/enums/EFriendRelationship.js";
-import SteamCommunity from "steamcommunity";
-import moment from "moment-timezone";
-import {encode, encodeUids} from "./bufferHelpers.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const Protos = helpers([{
-    name: 'csgo',
-    protos: loadProfos(__dirname + '/protos/')
-}])
-
-export const RANKS = {
-    0: 'Unranked',
-    1: 'Silver I',
-    2: 'Silver II',
-    3: 'Silver III',
-    4: 'Silver IV',
-    5: 'Silver Elite',
-    6: 'Silver Elite Master',
-    7: 'Gold Nova I',
-    8: 'Gold Nova II',
-    9: 'Gold Nova III',
-    10: 'Gold Nova Master',
-    11: 'Master Guardian I',
-    12: 'Master Guardian II',
-    13: 'Master Guardian Elite',
-    14: 'Distinguished Master Guardian',
-    15: 'Legendary Eagle',
-    16: 'Legendary Eagle Master',
-    17: 'Supreme Master First Class',
-    18: 'The Global Elite'
-}
-export const LOCS = {
-    20054: 'VN',
-    23115: 'KZ',
-    20041: 'IN',
-    20035: 'CN',
-    17474: 'BD',
-    17481: 'ID',
-    22861: 'MY',
-    18516: 'TH',
-    22356: 'TW',
-    21067: 'KR',
-    19272: 'HK',
-    18512: 'PH',
-    21842: 'RU',
-    16716: 'LA',
-    20558: 'NP',
-    18259: 'SG',
-    19789: 'MM',
-    20045: 'MN',
-    18251: 'KG',
-    18507: 'KH',
-    22605: 'MX',
-    19280: 'PK',
-    20301: 'HK/MO',//hongkong or macau
-    21333: 'Unknown',
-    21825: 'AU',
-    20034: 'Unkown',
-}
-
-
-const AppID = 730
-export let CSGO_VER = 13960
-export const FreeAppList = JSON.parse(fs.readFileSync(path.join(__dirname, 'free_packages.json'))).packages
-
-SteamUser.getAppVersion(AppID).then(function (ver) {
-    CSGO_VER = ver
-})
-
-const PersonasCache = []
-let isSendingFriendMessages = false;
-
-function SteamClient({
-                         username,
-                         password,
-                         cookie,
-                         clientJsToken,
-                         isAutoRequestFreeLicense = true,
-                         isFakeGameScore = true,
-                         isPartyRegister = true,
-                         isAutoPlay = false,
-                         isInvisible = false,
-                         autoAcceptTradeRequest = false,
-                         autoReconnect = true,
-                         MAX_GAME_PLAY = 10,
-                         games = null
-                     }) {
-    const steamClient = new NodeSteamUser()
-    let prime = null
-    let state = 'Offline'//InGame, Online, Invisible
-    let isLogOff = false
-    let playingBlocked = null
-    const richPresence = {}
-    let sendMessageTimestamp = 0
-    let lastTimePartyRegister = 0
-    let lastTimePartySearch = 0
-    const ownedApps = []
-    let logOffEvent = null
-
-    const currentLobby = {
-        lobbyID: null,
-        timestamp: 0
-    }
-
-    const onAnyCallbacks = []
-
-    const events = {
-        user: [],
-        loggedOn: [],
-        csgoOnline: [],
-        csgoClientHello: [],
-        webSession: [],
-        friendMessage: [],
-        friendTyping: [],
-        disconnected: [],
-        error: [],
-        playersProfile: [],
-        partyInvite: [],
-        friendRelationship: [],
-        tradeOffers: [],
-        offlineMessages: [],
-        friendsList: [],
-        gifts: [],
-        playingState: [],
-        emailInfo: [],
-        accountLimitations: [],
-    }
-
-    const gcCallback = {}
-
-    function pushGCCallback(name, cb, timeout) {
-        if (!gcCallback[name]) {
-            gcCallback[name] = {}
-        }
-        let t = null
-        let id = uuidv4()
-
-        function callback(...arg) {
-            if (t) {
-                clearTimeout(t)
-            }
-            delete gcCallback[name][id]
-            cb?.apply(null, arg)
-        }
-
-        if (timeout) {
-            t = setTimeout(callback, timeout)
-        }
-        gcCallback[name][id] = callback
-    }
-
-    function callGCCallback(name, ...arg) {
-        if (gcCallback[name]) {
-            for (const id in gcCallback[name]) {
-                gcCallback[name][id]?.(...arg)
-            }
-        }
-    }
-
-    function callEvent(_events, data) {
-        const eventName = Object.keys(events).find(eventName => events[eventName] === _events)
-        eventName && onAnyCallbacks.forEach(cb => cb?.({eventName, data}))
-
-        _events?.forEach?.((e) => {
-            e.callback?.(data)
-            e.timeout && clearTimeout(e.timeout)
-            delete e.timeout
-            if (e.once) {
-                delete e.callback
-            }
-        })
-        _.remove(_events, e => !e || e?.once)
-    }
-
-    function onEvent(name, callback, once, timeout) {
-        if (!events[name]) {
-            events[name] = []
-        }
-        const t = timeout ? setTimeout(callback, timeout) : null
-        events[name].push({
-            once,
-            callback,
-            timeout: t,
-        })
-    }
-
-
-    function offEvent(name) {
-        if (Array.isArray(events[name])) {
-            for (const eventElement of events[name]) {
-                if (eventElement.timeout) {
-                    clearTimeout(eventElement.timeout)
-                }
-            }
-        }
-
-        delete events[name]
-    }
-
-    function onAnyEvent(callback) {
-        onAnyCallbacks.push(callback)
-    }
-
-    function offAllEvent() {
-        for (const name in events) {
-            for (const event of events[name]) {
-                if (event.timeout) {
-                    try {
-                        clearTimeout(event.timeout)
-                    } catch (e) {
-                    }
-                    delete event.timeout
-                }
-            }
-            delete events[name]
-        }
-        onAnyCallbacks.length = 0
-    }
-
-    const intervals = {}
-    const intervalRandoms = {}
-
-    function doSetInterval(cb, timeout, key) {
-        const isRandom = Array.isArray(timeout)
-        if (!key) {
-            key = uuidv4()
-        }
-        if (isRandom) {
-            if (intervalRandoms[key] !== undefined) {
-                try {
-                    clearTimeout(intervalRandoms[key])
-                } catch (e) {
-                }
-            }
-            intervalRandoms[key] = setTimeout(function () {
-                doSetInterval(cb, timeout, key)
-                if (state !== 'Offline') {
-                    cb()
-                }
-            }, _.random(timeout[0], timeout[1]))
-        } else {
-            if (intervals[key] !== undefined) {
-                try {
-                    clearInterval(intervals[key])
-                } catch (e) {
-                }
-            }
-
-            intervals[key] = setInterval(function () {
-                if (state !== 'Offline') {
-                    cb()
-                }
-            }, timeout)
-        }
-
-        return key
-    }
-
-    function doClearIntervals() {
-        for (const key in intervals) {
-            clearInterval(intervals[key])
-            delete intervals[key]
-        }
-        for (const key in intervalRandoms) {
-            clearTimeout(intervalRandoms[key])
-            delete intervalRandoms[key]
-        }
-    }
-
-    function doClearInterval(key) {
-        try {
-            clearInterval(intervals[key])
-        } catch (e) {
-        }
-        delete intervals[key]
-
-
-        try {
-            clearTimeout(intervalRandoms[key])
-        } catch (e) {
-        }
-        delete intervalRandoms[key]
-    }
-
-    function getAccountInfoName() {
-        return [steamClient?.accountInfo?.name, steamClient?._logOnDetails?.account_name].filter(Boolean).join(" - ")
-    }
-
-    function getPersonaName() {
-        return steamClient?.accountInfo?.name
-    }
-
-    function log(...msg) {
-        const now = moment().tz('Asia/Ho_Chi_Minh').format("DD/MM/YYYY HH:mm:ss")
-        console.log(`[${now}] [${getAccountInfoName()}]`, ...msg)
-    }
-
-    async function getPersonas(steamIDs) {
-        steamIDs = steamIDs.map(steamId => steamId instanceof SteamID ? steamId.getSteamID64() : steamId)
-        const notCachesteamIDs = steamIDs.filter(id => !PersonasCache.some(p => p.id == id))
-        const cachedPersonas = PersonasCache.filter(p => steamIDs.includes(p.id))
-
-        if (notCachesteamIDs.length) {
-            let personas = null
-            try {
-                personas = (await steamClient.getPersonas(notCachesteamIDs))?.personas
-            } catch (e) {
-            }
-            if (!personas || !Object.keys(personas).length) {
-                try {
-                    personas = (await steamClient.getPersonas(notCachesteamIDs))?.personas
-                } catch (e) {
-                }
-            }
-            if (!personas || !Object.keys(personas).length) {
-                try {
-                    personas = (await steamClient.getPersonas(notCachesteamIDs))?.personas
-                } catch (e) {
-                }
-            }
-            if (personas && Object.keys(personas).length) {
-                for (let sid64 in personas) {
-                    personas[sid64].id = sid64
-                    personas[sid64].avatar_hash = Buffer.from(personas[sid64].avatar_hash).toString("hex")
-                    PersonasCache.push(personas[sid64])
-                    cachedPersonas.push(personas[sid64])
-                }
-            }
-        }
-
-        while (PersonasCache.length > 500) {
-            PersonasCache.shift()
-        }
-        return cachedPersonas
-    }
-
-    function sleep(ms) {
-        return new Promise(resolve => {
-            setTimeout(resolve, ms)
-        })
-    }
-
-    function getCookies() {
-        return cookie || steamClient?.webSession?.cookies?.join?.(';')
-    }
-
-    async function getCookiesWait() {
-        return getCookies() || new Promise(resolve => {
-            onEvent('webSession', function (webSession) {
-                resolve(webSession?.cookies)
-            }, true, 30000)
-        })
-    }
-
-    async function gamePlay() {
-        if ((Array.isArray(games) && games.length) || (games && (typeof games === "number" || typeof games === "string"))) {
-            return gamesPlayed(games)
-        }
-
-        let ownedApps = []
-        for (let i = 0; i < 5; i++) {
-            ownedApps = await getUserOwnedApps()
-            if (ownedApps?.length) {
-                break
-            }
-        }
-        if (!ownedApps?.length) {
-            gamesPlayed(730)
-        } else {
-            ownedApps = ownedApps.map(({appid}) => appid)
-            ownedApps = _.shuffle(ownedApps)
-            ownedApps.length = Math.min(ownedApps.length, MAX_GAME_PLAY - 1)
-            _.remove(ownedApps, app => app == 730)
-            gamesPlayed([...ownedApps, 730])
-        }
-    }
-
-    async function autoGamePlay() {
-        await gamePlay()
-        doSetInterval(gamePlay, [15 * 60000, 30 * 60000], 'autoGamePlay')
-    }
-
-    async function offAutoGamePlay() {
-        steamClient.gamesPlayed([])
-        doClearInterval('autoGamePlay')
-    }
-
-
-    async function updateAutoGamePlay() {
-        if (isAutoPlay) {
-            autoGamePlay()
-        } else {
-            offAutoGamePlay()
-        }
-    }
-
-
-    /**
-     * Get a list of lobbies (* = Unsure description could be wrong)
-     * @param {Number} ver Game version we are searching for
-     * @param {Boolean} apr Prime or not*
-     * @param {Number} ark Rank multiplied by 10*
-     * @param {Array.<Number>} grps *
-     * @param {Number} launcher If we are using the China CSGO launcher or not*
-     * @param {Number} game_type Game type, 8 Competitive, 10 Wingman
-     * @returns {Promise.<Object>}
-     */
-    async function partySearch({
-                                   prime = false,
-                                   game_type = 'Competitive',
-                                   rank = 'Silver Elite',
-                                   timeout = 5000,
-                               } = {}) {
-        const players = await new Promise(resolve => {
-            steamClient.sendToGC(AppID, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search, {}, protoEncode(Protos.csgo.CMsgGCCStrike15_v2_Party_Search, {
-                ver: CSGO_VER,
-                apr: prime ? 1 : 0,
-                ark: parseInt(Object.keys(RANKS).find(k => RANKS[k] === rank)) * 10,
-                grps: [],
-                launcher: 0,
-                game_type: game_type === 'Competitive' ? 8 : 10
-            }))
-            lastTimePartySearch = new Date().getTime()
-            pushGCCallback('partySearch', resolve, timeout)
-        })
-        if (Array.isArray(players) && players.length) {
-            const personas = await getPersonas(players.map(p => p.steamId))
-            for (const player of players) {
-                const persona = personas.find(p => p.id == player.steamId)
-                if (persona) {
-                    player.player_name = persona.player_name
-                    player.avatar_hash = persona.avatar_hash
-                }
-            }
-        }
-        return players
-    }
-
-    async function createLobby() {
-        if (!steamClient.steamID) {
-            return
-        }
-
-        return new Promise(resolve => {
-            const timeout = setTimeout(function () {
-                resolve()
-            }, 30000)
-
-            steamClient._send(
-                {
-                    msg: Protos.csgo.EMsg.k_EMsgClientMMSCreateLobby,
-                    proto: {
-                        steamid: steamClient.steamID.getSteamID64(),
-                        routing_appid: 730
-                    }
-                },
-                protoEncode(Protos.csgo.CMsgClientMMSCreateLobby, {
-                    app_id: 730,
-                    max_members: 1,
-                    lobby_type: 1,
-                    lobby_flags: 1
-                }), function (payload) {
-                    clearTimeout(timeout)
-                    const result = protoDecode(Protos.csgo.CMsgClientMMSCreateLobbyResponse, payload.toBuffer())
-                    const steam_id_lobby = result.steam_id_lobby.toString();
-                    currentLobby.lobbyID = steam_id_lobby
-                    currentLobby.timestamp = new Date().getTime()
-                    resolve(steam_id_lobby)
-                }
-            );
-        })
-
-        // return await getHandlerResult(Protos.csgo.EMsg.k_EMsgClientMMSCreateLobbyResponse, function (payload) {
-        //     const result = protoDecode(Protos.csgo.CMsgClientMMSCreateLobbyResponse, payload.toBuffer())
-        //     return result.steam_id_lobby.toString()
-        // })
-
-        // steamClient.sendToGC(730, Protos.csgo.EMsg.k_EMsgClientMMSCreateLobby, {
-        //     steamid: steamClient.steamID,
-        //     routing_appid: 730,
-        // }, protoEncode(Protos.csgo.CMsgClientMMSCreateLobby, {
-        //     app_id: 730,
-        //     max_members: 1,
-        //     lobby_type: 1,
-        //     lobby_flags: 1
-        // }))
-    }
-
-    async function updateLobby(lobbyID) {
-        if (!steamClient.steamID) {
-            return
-        }
-
-        return new Promise(resolve => {
-            const timeout = setTimeout(function () {
-                resolve()
-            }, 30000)
-
-            steamClient._send(
-                {
-                    msg: Protos.csgo.EMsg.k_EMsgClientMMSSetLobbyData,
-                    proto: {
-                        steamid: steamClient.steamID.getSteamID64(),
-                        routing_appid: 730
-                    }
-                },
-                protoEncode(Protos.csgo.CMsgClientMMSSetLobbyData, {
-                    app_id: 730,
-                    steam_id_lobby: lobbyID,
-                    steam_id_member: '0',
-                    max_members: 10,
-                    lobby_type: 1,
-                    lobby_flags: 1,
-                    metadata: encode({
-                        'game:ark': '0',
-                        // Country/Message
-                        'game:loc': '',
-                        'game:mapgroupname': 'mg_de_mirage',
-                        'game:mode': 'competitive',
-                        'game:prime': '1',
-                        'game:type': 'classic',
-                        'members:numPlayers': '1',
-                        'options:action': 'custommatch',
-                        'options:anytypemode': '0',
-                        'system:access': 'private',
-                        'system:network': 'LIVE',
-                        uids: [steamClient.steamID]
-                    }, [0x00, 0x00], [0x08], {uids: encodeUids}).toBuffer()
-                }),
-                function (payload) {
-                    clearTimeout(timeout)
-                    const result = protoDecode(Protos.csgo.CMsgClientMMSSetLobbyDataResponse, payload.toBuffer())
-                    const steam_id_lobby = result.steam_id_lobby.toString();
-                    currentLobby.lobbyID = steam_id_lobby
-                    currentLobby.timestamp = new Date().getTime()
-                    resolve(steam_id_lobby)
-                }
-            );
-        })
-
-        // return await getHandlerResult(Protos.csgo.EMsg.k_EMsgClientMMSSetLobbyDataResponse, function (payload) {
-        //     const result = protoDecode(Protos.csgo.CMsgClientMMSSetLobbyDataResponse, payload.toBuffer())
-        //     return result.steam_id_lobby.toString()
-        // })
-    }
-
-    async function invite2Lobby(lobbyID, steamId) {
-        if (!steamClient.steamID) {
-            return
-        }
-
-        steamClient._send(
-            {
-                msg: Protos.csgo.EMsg.k_EMsgClientMMSInviteToLobby,
-                proto: {
-                    steamid: steamClient.steamID.getSteamID64(),
-                    routing_appid: 730
-                }
-            },
-            protoEncode(Protos.csgo.CMsgClientMMSInviteToLobby, {
-                app_id: 730,
-                steam_id_lobby: lobbyID,
-                steam_id_user_invited: steamId,
-            }));
-
-        // lobbyID = new SteamID(lobbyID).accountid;
-
-        // Protos.csgo.EMsg.k_EMsgGCHInviteUserToLobby
-        // Protos.csgo.EMsg.k_EMsgClientMMSInviteToLobby
-        // steamClient.sendToGC(730, Protos.csgo.EMsg.k_EMsgClientMMSInviteToLobby, {}, protoEncode(Protos.csgo.CMsgClientMMSInviteToLobby, {
-        //     app_id: 730,
-        //     steam_id_lobby: lobbyID,
-        //     steam_id_user_invited: accountid,
-        // }), function (...args) {
-        //     console.log("invite2Lobby response", args)
-        // })
-    }
-
-    async function createThenInvite2Lobby(steamIds, onInvite) {
-        if (!steamClient.steamID) {
-            return
-        }
-
-        if (!Array.isArray(steamIds)) {
-            steamIds = [steamIds]
-        }
-
-        let lobbyID = null
-        if (currentLobby.lobbyID && currentLobby.timestamp > new Date().getTime() - 30000) {//30 seconds
-            lobbyID = currentLobby.lobbyID
-        } else {
-            lobbyID = await createLobby();
-            lobbyID = await updateLobby(lobbyID)
-        }
-
-        for (const steamId of steamIds) {
-            onInvite?.(lobbyID, steamId)
-            await invite2Lobby(lobbyID, steamId)
-        }
-
-        return lobbyID
-    }
-
-
-    async function getLobbyData(lobbyID) {
-        if (!steamClient.steamID) {
-            return
-        }
-
-        return new Promise(resolve => {
-            const timeout = setTimeout(function () {
-                resolve()
-            }, 30000)
-
-            steamClient._send(
-                {
-                    msg: Protos.csgo.EMsg.k_EMsgClientMMSGetLobbyData,
-                    proto: {
-                        steamid: steamClient.steamID.getSteamID64(),
-                        routing_appid: 730
-                    }
-                },
-                protoEncode(Protos.csgo.CMsgClientMMSGetLobbyData, {
-                    app_id: 730,
-                    steam_id_lobby: lobbyID.toString(),
-                }),
-                function (payload) {
-                    clearTimeout(timeout)
-                    const result = protoDecode(Protos.csgo.CMsgClientMMSLobbyData, payload.toBuffer())
-                    result.steam_id_lobby = result.steam_id_lobby.toString()
-                    resolve(result)
-                }
-            );
-        })
-    }
-
-
-    async function joinLobby(lobbyID) {
-        log("joinLobby", lobbyID);//SteamID.fromIndividualAccountID(lobbyId).accountid
-
-        steamClient._send(
-            {
-                msg: Protos.csgo.EMsg.k_EMsgClientMMSJoinLobby,
-                proto: {
-                    steamid: steamClient.steamID.getSteamID64(),
-                    routing_appid: 730
-                }
-            },//CMsgClientMMSUserJoinedLobby CMsgClientMMSJoinLobby
-            protoEncode(Protos.csgo.CMsgClientMMSJoinLobby, {
-                app_id: 730,
-                steam_id_lobby: lobbyID,
-                persona_name: steamClient.accountInfo.name,
-            }),
-            function (payload) {
-                const result = protoDecode(Protos.csgo.CMsgClientMMSJoinLobbyResponse, payload.toBuffer())
-                result.steam_id_lobby = result.steam_id_lobby.toString()
-                result.steam_id_owner = result.steam_id_owner.toString()
-                console.log(result);
-                const resultExample = {
-                    members: [],
-                    app_id: 730,
-                    steam_id_lobby: "3641224920",
-                    chat_room_enter_response: 2,
-                    max_members: 0,
-                    lobby_type: 0,
-                    lobby_flags: 0,
-                    steam_id_owner: "0",
-                    metadata: null//Buffer
-                }
-            }
-        )
-    }
-
-    async function sendHello() {
-        steamClient.sendToGC(AppID, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingClient2GCHello, {}, Buffer.alloc(0))
-        steamClient.sendToGC(AppID, Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientHello, {}, Buffer.alloc(0))
-    }
-
-    async function requestCoPlays() {
-        return new Promise(resolve => {
-            steamClient.sendToGC(AppID, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays, {}, Buffer.alloc(0))
-            pushGCCallback('RequestCoPlays', resolve, 30000)
-        })
-    }
-
-
-    function bindEvent() {
-        const _events = {
-            async disconnected(eresult, msg) {
-                state = 'Offline'
-                log('disconnected', eresult, msg)
-
-                callEvent(events.disconnected, {eresult, msg})
-
-                if (['ServiceUnavailable', 'NoConnection'].includes(msg) && autoReconnect && !isLogOff) {
-                    async function relogin(retry) {
-                        if (isLogOff) {
-                            console.error("Cannot relogin (logoff)")
-                            return false
-                        } else if (retry <= 0) {
-                            console.error("Cannot relogin")
-                            return false
-                        } else {
-                            const isSuccess = await login(true)
-                            if (isSuccess) {
-                                const loggedOnResponse = await new Promise(resolve => {
-                                    onEvent('loggedOn', resolve, true, 180000)
-                                })
-                                if (loggedOnResponse) {
-                                    console.log("Relogin success")
-                                    return true
-                                } else {
-                                    const isLogOff = await new Promise((resolve, reject) => {
-                                        logOffEvent = resolve
-                                        setTimeout(resolve, 120000)
-                                    })
-                                    logOffEvent = null
-                                    if (isLogOff === true) {
-                                        return false
-                                    }
-                                    return await relogin(retry - 1)
-                                }
-                            } else {
-                                const isLogOff = await new Promise((resolve, reject) => {
-                                    logOffEvent = resolve
-                                    setTimeout(resolve, 120000)
-                                })
-                                logOffEvent = null
-                                if (isLogOff === true) {
-                                    return false
-                                }
-                                return await relogin(retry - 1)
-                            }
-                        }
-                    }
-
-                    const isLogOff = await new Promise((resolve, reject) => {
-                        logOffEvent = resolve
-                        setTimeout(resolve, 60000)
-                    })
-                    logOffEvent = null
-                    if (isLogOff === true) {
-                        offAllEvent()
-                        doClearIntervals()
-                    } else {
-                        const isSuccess = await relogin(50)
-                        if (!isSuccess) {
-                            offAllEvent()
-                            doClearIntervals()
-                        }
-                    }
-                } else {
-                    offAllEvent()
-                    doClearIntervals()
-                }
-            },
-            async error(e) {
-                let errorStr = ``
-                switch (e.eresult) {
-                    case 5:
-                        errorStr = `Invalid Password`
-                        break
-                    case 6:
-                    case 34:
-                        errorStr = `Logged In Elsewhere`
-                        break
-                    case 84:
-                        errorStr = `Rate Limit Exceeded`
-                        break
-                    case 65:
-                        errorStr = `steam guard is invalid`
-                        break
-                    default:
-                        errorStr = `Unknown: ${e.eresult}`
-                        break
-                }
-                log(`error [isLogOff: ${isLogOff}]`, e?.message)
-                doClearIntervals()
-                callEvent(events.error, {eresult: e.eresult, msg: e.message, error: errorStr})
-            },
-            async webSession(sessionID, cookies) {
-                const webSession = {sessionID, cookies};
-                steamClient.webSession = webSession
-                callEvent(events.webSession, webSession)
-            },
-            async receivedFromGC(appid, msgType, payload) {
-                const key = getECsgoGCMsgKey(msgType)
-                switch (msgType) {
-                    case Protos.csgo.EMsg.k_EMsgClientChatInvite: {
-                        log(payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgClientMMSJoinLobbyResponse: {
-                        const msg = protoDecode(Protos.csgo.CMsgClientMMSJoinLobbyResponse, payload);
-                        log(msg)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Invite: {
-                        const msg = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Party_Invite, payload);
-                        const sid64 = SteamID.fromIndividualAccountID(msg.accountid).getSteamID64();
-                        if (events.partyInvite?.length) {
-                            const personas = await getPersonas([sid64]);
-                            const player_name = personas.find(p => p.id == sid64)?.player_name
-                            if (player_name === undefined) {
-                                log(sid64, personas);
-                            }
-                            callEvent(events.partyInvite, {player_name, steamId: sid64, lobbyId: msg.lobbyid})
-                        }
-                        // log(player_name, `https://steamcommunity.com/profiles/${sid64}`);
-                        // joinLobby(msg.lobbyid, msg.accountid)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays: {
-                        const msg = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Account_RequestCoPlays, payload);
-                        const personas = msg.players.map(p => SteamID.fromIndividualAccountID(p.accountid));
-                        callGCCallback('RequestCoPlays', personas)
-                        break
-                    }
-                    case Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientWelcome: {
-                        prime = false
-                        const CMsgClientWelcome = protoDecode(Protos.csgo.CMsgClientWelcome, payload);
-                        const obj = {}
-                        for (const outofdate_cache of CMsgClientWelcome.outofdate_subscribed_caches) {
-                            for (const cache_object of outofdate_cache.objects) {
-                                for (const object_data of cache_object.object_data) {
-                                    switch (cache_object.type_id) {
-                                        case 1: {
-                                            const result = protoDecode(Protos.csgo.CSOEconItem, object_data);
-                                            result.id = result.id.toNumber()
-                                            break
-                                        }
-                                        case 2: {
-                                            const result = protoDecode(Protos.csgo.CSOPersonaDataPublic, object_data);
-                                            obj.PersonaDataPublic = result
-                                            const example = {
-                                                player_level: 4,
-                                                commendation: {
-                                                    cmd_friendly: 149,
-                                                    cmd_teaching: 108,
-                                                    cmd_leader: 115
-                                                },
-                                                elevated_state: true
-                                            }
-                                            break
-                                        }
-                                        case 5: {
-                                            const result = protoDecode(Protos.csgo.CSOItemRecipe, object_data);
-                                            break
-                                        }
-                                        case 7: {
-                                            const CSOEconGameAccountClient = protoDecode(Protos.csgo.CSOEconGameAccountClient, object_data);
-                                            const CSOEconGameAccountClientExample = {
-                                                additional_backpack_slots: 0,
-                                                bonus_xp_timestamp_refresh: 1688518800,//Wednesday 1:00:00 AM every week
-                                                bonus_xp_usedflags: 19,
-                                                elevated_state: 5,
-                                                elevated_timestamp: 5
-                                            } //1688518800
-                                            if ((CSOEconGameAccountClient.bonus_xp_usedflags & 16) != 0) { // EXPBonusFlag::PrestigeEarned
-                                                prime = true
-                                                CSOEconGameAccountClient.prime = true
-                                            }
-                                            if (CSOEconGameAccountClient.elevated_state === 5) { // bought prime
-                                                prime = true
-                                                CSOEconGameAccountClient.prime = true
-                                            }
-                                            obj.GameAccountClient = CSOEconGameAccountClient
-                                            break
-                                        }
-
-                                        case 35: {
-                                            // const result =protoDecode(Protos.csgo.CSOSelectedItemPreset, object_data);
-                                            break
-                                        }
-
-                                        case 36: {
-                                            // const result =protoDecode(Protos.csgo.CSOEconItemPresetInstance, object_data);
-                                            break
-                                        }
-                                        case 38: {
-                                            const result = protoDecode(Protos.csgo.CSOEconItemDropRateBonus, object_data);
-                                            break
-                                        }
-                                        case 39: {
-                                            const result = protoDecode(Protos.csgo.CSOEconItemLeagueViewPass, object_data);
-                                            break
-                                        }
-                                        case 40: {
-                                            const result = protoDecode(Protos.csgo.CSOEconItemEventTicket, object_data);
-                                            break
-                                        }
-                                        case 41: {
-                                            const result = protoDecode(Protos.csgo.CSOAccountSeasonalOperation, object_data);
-                                            break
-                                        }
-                                        case 42: {
-                                            // const result =protoDecode(Protos.csgo.CSOEconItemTournamentPassport, object_data);
-                                            break
-                                        }
-                                        case 43: {
-                                            const result = protoDecode(Protos.csgo.CSOEconDefaultEquippedDefinitionInstanceClient, object_data);
-                                            const example = {
-                                                account_id: 1080136620,
-                                                item_definition: 61,
-                                                class_id: 3,
-                                                slot_id: 2
-                                            }
-                                            break
-                                        }
-                                        case 45: {
-                                            const result = protoDecode(Protos.csgo.CSOEconCoupon, object_data);
-                                            break
-                                        }
-                                        case 46: {
-                                            const result = protoDecode(Protos.csgo.CSOQuestProgress, object_data);
-                                            break
-                                        }
-                                        case 4: {
-                                            const result = protoDecode(Protos.csgo.CSOAccountItemPersonalStore, object_data);
-                                            result.generation_time = result.generation_time * 1000
-                                            if (Array.isArray(result.items)) {
-                                                result.items = result.items.map(item => item.toNumber())
-                                            }
-                                            obj.personalStore = result
-                                            break
-                                        }
-
-                                        default: {
-                                            log("cache_object.type_id", cache_object.type_id);
-                                        }
-                                    }
-                                }
-
-                            }
-                        }
-                        callEvent(events.csgoOnline, obj)
-
-                        if (isPartyRegister) {
-                            partyRegister()
-                            doSetInterval(function () {
-                                partyRegister()
-                            }, [60000, 120000], 'autoPartyRegister')
-                        }
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate, payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GC2ClientGlobalStats: {
-                        const result = protoDecode(Protos.csgo.CMsgClientUGSGetGlobalStatsResponse, payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientReportPlayer: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientReportPlayer, payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GC2ClientTextMsg: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_GC2ClientTextMsg, payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientHello: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchmakingGC2ClientHello, payload)
-                        const example = {
-                            my_current_event_teams: [],
-                            my_current_event_stages: [],
-                            rankings: [],
-                            account_id: 1080136620,
-                            ongoingmatch: null,
-                            global_stats: {
-                                search_statistics: [
-                                    {
-                                        game_type: 520,
-                                        search_time_avg: 0,
-                                        players_searching: 5141
-                                    },
-                                    {
-                                        game_type: 32776,
-                                        search_time_avg: 0,
-                                        players_searching: 6561
-                                    },
-                                ],
-                                players_online: 617207,
-                                servers_online: 230638,
-                                players_searching: 13550,
-                                servers_available: 126352,
-                                ongoing_matches: 23264,
-                                search_time_avg: 95993,
-                                main_post_url: "*XA=https://blast.tv/live*XT=https://www.twitch.tv/blastpremier*XB=https://live.bilibili.com/35*XG=playcast://https://gotv.blast.tv/major-a*T=SGTAB*L=2@https://steamcommunity.com/broadcast/watch/76561199492362089",
-                                required_appid_version: 13879,
-                                pricesheet_version: 1688084844,
-                                twitch_streams_version: 2,
-                                active_tournament_eventid: 21,
-                                active_survey_id: 0,
-                                rtime32_cur: 0,
-                                rtime32_event_start: 0
-                            },
-                            penalty_seconds: 0,
-                            penalty_reason: 0,
-                            vac_banned: 0,
-                            ranking: {
-                                account_id: 1080136620,
-                                rank_id: 10,
-                                wins: 209,
-                                rank_change: 0,
-                                rank_type_id: 6,
-                                tv_control: 0
-                            },
-                            commendation: {
-                                cmd_friendly: 149,
-                                cmd_teaching: 108,
-                                cmd_leader: 115
-                            },
-                            medals: null,
-                            my_current_event: null,
-                            my_current_team: null,
-                            survey_vote: 0,
-                            activity: null,
-                            player_level: 4,
-                            player_cur_xp: 327684501,
-                            player_xp_bonus_flags: 0
-                        }
-                        if (result?.global_stats?.required_appid_version && (!CSGO_VER || result.global_stats.required_appid_version > CSGO_VER)) {
-                            CSGO_VER = result.global_stats.required_appid_version
-                        }
-                        callEvent(events.csgoClientHello, result)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientReportResponse: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientReportResponse, payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientCommendPlayerQueryResponse: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientCommendPlayer, payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment, payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchList: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchList, payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GetEventFavorites_Response: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_GetEventFavorites_Response, payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_StartAgreementSessionInGame: {
-
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_ClientDeepStats: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_ClientDeepStats, payload)
-                        break
-                    }
-                    case Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientConnectionStatus: {
-                        const result = protoDecode(Protos.csgo.CMsgConnectionStatus, payload)
-                        break
-                    }
-                    case Protos.csgo.EGCItemMsg.k_EMsgGCStoreGetUserDataResponse: {
-                        const result = protoDecode(Protos.csgo.CMsgStoreGetUserDataResponse, payload)
-                        break
-                    }
-                    case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseFinalizeResponse: {
-                        const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseFinalizeResponse, payload)
-                        break
-                    }
-                    case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseCancelResponse: {
-                        const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseCancelResponse, payload)
-                        break
-                    }
-                    case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseInitResponse: {
-                        const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseInitResponse, payload)
-                        break
-                    }
-                    case Protos.csgo.EMsg.k_EMsgClientMMSCreateLobbyResponse: {
-                        const result = protoDecode(Protos.csgo.CMsgClientMMSCreateLobbyResponse, payload)
-                        console.log("k_EMsgClientMMSCreateLobbyResponse", result);
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientGCRankUpdate: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientGCRankUpdate, payload)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search: {
-                        const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Party_SearchResults, payload)
-                        const entries = _.uniqBy(result.entries, 'id')
-                        //{
-                        //   id: 144900402,
-                        //   grp: 0,
-                        //   game_type: 8,
-                        //   apr: 1,
-                        //   ark: 17,
-                        //   loc: 20041,
-                        //   accountid: 0
-                        // }
-
-
-                        //{
-                        //   id: "76561199265943339",
-                        //   rich_presence: [],
-                        //   persona_state: null,
-                        //   game_played_app_id: null,
-                        //   game_server_ip: null,
-                        //   game_server_port: null,
-                        //   persona_state_flags: null,
-                        //   online_session_instances: null,
-                        //   persona_set_by_user: null,
-                        //   player_name: "杀人不见血",
-                        //   query_port: null,
-                        //   steamid_source: null,
-                        //   avatar_hash: "33994e26f1fe7e2093f8c7dee66c1ac91531050d",
-                        //   last_logoff: null,
-                        //   last_logon: null,
-                        //   last_seen_online: null,
-                        //   clan_rank: null,
-                        //   game_name: null,
-                        //   gameid: null,
-                        //   game_data_blob: null,
-                        //   clan_data: null,
-                        //   clan_tag: null,
-                        //   broadcast_id: null,
-                        //   game_lobby_id: null,
-                        //   watching_broadcast_accountid: null,
-                        //   watching_broadcast_appid: null,
-                        //   watching_broadcast_viewers: null,
-                        //   watching_broadcast_title: null,
-                        //   is_community_banned: null,
-                        //   player_name_pending_review: null,
-                        //   avatar_pending_review: null,
-                        //   avatar_url_icon: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d.jpg",
-                        //   avatar_url_medium: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d_medium.jpg",
-                        //   avatar_url_full: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d_full.jpg"
-                        // }
-
-                        const players = []
-                        for (const player of entries) {
-                            try {
-                                const prime = player.apr === 1 ? 'PRIME' : 'NON-PRIME'
-                                const loc = LOCS[player.loc] || player.loc
-                                const steamId = SteamID.fromIndividualAccountID(player.id).getSteamID64()
-                                const friendCode = FriendCode.encode(steamId)
-
-                                // if ((LOCS[player.loc] == 'VN' || !LOCS[player.loc])) {
-                                players.push({
-                                    prime,
-                                    rank: RANKS[player.ark] !== undefined ? RANKS[player.ark] : player.ark,
-                                    loc,
-                                    steamId,
-                                    friendCode,
-                                })
-                                // }
-                            } catch (e) {
-                            }
-                        }
-
-                        callGCCallback('partySearch', players)
-                        break
-                    }
-                    case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayersProfile: {
-                        let data = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_PlayersProfile, payload)?.account_profiles
-                        const dataExample = [{
-                            my_current_event_teams: [],
-                            my_current_event_stages: [],
-                            rankings: [{
-                                account_id: 1225887169,
-                                rank_id: 0,
-                                wins: 6,
-                                rank_change: 0,
-                                rank_type_id: 7,
-                                tv_control: 0
-                            }, {
-                                account_id: 1225887169,
-                                rank_id: 0,
-                                wins: 0,
-                                rank_change: 0,
-                                rank_type_id: 10,
-                                tv_control: 0
-                            }],
-                            account_id: 1225887169,
-                            ongoingmatch: null,
-                            global_stats: null,
-                            penalty_seconds: 0,
-                            penalty_reason: 0,
-                            vac_banned: 0,
-                            ranking: {
-                                account_id: 1225887169,
-                                rank_id: 8,
-                                wins: 469,
-                                rank_change: 0,
-                                rank_type_id: 6,
-                                tv_control: 0
-                            },
-                            commendation: {
-                                cmd_friendly: 51, cmd_teaching: 40, cmd_leader: 40
-                            },
-                            medals: {
-                                display_items_defidx: [4819, 4737], featured_display_item_defidx: 4819
-                            },
-                            my_current_event: null,
-                            my_current_team: null,
-                            survey_vote: 0,
-                            activity: null,
-                            player_level: 32,
-                            player_cur_xp: 327682846,
-                            player_xp_bonus_flags: 0
-                        }]
-
-                        const player = data?.[0];
-                        if (player) {
-                            player.prime = !!(player.ranking?.account_id || player.player_level || player.player_cur_xp)
-                            player.steamId = SteamID.fromIndividualAccountID(player.account_id).getSteamID64()
-                            callGCCallback('PlayersProfile_' + player.account_id, player)
-                        }
-                        callEvent(events.playersProfile, player)
-                        break
-                    }
-                    default:
-                        log(`receivedFromGC ${msgType} ${key}`)
-                        const results = Object.values(Protos.csgo).map(function (p) {
-                            try {
-                                return protoDecode(p, payload)
-                            } catch (e) {
-                            }
-                        }).filter(function (result) {
-                            return result && Object.keys(result).length
-                        })
-                        log(key, results)
-                }
-            },
-            async loggedOn(loggedOnResponse) {
-                callEvent(events.loggedOn, loggedOnResponse)
-                updateInvisible()
-                updateAutoRequestFreeLicense()
-                updateAutoGamePlay()
-            },
-            async user(steamId, data) {
-                callEvent(events.user, {steamId: steamId.getSteamID64(), data})
-                const dataExample = {
-                    rich_presence: [
-                        {
-                            key: "status",
-                            value: "Competitive Mirage [ 3 : 6 ]"
-                        },
-                        {
-                            key: "version",
-                            value: "13875"
-                        },
-                        {
-                            key: "game:state",
-                            value: "game"
-                        },
-                        {
-                            key: "steam_display",
-                            value: "#display_GameKnownMapScore"
-                        },
-                        {
-                            key: "game:mode",
-                            value: "competitive"
-                        },
-                        {
-                            key: "game:mapgroupname",
-                            value: "mg_de_mirage"
-                        },
-                        {
-                            key: "game:map",
-                            value: "de_mirage"
-                        },
-                        {
-                            key: "game:server",
-                            value: "kv"
-                        },
-                        {
-                            key: "watch",
-                            value: "1"
-                        },
-                        {
-                            key: "steam_player_group",
-                            value: "2134948645"
-                        },
-                        {
-                            key: "game:score",
-                            value: "[ 3 : 6 ]"
-                        }
-                    ],
-                    friendid: "76561199405834425",
-                    persona_state: 1,
-                    game_played_app_id: 730,
-                    game_server_ip: null,
-                    game_server_port: null,
-                    persona_state_flags: 1,
-                    online_session_instances: 1,
-                    persona_set_by_user: null,
-                    player_name: "quỷ súng",
-                    query_port: null,
-                    steamid_source: "0",
-                    avatar_hash: {
-                        type: "Buffer",
-                        data: [
-                            23,
-                            163,
-                            216,
-                            209,
-                            236,
-                            179,
-                            73,
-                            228,
-                            225,
-                            30,
-                            48,
-                            190,
-                            192,
-                            170,
-                            177,
-                            246,
-                            139,
-                            71,
-                            122,
-                            205
-                        ]
-                    },
-                    last_logoff: 1683950268,
-                    last_logon: 1683950281,
-                    last_seen_online: 1683950268,
-                    clan_rank: null,
-                    game_name: "",
-                    gameid: "730",
-                    game_data_blob: {
-                        type: "Buffer",
-                        data: []
-                    },
-                    clan_data: null,
-                    clan_tag: null,
-                    broadcast_id: "0",
-                    game_lobby_id: "0",
-                    watching_broadcast_accountid: null,
-                    watching_broadcast_appid: null,
-                    watching_broadcast_viewers: null,
-                    watching_broadcast_title: null,
-                    is_community_banned: null,
-                    player_name_pending_review: null,
-                    avatar_pending_review: null
-                }
-            },
-            async playingState(playing_blocked, playing_app) {
-                playingBlocked = playing_blocked
-                if (playing_app === 0) {
-                    playing_app = null
-                }
-                if (playing_blocked) {//true, false
-                    console.log("Playing else where")
-                }
-                log('playingState', playing_blocked, playing_app);
-                callEvent(events.playingState, {playing_blocked, playing_app})
-            },
-            async friendRelationship(sid, relationship, previousRelationship) {
-                callEvent(events.friendRelationship, {
-                    steamId: sid.getSteamID64(),
-                    relationship,
-                    previousRelationship
-                })
-                switch (relationship) {
-                    case EFriendRelationship.None: {
-                        //we got unfriended.
-                        break
-                    }
-                    case EFriendRelationship.RequestRecipient: {
-                        //we got invited as a friend
-                        break
-                    }
-                    case EFriendRelationship.Friend: {
-                        //we got added as a friend
-                        break
-                    }
-                }
-            },
-            async tradeOffers(count) {
-                callEvent(events.tradeOffers, count)
-            },
-            async offlineMessages(count, friends) {
-                callEvent(events.offlineMessages, {count, steamIdList: friends})
-            },
-            async tradeRequest(steamID, respond) {
-                if (autoAcceptTradeRequest) {
-                    log(`Incoming trade request from ${steamID.getSteam3RenderedID()}, accepting`);
-                    respond(true);
-                } else {
-                    log(`Incoming trade request from ${steamID.getSteam3RenderedID()}, wating`);
-                }
-            },
-            async friendsList() {
-                callEvent(events.friendsList, getFriendList())
-            },
-            async gifts(gid, packageid, TimeCreated, TimeExpiration, TimeSent, TimeAcked, TimeRedeemed, RecipientAddress, SenderAddress, SenderName) {
-                callEvent(events.gifts, {
-                    gid,
-                    packageid,
-                    TimeCreated,
-                    TimeExpiration,
-                    TimeSent,
-                    TimeAcked,
-                    TimeRedeemed,
-                    RecipientAddress,
-                    SenderAddress,
-                    SenderName
-                })
-            },
-            async emailInfo(address, validated) {
-                callEvent(events.emailInfo, {address, validated})
-            },
-            async appLaunched() {
-                setTimeout(function () {
-                    state = getPlayingAppIds().length ? 'InGame' : (isInvisible ? "Invisible" : 'Online')
-                }, 1000)
-            },
-            async appQuit() {
-                setTimeout(function () {
-                    state = getPlayingAppIds().length ? 'InGame' : (isInvisible ? "Invisible" : 'Online')
-                }, 1000)
-            },
-            async accountLimitations(bis_limited_account, bis_community_banned, bis_locked_account, bis_limited_account_allowed_to_invite_friends) {
-                callEvent(events.accountLimitations, {
-                    limited: bis_limited_account,
-                    communityBanned: bis_community_banned,
-                    locked: bis_locked_account,
-                    canInviteFriends: bis_limited_account_allowed_to_invite_friends
-                })
-            },
-        }
-
-        const _chatEvents = {
-            async friendMessage(data) {
-                if (!data) return
-                data.message_no_bbcode = data.message_no_bbcode?.replaceAll(`ː`, `:`)
-                data.message = data.message?.replaceAll(`ː`, `:`)
-                const example = {
-                    steamid_friend: {
-                        universe: 1,
-                        type: 1,
-                        instance: 1,
-                        accountid: 1080136620
-                    },
-                    chat_entry_type: 1,
-                    from_limited_account: false,
-                    message: "xxx",
-                    ordinal: 0,
-                    local_echo: false,
-                    message_no_bbcode: "xxx",
-                    low_priority: false,
-                    server_timestamp: "2023-05-14T09:26:25.000Z",
-                    message_bbcode_parsed: [
-                        "xxx"
-                    ]
-                }
-                const timestamp = new Date(data.server_timestamp).getTime()
-                const steamId = data.steamid_friend.getSteamID64()
-                const invite = [`Invited you to play a game!`, `Đã mời bạn chơi một trò chơi!`].includes(data.message_no_bbcode || data.message)
-                const emotion = (data.message_no_bbcode || '').split(' ').find(m => m.startsWith(':') && m.endsWith(':'))
-
-                callEvent(events.friendMessage, {
-                    ...data,
-                    message: data.message_no_bbcode,
-                    invite,
-                    steamId,
-                    timestamp,
-                    emotion,
-                })
-            },
-            async friendTyping(steamId, message) {
-                callEvent(events.friendTyping, {
-                    steamId, message
-                })
-            },
-        }
-
-        // steamClient.on('lobbyInvite', (inviterID, lobbyID ) => {
-        //     joinLobby(lobbyID)
-        // })
-
-        // steamClient.on('debug', (msg) => {
-        //     if (!["ClientPersonaState","ClientClanState"].some(c => msg.includes(c))) {
-        //         if(msg.startsWith("Received")){
-        //             console.log(`-------  ${msg}`)
-        //         } else {
-        //             console.log(msg)
-        //         }
-        //     }
-        // })
-
-
-        function getECsgoGCMsgKey(_key) {
-            for (let key in Protos.csgo.ECsgoGCMsg) {
-                if (Protos.csgo.ECsgoGCMsg[key] == _key) {
-                    return key
-                }
-            }
-            for (let key in Protos.csgo.EGCBaseClientMsg) {
-                if (Protos.csgo.EGCBaseClientMsg[key] == _key) {
-                    return key
-                }
-            }
-            for (let key in Protos.csgo.EMsg) {
-                if (Protos.csgo.EMsg[key] == _key) {
-                    return key
-                }
-            }
-            for (let key in Protos.csgo.EGCItemMsg) {
-                if (Protos.csgo.EGCItemMsg[key] == _key) {
-                    return key
-                }
-            }
-        }
-
-
-        for (const [name, _event] of Object.entries(_events)) {
-            steamClient.on(name, _event)
-        }
-
-        for (const [name, _event] of Object.entries(_chatEvents)) {
-            steamClient.chat.on(name, _event)
-        }
-    }
-
-    function getHandlerResult(msg, handler) {
-        const timeout = {current: null}
-        return new Promise(resolve => {
-
-            function myhandler(...args) {
-                timeout.current && clearTimeout(timeout.current)
-                removeHandler()
-                resolve(handler?.(...args))
-            }
-
-            function removeHandler() {
-                if (Array.isArray(steamClient._handlerManager._handlers[msg])) {
-                    const index = steamClient._handlerManager._handlers[msg].findIndex(_handler => _handler === myhandler)
-                    if (index > -1) {
-                        steamClient._handlerManager._handlers[msg].splice(index, 1)
-                    }
-                }
-            }
-
-            timeout.current = setTimeout(function () {
-                removeHandler()
-                resolve()
-            }, 60000)
-            steamClient._handlerManager.add(msg, myhandler);
-        })
-    }
-
-    function getFriendList() {
-        return Object.keys(steamClient.myFriends).filter(steamId => steamClient.myFriends[steamId] === NodeSteamUser.EFriendRelationship.Friend)
-    }
-
-    function sendFriendTyping(steamId, callback) {
-        steamClient.chat.sendFriendTyping(steamId, callback)
-    }
-
-
-    /*
-    * usually take 400 -> 800 miliseconds
-    * */
-    function getPlayersProfile(steamId) {
-        const accountid = new SteamID(steamId).accountid
-        steamClient.sendToGC(730, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile, {}, protoEncode(Protos.csgo.CMsgGCCStrike15_v2_ClientRequestPlayersProfile, {
-            account_id: accountid, // account_id: new SteamID('76561199184696945').accountid,
-            request_level: 32
-        }))
-        return new Promise(resolve => {
-            pushGCCallback('PlayersProfile_' + accountid, resolve, 2000)
-        })
-    }
-
-    async function checkPlayerPrimeStatus(steamId) {
-        const profile = await getPlayersProfile(steamId)
-        if (!profile) return false
-
-        if (profile.ranking?.account_id) {
-            return true
-        }
-
-        if (profile.player_level || profile.player_cur_xp) {
-            return true
-        }
-        return false
-    }
-
-    async function _getStoreSteamPoweredResponse(cookie) {
-        let response = null
-        for (let i = 0; i < 50; i++) {
-            if (!response) {
-                try {
-                    response = (await axios.request({
-                        url: 'https://store.steampowered.com/', headers: {
-                            cookie,
-                            accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.75',
-                        },
-                    }))
-                } catch (e) {
-                    await sleep(1000)
-                }
-            }
-        }
-        return response
-    }
-
-    async function getNewCookie(cookie) {
-        if (!cookie) {
-            return
-        }
-        let response = await _getStoreSteamPoweredResponse(cookie)
-        if (!response) {
-            return
-        }
-        while (Array.isArray(response?.headers?.["set-cookie"])) {
-            console.log(cookie);
-            const cookieObj = cookie.split(';').reduce(function (accumulator, currentValue) {
-                accumulator[currentValue.trim().split('=')[0].trim()] = currentValue.trim().split('=')[1].trim()
-                return accumulator
-            }, {})
-            for (const mcookie of response.headers["set-cookie"]) {
-                const name = mcookie.split('=')[0].trim()
-                const value = mcookie.split('=')[1].split(";")[0].trim()
-                cookieObj[name] = value
-            }
-            cookie = Object.keys(cookieObj).map(name => `${name}=${cookieObj[name]}`).join(';')
-            response = await _getStoreSteamPoweredResponse(cookie)
-        }
-        return cookie
-    }
-
-    async function loginWithCookie(cookie, tryNewCookie = false) {
-        let response;
-        for (let i = 0; i < 20; i++) {
-            try {
-                response = (await axios.request({
-                    url: 'https://steamcommunity.com/chat/clientjstoken',
-                    headers: {
-                        cookie,
-                    },
-                }));
-            } catch (e) {
-                await sleep(1000)
-            }
-            if (response) {
-                break;
-            }
-        }
-
-        const result = response?.data
-        if (result?.logged_in) {
-            Object.assign(result, {
-                steamID: new SteamID(result.steamid), accountName: result.account_name, webLogonToken: result.token
-            })
-            steamClient.logOn(result)
-            return cookie
-        } else {
-            if (tryNewCookie) {
-                log('You are not logged in', cookie)
-                return null
-            } else {
-                const newCookie = await getNewCookie(cookie)
-                if (!newCookie) {
-                    console.error("Cannot get new cookie")
-                    return null
-                } else {
-                    return await loginWithCookie(newCookie, true)
-                }
-            }
-        }
-    }
-
-    async function login(reconnect = false) {
-        if (clientJsToken?.logged_in === true) {
-            log(reconnect ? 'reconnect with clientJsToken' : 'login with clientJsToken')
-            steamClient.logOn(clientJsToken)
-            setTimeout(function () {
-                clientJsToken = null
-            }, 1000)
-            return true
-        } else if (cookie) {
-            log(reconnect ? 'reconnect with cookie' : 'login with cookie')
-            const _clientJsToken = await new SteamUser(typeof cookie === "function" ? await cookie() : cookie).getClientJsToken()
-            if (_clientJsToken?.logged_in === true) {
-                try {
-                    await steamClient.logOn(_clientJsToken)
-                    return true
-                } catch (e) {
-                    return false
-                }
-            } else {
-                return false
-            }
-        } else if (username && password) {
-            log(reconnect ? `reconnect with username ${username}` : `login with username ${username}`)
-            steamClient.logOn({
-                accountName: username, password: password, rememberPassword: true, machineName: 'Natri',
-            })
-            return true
-        }
-    }
-
-    async function logOff() {
-        isLogOff = true
-        logOffEvent?.(true)
-        steamClient.logOff()
-    }
-
-    function onCookie(callback) {
-        if (getCookies()) {
-            callback(getCookies())
-        } else {
-            onEvent('webSession', function (webSession) {
-                callback(webSession?.cookies?.join?.(';'))
-            }, true)
-        }
-    }
-
-    function init() {
-        bindEvent()
-        login()
-
-        steamClient._handlerManager.add(Protos.csgo.EMsg.k_EMsgClientRequestedClientStats, function (payload) {
-            const result = protoDecode(Protos.csgo.CMsgClientRequestedClientStats, payload.toBuffer())
-            // console.log("CMsgClientRequestedClientStats", result);
-        })
-        steamClient._handlerManager.add(Protos.csgo.EMsg.k_EMsgClientMMSLobbyData, function (payload) {
-            const result = protoDecode(Protos.csgo.CMsgClientMMSLobbyData, payload.toBuffer())
-            // console.log("CMsgClientMMSLobbyData", result, result.metadata);
-        })
-    }
-
-
-    function partyRegister() {
-        if (prime === null) {
-            _partyRegister(true)
-            _partyRegister(false)
-        } else {
-            _partyRegister(prime)
-        }
-    }
-
-    function _partyRegister(prime) {
-        log("partyRegister", prime)
-        lastTimePartyRegister = new Date().getTime()
-        steamClient.sendToGC(730, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Register, {}, protoEncode(Protos.csgo.CMsgGCCStrike15_v2_Party_Register, {
-            // id : 0,
-            ver: CSGO_VER,
-            apr: prime ? 1 : 0,//prime
-            ark: prime ? 180 : 0, grps: [], launcher: 0, game_type: 8
-        }))
-    }
-
-    async function sendFriendMessage(steamId, message) {
-        while (sendMessageTimestamp && new Date().getTime() - sendMessageTimestamp < 2000) {
-            await sleep(1000)
-        }
-
-        while (isSendingFriendMessages) {
-            await sleep(5000)
-        }
-
-        isSendingFriendMessages = true
-        const now = new Date().getTime()
-        while (new Date().getTime() - now < 2 * 60000) {//2 minutes
-            const result = await new Promise(resolve => {
-                steamClient.chat.sendFriendMessage(steamId, message, undefined, function (...arg) {
-                    sendMessageTimestamp = new Date().getTime()
-                    resolve(arg)
-                });
-            })
-
-            if (result?.[1]?.server_timestamp) {
-                isSendingFriendMessages = false
-                return result?.[1]
-            } else if (result?.[0]?.message?.includes?.("RateLimitExceeded")) {
-                await sleep(5000)
-            } else {
-                isSendingFriendMessages = false
-                return result
-            }
-        }
-        isSendingFriendMessages = false
-    }
-
-    async function autoRequestFreeLicense(shouldLog = false, max = 10) {
-        return
-        // const mCookies = await getCookiesWait()
-        // if (!mCookies) return
-        // let freeAppList = Array.isArray(steamClient.licenses) ? FreeAppList.filter(appId => steamClient.licenses.every(({package_id}) => package_id !== appId)) : FreeAppList;
-        const freeAppList = freeAppList.filter(appId => ownedApps.some(app => app.appid == appId))
-        const recommendedApps = _.shuffle(freeAppList)
-        if (max) {
-            recommendedApps.length = Math.min(recommendedApps.length, max)
-        }
-        try {
-            const response = await steamClient.requestFreeLicense(recommendedApps)
-            if (shouldLog) {
-                log(response)
-            }
-        } catch (e) {
-            log(e);
-        }
-        // if (Math.random() > 0.7) {
-        //     for (const recommendedApp of recommendedApps) {
-        //         try {
-        //             await steamUtils.requestFreeLicense(recommendedApp)
-        //         } catch (e) {
-        //         }
-        //         await sleep(2000)
-        //     }
-        // } else {
-        //     try {
-        //         await steamClient.requestFreeLicense(recommendedApps)
-        //     } catch (e) {
-        //         log(e);
-        //     }
-        // }
-
-        // if (shouldLog) {
-        //     await sleep(20000)
-        //     const ownedAppsCount2 = (await steamUtils.getDynamicStoreUserData())?.rgOwnedApps?.length || 0
-        //     const increaseNumber = ownedAppsCount2 - ownedAppsCount;
-        //     log(`OwnedApps length ${ownedAppsCount2}, increase ${increaseNumber}`)
-        // }
-    }
-
-    async function playCSGO() {
-        try {
-            await steamClient.requestFreeLicense(AppID)
-            await sleep(5000)
-        } catch (e) {
-        }
-        gamesPlayed(AppID)
-    }
-
-    function doFakeGameScore() {
-        const maxRound = Math.random() > 0.7 ? 16 : 12
-        const maps = [
-            "ar_baggage",
-            "ar_dizzy",
-            "ar_monastery",
-            "ar_shoots",
-            "cs_agency",
-            "cs_assault",
-            "cs_italy",
-            "cs_militia",
-            "cs_office",
-            "de_ancient",
-            "de_anubis",
-            "de_bank",
-            "de_boyard",
-            "de_cache",
-            "de_canals",
-            "de_cbble",
-            "de_chalice",
-            "de_dust2",
-            "de_inferno",
-            "de_lake",
-            "de_mirage",
-            "de_nuke",
-            "de_overpass",
-            "de_safehouse",
-            // "de_shortnuke",
-            "de_stmarc",
-            "de_sugarcane",
-            "de_train",
-            "de_tuscan",
-            "de_vertigo",
-            "dz_ember",
-            "dz_vineyard",
-            "gd_cbble",
-            "training1"
-        ]
-
-        if (richPresence.myScore === undefined) {
-            richPresence.myScore = _.random(0, maxRound)
-        }
-        if (richPresence.theirScore === undefined) {
-            richPresence.theirScore = _.random(0, maxRound)
-        }
-        if (richPresence.map === undefined) {
-            richPresence.map = maps[Math.floor(Math.random() * maps.length)]
-        }
-        if (richPresence.myScore === maxRound || richPresence.theirScore === maxRound) {
-            richPresence.myScore = 0
-            richPresence.theirScore = 0
-            richPresence.map = maps[Math.floor(Math.random() * maps.length)]
-        } else {
-            const isMyTeamWin = Math.random() > 0.5
-            if (isMyTeamWin) {
-                richPresence.myScore++
-            } else {
-                richPresence.theirScore++
-            }
-        }
-
-        const score = richPresence.myScore === 0 && richPresence.theirScore === 0 ? '' : `[ ${richPresence.myScore} : ${richPresence.theirScore} ]`
-        steamClient.uploadRichPresence(730, {
-            'game:state': 'game',
-            steam_display: '#display_GameKnownMapScore',
-            connect: '+gcconnectG082AA752',
-            version: CSGO_VER.toString(),
-            'game:mode': 'competitive',
-            'game:map': richPresence.map,
-            'game:server': 'kv',
-            'watch': _.random(1, 5).toString(),
-            'game:score': score,
-        })
-    }
-
-    function updateFakeGameScore() {
-        if (isFakeGameScore && getPlayingAppIds().some(a => a == 730)) {
-            doSetInterval(doFakeGameScore, [60000, 180000], 'uploadRichPresenceCSGO')
-        } else {
-            doClearInterval('uploadRichPresenceCSGO')
-        }
-    }
-
-    function updateAutoRequestFreeLicense() {
-        if (isAutoRequestFreeLicense) {
-            doSetInterval(function () {
-                autoRequestFreeLicense(false, 50)
-            }, [5 * 60000, 10 * 60000], 'autoRequestFreeLicense')
-        } else {
-            doClearInterval('autoRequestFreeLicense')
-        }
-    }
-
-    function updateInvisible() {
-        if (isInvisible) {
-            steamClient.setPersona(NodeSteamUser.EPersonaState.Invisible)
-            state = 'Invisible'
-        } else {
-            steamClient.setPersona(NodeSteamUser.EPersonaState.Online)
-            state = 'Online'
-        }
-    }
-
-    async function gamesPlayed(apps) {
-        if (!Array.isArray(apps)) {
-            apps = [apps]
-        }
-
-        steamClient.gamesPlayed(apps);
-        const shouldHello = apps.some(app => parseInt(app) === 730);
-        await sleep(1000)
-        if (shouldHello) {
-            await sendHello()
-        }
-        await sleep(1000)
-        if (shouldHello) {
-            await sendHello()
-        }
-        updateFakeGameScore()
-
-        // await sleep(10000)
-        // self.steamUser.uploadRichPresence(730, {
-        //     status: 'bussssss',
-        //     'game:state': 'lobby',
-        //     steam_display: '#display_watch',
-        //     currentmap: '#gamemap_de_empire',
-        //     connect: '+gcconnectG082AA752',
-        //     'game:mode': 'competitive'
-        // })
-    }
-
-    function getFriendsList() {
-        const methodName = "FriendsList.GetFriendsList#1"
-        const {users, myFriends} = steamClient//object
-        /*
-        users
-        * {
-              rich_presence: [],
-              player_name: "Kei #SkinsMonkey",
-              avatar_hash: [123,4543],
-              last_logoff: "2023-05-20T05:00:42.000Z",
-              last_logon: "2023-05-20T05:02:16.000Z",
-              last_seen_online: "2023-05-20T05:00:42.000Z",
-              avatar_url_icon: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/3e/3e9da0b107ac2ec384759544368a8a977359537a.jpg",
-              avatar_url_medium: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/3e/3e9da0b107ac2ec384759544368a8a977359537a_medium.jpg",
-              avatar_url_full: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/3e/3e9da0b107ac2ec384759544368a8a977359537a_full.jpg"
-            }
-        *
-
-        myFriends
-        {
-          76561198365087582: 3,
-          76561199490395123: 3
-        }
-        * */
-        /*steamClient._send({
-            msg: 151,
-            proto: {
-                target_job_name: methodName
-            }
-        }, Buffer.alloc(0), function (body, hdr) {
-            const result = hdr.proto.eresult
-            const errorMessage = hdr.proto.error_message
-            const responseData = body.toBuffer()
-            console.log(`xxx`, result)
-        })*/
-
-        steamClient.sendToGC(730, 767, {}, Buffer.alloc(0))
-    }
-
-    async function getUserOwnedApps(steamId = steamClient.steamID) {
-        if (!steamId) {
-            return []
-        }
-        if (typeof steamId?.getSteamID64 === "function") {
-            steamId = steamId.getSteamID64()
-        }
-        const isMe = steamId === steamClient.steamID.getSteamID64();
-        if (isMe && ownedApps.length) {
-            return ownedApps
-        }
-        let result = {}
-        try {
-            result = await steamClient.getUserOwnedApps(steamId)
-        } catch (e) {
-            try {
-                result = await steamClient.getUserOwnedApps(steamId)
-            } catch (e) {
-                result = {}
-            }
-        }
-        if (isMe && Array.isArray(result.apps)) {
-            ownedApps.length = 0
-            ownedApps.push(...result.apps)
-        }
-        return result.apps || []
-        const resultExample = {
-            app_count: 22,
-            apps: [
-                {
-                    content_descriptorids: [],
-                    appid: 208030,
-                    name: "Moon Breakers",
-                    playtime_2weeks: null,
-                    playtime_forever: 0,
-                    img_icon_url: "",
-                    has_community_visible_stats: null,
-                    playtime_windows_forever: 0,
-                    playtime_mac_forever: 0,
-                    playtime_linux_forever: 0,
-                    rtime_last_played: 0,
-                    capsule_filename: null,
-                    sort_as: null,
-                    has_workshop: null,
-                    has_market: null,
-                    has_dlc: null,
-                    has_leaderboards: null
-                },
-            ]
-        }
-    }
-
-    function getPlayingAppIds() {
-        return steamClient._playingAppIds || []
-    }
-
-    return {
-        init,
-        partySearch,
-        invite2Lobby,
-        createLobby,
-        updateLobby,
-        createThenInvite2Lobby,
-        joinLobby,
-        getLobbyData,
-        partyRegister,
-        requestCoPlays,
-        getPersonas,
-        getUsername() {
-            return username
-        },
-        getCookies,
-        getCookiesWait,
-        getLogOnDetails() {
-            return steamClient?._logOnDetails
-        },
-        onEvent,
-        offEvent,
-        offAllEvent,
-        setPersona(state, name) {
-            steamClient.setPersona(state, name)
-        },
-        sendFriendMessage,
-        sendFriendTyping,
-        getSteamClient() {
-            return steamClient
-        },
-        getAccountInfoName,
-        getPersonaName,
-        async getPlayersProfile(steamId, retry = 3) {
-            for (let i = 0; i < retry; i++) {
-                const profile = await getPlayersProfile(steamId)
-                if (profile) {
-                    return profile
-                }
-            }
-            return null
-        },
-        autoRequestFreeLicense,
-        playCSGO,
-        doSetInterval,
-        doClearIntervals,
-        gamesPlayed,
-        sendHello,
-        checkPlayerPrimeStatus,
-        doClearInterval,
-        gamePlay,
-        autoGamePlay,
-        offAutoGamePlay,
-        updateAutoGamePlay,
-        getFriendsList,
-        setIsPartyRegister(change) {
-            change = !!change
-            if (isPartyRegister !== change) {
-                isPartyRegister = change
-                if (!isPartyRegister) {
-                    doClearInterval('autoPartyRegister')
-                } else {
-                    sendHello()
-                }
-            }
-        },
-        setAutoPlay(change) {
-            change = !!change
-            if (isAutoPlay !== change) {
-                isAutoPlay = change
-                updateAutoGamePlay()
-            }
-        },
-        setIsInvisible(change) {
-            change = !!change
-            if (isInvisible !== change) {
-                isInvisible = change
-                updateInvisible()
-            }
-        },
-        setFakeGameScore(change) {
-            change = !!change
-            if (isFakeGameScore !== change) {
-                isFakeGameScore = change
-                updateFakeGameScore()
-            }
-        },
-        setAutoRequestFreeLicense(change) {
-            change = !!change
-            if (isAutoRequestFreeLicense !== change) {
-                isAutoRequestFreeLicense = change
-                updateAutoRequestFreeLicense()
-            }
-        },
-        getState() {
-            return state
-        },
-        log,
-        isPrime() {
-            return prime === true
-        },
-        getFriendList,
-        logOff,
-        isPlayingBlocked() {
-            return playingBlocked
-        },
-        async getChatHistory(steamId) {
-            if (!steamClient.steamID) return []
-            const mySteamId = typeof steamClient.steamID.getSteamID64 === "function" ? steamClient.steamID.getSteamID64() : steamClient.steamID
-            return new Promise(resolve => {
-                setTimeout(resolve, 90000)
-                steamClient.getChatHistory(steamId, async function (error, result) {
-                    const messages = (result || []).map(function (msg) {
-                        const fromSteamId = typeof msg.steamID?.getSteamID64 === "function" ? msg.steamID.getSteamID64() : msg.steamID
-                        return {
-                            message: msg.message,
-                            from: fromSteamId,
-                            to: fromSteamId == mySteamId ? steamId : mySteamId,
-                            _id: new Date(msg.timestamp).getTime().toString(),
-                            timestamp: new Date(msg.timestamp).getTime(),
-                            isMe: fromSteamId !== steamId
-                        };
-                    })
-                    resolve(messages)
-                })
-            })
-        },
-        onAnyEvent,
-        async redeemGift(gid) {
-            try {
-                const community = new SteamCommunity();
-                let cookies = await getCookiesWait();
-                community.setCookies(typeof cookies === "string" ? cookies.split(';') : cookies)
-                community.redeemGift(gid)
-            } catch (e) {
-            }
-        },
-        async requestFreeLicense(...args) {
-            try {
-                return await steamClient.requestFreeLicense(...args)
-            } catch (e) {
-            }
-        },
-        getSteamId() {
-            try {
-                return steamClient.steamID.getSteamID64()
-            } catch (e) {
-            }
-        },
-        getLastTimePartyRegister() {
-            return lastTimePartyRegister
-        },
-        getLastTimePartySearch() {
-            return lastTimePartySearch
-        },
-        getLicenses() {
-            return steamClient.licenses
-            const exampleLicenses = [{
-                package_id: 303386,
-                time_created: 1680491335,
-                time_next_process: 0,
-                minute_limit: 0,
-                minutes_used: 0,
-                payment_method: 1024,
-                flags: 512,
-                purchase_country_code: "VN",
-                license_type: 1,
-                territory_code: 0,
-                change_number: 20615891,
-                owner_id: 1530068060,
-                initial_period: 0,
-                initial_time_unit: 0,
-                renewal_period: 0,
-                renewal_time_unit: 0,
-                access_token: "8049398090486337961",
-                master_package_id: null
-            }]
-        },
-        uploadRichPresence(appid, richPresence) {
-            if (Array.isArray(richPresence)) {
-                richPresence = richPresence.reduce(function (previousValue, currentValue, currentIndex, array) {
-                    if (currentValue.key) {
-                        previousValue[currentValue.key] = currentValue.value?.toString() || ''
-                    }
-                    return previousValue
-                })
-            }
-            steamClient.uploadRichPresence(appid, richPresence)
-        },
-        getUserOwnedApps,
-        getPlayingAppIds,
-        getCurrentLobby() {
-            return currentLobby
-        }
-    }
-}
-
-export default SteamClient
-
-export function increaseCSGO_VER() {
-    return ++CSGO_VER
-}
-
-SteamClient.isAccountPlayable = async function isAccountPlayable(params, timeoutMs) {
-    let clientJsToken = params.clientJsToken
-    delete params.clientJsToken
-    if(!clientJsToken && params.cookie){
-        clientJsToken = await new SteamUser(typeof params.cookie === "function" ? await params.cookie() : params.cookie).getClientJsToken()
-    }
-    if (clientJsToken?.logged_in !== true) {
-        return false
-    }
-    params.clientJsToken = clientJsToken
-
-    return await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-            doResolve();
-        }, timeoutMs || 30000);
-
-        const steamClient = new SteamClient({
-            isFakeGameScore: false,
-            isAutoPlay: true,
-            isPartyRegister: false,
-            isInvisible: false,
-            MAX_GAME_PLAY: 10,
-            games: 730,
-            ...params,
-        });
-
-        steamClient.onEvent("error", ({eresult, msg, error}) => {
-            doResolve();
-        });
-
-        steamClient.onEvent("csgoOnline", ClientWelcome => {
-            doResolve(ClientWelcome);
-        });
-
-        steamClient.onEvent("csgoClientHello", ClientHello => {
-            doResolve(ClientHello);
-        });
-
-        steamClient.onEvent("playingState", ({playing_blocked, playing_app}) => {
-                if (playing_blocked) {
-                    doResolve();
-                }
-            },
-        );
-
-        steamClient.init();
-
-        function doResolve(data) {
-            clearTimeout(timeout);
-            steamClient.doClearIntervals();
-            steamClient.offAllEvent();
-            steamClient.logOff();
-            return resolve(!!data);
-        }
-    });
-}
+import NodeSteamUser from "steam-user";
+import _ from "lodash";
+import fs from "fs";
+import { protoDecode, protoEncode } from "./helpers/util.js";
+import SteamID from "steamid";
+import FriendCode from "csgo-friendcode";
+import axios from "axios";
+import helpers, { loadProfos } from "./helpers/protos.js";
+import { fileURLToPath } from "url";
+import path from "path";
+import SteamUser from "./index.js";
+import { v4 as uuidv4 } from "uuid";
+import EFriendRelationship from "steam-user/enums/EFriendRelationship.js";
+import SteamCommunity from "steamcommunity";
+import moment from "moment-timezone";
+import { encode, encodeUids } from "./bufferHelpers.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const Protos = helpers([
+  {
+    name: "csgo",
+    protos: loadProfos(`${__dirname}/protos/`),
+  },
+]);
+
+export const RANKS = {
+  0: "Unranked",
+  1: "Silver I",
+  2: "Silver II",
+  3: "Silver III",
+  4: "Silver IV",
+  5: "Silver Elite",
+  6: "Silver Elite Master",
+  7: "Gold Nova I",
+  8: "Gold Nova II",
+  9: "Gold Nova III",
+  10: "Gold Nova Master",
+  11: "Master Guardian I",
+  12: "Master Guardian II",
+  13: "Master Guardian Elite",
+  14: "Distinguished Master Guardian",
+  15: "Legendary Eagle",
+  16: "Legendary Eagle Master",
+  17: "Supreme Master First Class",
+  18: "The Global Elite",
+};
+export const LOCS = {
+  20054: "VN",
+  23115: "KZ",
+  20041: "IN",
+  20035: "CN",
+  17474: "BD",
+  17481: "ID",
+  22861: "MY",
+  18516: "TH",
+  22356: "TW",
+  21067: "KR",
+  19272: "HK",
+  18512: "PH",
+  21842: "RU",
+  16716: "LA",
+  20558: "NP",
+  18259: "SG",
+  19789: "MM",
+  20045: "MN",
+  18251: "KG",
+  18507: "KH",
+  22605: "MX",
+  19280: "PK",
+  20301: "HK/MO", //hongkong or macau
+  21333: "Unknown",
+  21825: "AU",
+  20034: "Unkown",
+};
+
+const AppID = 730;
+export let CSGO_VER = 13960;
+export const FreeAppList = JSON.parse(fs.readFileSync(path.join(__dirname, "free_packages.json"))).packages;
+
+SteamUser.getAppVersion(AppID).then(function (ver) {
+  CSGO_VER = ver;
+});
+
+const PersonasCache = [];
+let isSendingFriendMessages = false;
+
+function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestFreeLicense = true, isFakeGameScore = true, isPartyRegister = true, isAutoPlay = false, isInvisible = false, autoAcceptTradeRequest = false, autoReconnect = true, MAX_GAME_PLAY = 10, games = null }) {
+  const steamClient = new NodeSteamUser();
+  let prime = null;
+  let state = "Offline"; //InGame, Online, Invisible
+  let isLogOff = false;
+  let playingBlocked = null;
+  const richPresence = {};
+  let sendMessageTimestamp = 0;
+  let lastTimePartyRegister = 0;
+  let lastTimePartySearch = 0;
+  const ownedApps = [];
+  let logOffEvent = null;
+
+  const currentLobby = {
+    lobbyID: null,
+    timestamp: 0,
+  };
+
+  const onAnyCallbacks = [];
+
+  const events = {
+    user: [],
+    loggedOn: [],
+    csgoOnline: [],
+    csgoClientHello: [],
+    webSession: [],
+    friendMessage: [],
+    friendTyping: [],
+    disconnected: [],
+    error: [],
+    playersProfile: [],
+    fatalError: [],
+    partyInvite: [],
+    friendRelationship: [],
+    tradeOffers: [],
+    offlineMessages: [],
+    friendsList: [],
+    gifts: [],
+    playingState: [],
+    emailInfo: [],
+    accountLimitations: [],
+  };
+
+  const gcCallback = {};
+
+  function pushGCCallback(name, cb, timeout) {
+    if (!gcCallback[name]) {
+      gcCallback[name] = {};
+    }
+    let t = null;
+    let id = uuidv4();
+
+    function callback(...arg) {
+      if (t) {
+        clearTimeout(t);
+      }
+      delete gcCallback[name][id];
+      cb?.apply(null, arg);
+    }
+
+    if (timeout) {
+      t = setTimeout(callback, timeout);
+    }
+    gcCallback[name][id] = callback;
+  }
+
+  function callGCCallback(name, ...arg) {
+    if (gcCallback[name]) {
+      for (const id in gcCallback[name]) {
+        gcCallback[name][id]?.(...arg);
+      }
+    }
+  }
+
+  function callEvent(_events, data) {
+    const eventName = Object.keys(events).find((eventName) => events[eventName] === _events);
+    eventName && onAnyCallbacks.forEach((cb) => cb?.({ eventName, data }));
+
+    _events?.forEach?.((e) => {
+      e.callback?.(data);
+      e.timeout && clearTimeout(e.timeout);
+      delete e.timeout;
+      if (e.once) {
+        delete e.callback;
+      }
+    });
+    _.remove(_events, (e) => !e || e?.once);
+  }
+
+  function onEvent(name, callback, once, timeout) {
+    if (!events[name]) {
+      events[name] = [];
+    }
+    const t = timeout ? setTimeout(callback, timeout) : null;
+    events[name].push({
+      once,
+      callback,
+      timeout: t,
+    });
+  }
+
+  function offEvent(name) {
+    if (Array.isArray(events[name])) {
+      for (const eventElement of events[name]) {
+        if (eventElement.timeout) {
+          clearTimeout(eventElement.timeout);
+        }
+      }
+    }
+
+    delete events[name];
+  }
+
+  function onAnyEvent(callback) {
+    onAnyCallbacks.push(callback);
+  }
+
+  function offAllEvent() {
+    for (const name in events) {
+      for (const event of events[name]) {
+        if (event.timeout) {
+          try {
+            clearTimeout(event.timeout);
+          } catch (e) {}
+          delete event.timeout;
+        }
+      }
+      delete events[name];
+    }
+    onAnyCallbacks.length = 0;
+  }
+
+  const intervals = {};
+  const intervalRandoms = {};
+
+  function doSetInterval(cb, timeout, key) {
+    const isRandom = Array.isArray(timeout);
+    if (!key) {
+      key = uuidv4();
+    }
+    if (isRandom) {
+      if (intervalRandoms[key] !== undefined) {
+        try {
+          clearTimeout(intervalRandoms[key]);
+        } catch (e) {}
+      }
+      intervalRandoms[key] = setTimeout(
+        function () {
+          doSetInterval(cb, timeout, key);
+          if (state !== "Offline") {
+            cb();
+          }
+        },
+        _.random(timeout[0], timeout[1]),
+      );
+    } else {
+      if (intervals[key] !== undefined) {
+        try {
+          clearInterval(intervals[key]);
+        } catch (e) {}
+      }
+
+      intervals[key] = setInterval(function () {
+        if (state !== "Offline") {
+          cb();
+        }
+      }, timeout);
+    }
+
+    return key;
+  }
+
+  function doClearIntervals() {
+    for (const key in intervals) {
+      clearInterval(intervals[key]);
+      delete intervals[key];
+    }
+    for (const key in intervalRandoms) {
+      clearTimeout(intervalRandoms[key]);
+      delete intervalRandoms[key];
+    }
+  }
+
+  function doClearInterval(key) {
+    try {
+      clearInterval(intervals[key]);
+    } catch (e) {}
+    delete intervals[key];
+
+    try {
+      clearTimeout(intervalRandoms[key]);
+    } catch (e) {}
+    delete intervalRandoms[key];
+  }
+
+  function getAccountInfoName() {
+    return [steamClient?.accountInfo?.name, steamClient?._logOnDetails?.account_name].filter(Boolean).join(" - ");
+  }
+
+  function getPersonaName() {
+    return steamClient?.accountInfo?.name;
+  }
+
+  function log(...msg) {
+    const now = moment().tz("Asia/Ho_Chi_Minh").format("DD/MM/YYYY HH:mm:ss");
+    console.log(`[${now}] [${getAccountInfoName()}]`, ...msg);
+  }
+
+  async function getPersonas(steamIDs) {
+    steamIDs = steamIDs.map((steamId) => (steamId instanceof SteamID ? steamId.getSteamID64() : steamId));
+    const notCachesteamIDs = steamIDs.filter((id) => !PersonasCache.some((p) => p.id == id));
+    const cachedPersonas = PersonasCache.filter((p) => steamIDs.includes(p.id));
+
+    if (notCachesteamIDs.length) {
+      let personas = null;
+      try {
+        personas = (await steamClient.getPersonas(notCachesteamIDs))?.personas;
+      } catch (e) {}
+      if (!personas || !Object.keys(personas).length) {
+        try {
+          personas = (await steamClient.getPersonas(notCachesteamIDs))?.personas;
+        } catch (e) {}
+      }
+      if (!personas || !Object.keys(personas).length) {
+        try {
+          personas = (await steamClient.getPersonas(notCachesteamIDs))?.personas;
+        } catch (e) {}
+      }
+      if (personas && Object.keys(personas).length) {
+        for (let sid64 in personas) {
+          personas[sid64].id = sid64;
+          personas[sid64].avatar_hash = Buffer.from(personas[sid64].avatar_hash).toString("hex");
+          PersonasCache.push(personas[sid64]);
+          cachedPersonas.push(personas[sid64]);
+        }
+      }
+    }
+
+    while (PersonasCache.length > 500) {
+      PersonasCache.shift();
+    }
+    return cachedPersonas;
+  }
+
+  function sleep(ms) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+
+  function getCookies() {
+    return cookie || steamClient?.webSession?.cookies?.join?.(";");
+  }
+
+  async function getCookiesWait() {
+    return (
+      getCookies() ||
+      new Promise((resolve) => {
+        onEvent(
+          "webSession",
+          function (webSession) {
+            resolve(webSession?.cookies);
+          },
+          true,
+          30000,
+        );
+      })
+    );
+  }
+
+  async function gamePlay() {
+    if ((Array.isArray(games) && games.length) || (games && (typeof games === "number" || typeof games === "string"))) {
+      return gamesPlayed(games);
+    }
+
+    let ownedApps = [];
+    for (let i = 0; i < 5; i++) {
+      ownedApps = await getUserOwnedApps();
+      if (ownedApps?.length) {
+        break;
+      }
+    }
+    if (!ownedApps?.length) {
+      gamesPlayed(730);
+    } else {
+      ownedApps = ownedApps.map(({ appid }) => appid);
+      ownedApps = _.shuffle(ownedApps);
+      ownedApps.length = Math.min(ownedApps.length, MAX_GAME_PLAY - 1);
+      _.remove(ownedApps, (app) => app == 730);
+      gamesPlayed([...ownedApps, 730]);
+    }
+  }
+
+  async function autoGamePlay() {
+    await gamePlay();
+    doSetInterval(gamePlay, [15 * 60000, 30 * 60000], "autoGamePlay");
+  }
+
+  async function offAutoGamePlay() {
+    steamClient.gamesPlayed([]);
+    doClearInterval("autoGamePlay");
+  }
+
+  async function updateAutoGamePlay() {
+    if (isAutoPlay) {
+      autoGamePlay();
+    } else {
+      offAutoGamePlay();
+    }
+  }
+
+  /**
+   * Get a list of lobbies (* = Unsure description could be wrong)
+   * @param {Number} ver Game version we are searching for
+   * @param {Boolean} apr Prime or not*
+   * @param {Number} ark Rank multiplied by 10*
+   * @param {Array.<Number>} grps *
+   * @param {Number} launcher If we are using the China CSGO launcher or not*
+   * @param {Number} game_type Game type, 8 Competitive, 10 Wingman
+   * @returns {Promise.<Object>}
+   */
+  async function partySearch({ prime = false, game_type = "Competitive", rank = "Silver Elite", timeout = 5000 } = {}) {
+    const players = await new Promise((resolve) => {
+      steamClient.sendToGC(
+        AppID,
+        Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search,
+        {},
+        protoEncode(Protos.csgo.CMsgGCCStrike15_v2_Party_Search, {
+          ver: CSGO_VER,
+          apr: prime ? 1 : 0,
+          ark: parseInt(Object.keys(RANKS).find((k) => RANKS[k] === rank)) * 10,
+          grps: [],
+          launcher: 0,
+          game_type: game_type === "Competitive" ? 8 : 10,
+        }),
+      );
+      lastTimePartySearch = new Date().getTime();
+      pushGCCallback("partySearch", resolve, timeout);
+    });
+    if (Array.isArray(players) && players.length) {
+      const personas = await getPersonas(players.map((p) => p.steamId));
+      for (const player of players) {
+        const persona = personas.find((p) => p.id == player.steamId);
+        if (persona) {
+          player.player_name = persona.player_name;
+          player.avatar_hash = persona.avatar_hash;
+        }
+      }
+    }
+    return players;
+  }
+
+  async function createLobby() {
+    if (!steamClient.steamID) {
+      return;
+    }
+
+    return new Promise((resolve) => {
+      const timeout = setTimeout(function () {
+        resolve();
+      }, 30000);
+
+      steamClient._send(
+        {
+          msg: Protos.csgo.EMsg.k_EMsgClientMMSCreateLobby,
+          proto: {
+            steamid: steamClient.steamID.getSteamID64(),
+            routing_appid: 730,
+          },
+        },
+        protoEncode(Protos.csgo.CMsgClientMMSCreateLobby, {
+          app_id: 730,
+          max_members: 1,
+          lobby_type: 1,
+          lobby_flags: 1,
+        }),
+        function (payload) {
+          clearTimeout(timeout);
+          const result = protoDecode(Protos.csgo.CMsgClientMMSCreateLobbyResponse, payload.toBuffer());
+          const steam_id_lobby = result.steam_id_lobby.toString();
+          currentLobby.lobbyID = steam_id_lobby;
+          currentLobby.timestamp = new Date().getTime();
+          resolve(steam_id_lobby);
+        },
+      );
+    });
+
+    // return await getHandlerResult(Protos.csgo.EMsg.k_EMsgClientMMSCreateLobbyResponse, function (payload) {
+    //     const result = protoDecode(Protos.csgo.CMsgClientMMSCreateLobbyResponse, payload.toBuffer())
+    //     return result.steam_id_lobby.toString()
+    // })
+
+    // steamClient.sendToGC(730, Protos.csgo.EMsg.k_EMsgClientMMSCreateLobby, {
+    //     steamid: steamClient.steamID,
+    //     routing_appid: 730,
+    // }, protoEncode(Protos.csgo.CMsgClientMMSCreateLobby, {
+    //     app_id: 730,
+    //     max_members: 1,
+    //     lobby_type: 1,
+    //     lobby_flags: 1
+    // }))
+  }
+
+  async function updateLobby(lobbyID) {
+    if (!steamClient.steamID) {
+      return;
+    }
+
+    return new Promise((resolve) => {
+      const timeout = setTimeout(function () {
+        resolve();
+      }, 30000);
+
+      steamClient._send(
+        {
+          msg: Protos.csgo.EMsg.k_EMsgClientMMSSetLobbyData,
+          proto: {
+            steamid: steamClient.steamID.getSteamID64(),
+            routing_appid: 730,
+          },
+        },
+        protoEncode(Protos.csgo.CMsgClientMMSSetLobbyData, {
+          app_id: 730,
+          steam_id_lobby: lobbyID,
+          steam_id_member: "0",
+          max_members: 10,
+          lobby_type: 1,
+          lobby_flags: 1,
+          metadata: encode(
+            {
+              "game:ark": "0",
+              // Country/Message
+              "game:loc": "",
+              "game:mapgroupname": "mg_de_mirage",
+              "game:mode": "competitive",
+              "game:prime": "1",
+              "game:type": "classic",
+              "members:numPlayers": "1",
+              "options:action": "custommatch",
+              "options:anytypemode": "0",
+              "system:access": "private",
+              "system:network": "LIVE",
+              uids: [steamClient.steamID],
+            },
+            [0x00, 0x00],
+            [0x08],
+            { uids: encodeUids },
+          ).toBuffer(),
+        }),
+        function (payload) {
+          clearTimeout(timeout);
+          const result = protoDecode(Protos.csgo.CMsgClientMMSSetLobbyDataResponse, payload.toBuffer());
+          const steam_id_lobby = result.steam_id_lobby.toString();
+          currentLobby.lobbyID = steam_id_lobby;
+          currentLobby.timestamp = new Date().getTime();
+          resolve(steam_id_lobby);
+        },
+      );
+    });
+
+    // return await getHandlerResult(Protos.csgo.EMsg.k_EMsgClientMMSSetLobbyDataResponse, function (payload) {
+    //     const result = protoDecode(Protos.csgo.CMsgClientMMSSetLobbyDataResponse, payload.toBuffer())
+    //     return result.steam_id_lobby.toString()
+    // })
+  }
+
+  async function invite2Lobby(lobbyID, steamId) {
+    if (!steamClient.steamID) {
+      return;
+    }
+
+    steamClient._send(
+      {
+        msg: Protos.csgo.EMsg.k_EMsgClientMMSInviteToLobby,
+        proto: {
+          steamid: steamClient.steamID.getSteamID64(),
+          routing_appid: 730,
+        },
+      },
+      protoEncode(Protos.csgo.CMsgClientMMSInviteToLobby, {
+        app_id: 730,
+        steam_id_lobby: lobbyID,
+        steam_id_user_invited: steamId,
+      }),
+    );
+
+    // lobbyID = new SteamID(lobbyID).accountid;
+
+    // Protos.csgo.EMsg.k_EMsgGCHInviteUserToLobby
+    // Protos.csgo.EMsg.k_EMsgClientMMSInviteToLobby
+    // steamClient.sendToGC(730, Protos.csgo.EMsg.k_EMsgClientMMSInviteToLobby, {}, protoEncode(Protos.csgo.CMsgClientMMSInviteToLobby, {
+    //     app_id: 730,
+    //     steam_id_lobby: lobbyID,
+    //     steam_id_user_invited: accountid,
+    // }), function (...args) {
+    //     console.log("invite2Lobby response", args)
+    // })
+  }
+
+  async function createThenInvite2Lobby(steamIds, onInvite) {
+    if (!steamClient.steamID) {
+      return;
+    }
+
+    if (!Array.isArray(steamIds)) {
+      steamIds = [steamIds];
+    }
+
+    let lobbyID = null;
+    if (currentLobby.lobbyID && currentLobby.timestamp > new Date().getTime() - 30000) {
+      //30 seconds
+      lobbyID = currentLobby.lobbyID;
+    } else {
+      lobbyID = await createLobby();
+      lobbyID = await updateLobby(lobbyID);
+    }
+
+    for (const steamId of steamIds) {
+      onInvite?.(lobbyID, steamId);
+      await invite2Lobby(lobbyID, steamId);
+    }
+
+    return lobbyID;
+  }
+
+  async function getLobbyData(lobbyID) {
+    if (!steamClient.steamID) {
+      return;
+    }
+
+    return new Promise((resolve) => {
+      const timeout = setTimeout(function () {
+        resolve();
+      }, 30000);
+
+      steamClient._send(
+        {
+          msg: Protos.csgo.EMsg.k_EMsgClientMMSGetLobbyData,
+          proto: {
+            steamid: steamClient.steamID.getSteamID64(),
+            routing_appid: 730,
+          },
+        },
+        protoEncode(Protos.csgo.CMsgClientMMSGetLobbyData, {
+          app_id: 730,
+          steam_id_lobby: lobbyID.toString(),
+        }),
+        function (payload) {
+          clearTimeout(timeout);
+          const result = protoDecode(Protos.csgo.CMsgClientMMSLobbyData, payload.toBuffer());
+          result.steam_id_lobby = result.steam_id_lobby.toString();
+          resolve(result);
+        },
+      );
+    });
+  }
+
+  async function joinLobby(lobbyID) {
+    log("joinLobby", lobbyID); //SteamID.fromIndividualAccountID(lobbyId).accountid
+
+    steamClient._send(
+      {
+        msg: Protos.csgo.EMsg.k_EMsgClientMMSJoinLobby,
+        proto: {
+          steamid: steamClient.steamID.getSteamID64(),
+          routing_appid: 730,
+        },
+      }, //CMsgClientMMSUserJoinedLobby CMsgClientMMSJoinLobby
+      protoEncode(Protos.csgo.CMsgClientMMSJoinLobby, {
+        app_id: 730,
+        steam_id_lobby: lobbyID,
+        persona_name: steamClient.accountInfo.name,
+      }),
+      function (payload) {
+        const result = protoDecode(Protos.csgo.CMsgClientMMSJoinLobbyResponse, payload.toBuffer());
+        result.steam_id_lobby = result.steam_id_lobby.toString();
+        result.steam_id_owner = result.steam_id_owner.toString();
+        console.log(result);
+        const resultExample = {
+          members: [],
+          app_id: 730,
+          steam_id_lobby: "3641224920",
+          chat_room_enter_response: 2,
+          max_members: 0,
+          lobby_type: 0,
+          lobby_flags: 0,
+          steam_id_owner: "0",
+          metadata: null, //Buffer
+        };
+      },
+    );
+  }
+
+  async function sendHello() {
+    steamClient.sendToGC(AppID, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingClient2GCHello, {}, Buffer.alloc(0));
+    steamClient.sendToGC(AppID, Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientHello, {}, Buffer.alloc(0));
+  }
+
+  async function requestCoPlays() {
+    return new Promise((resolve) => {
+      steamClient.sendToGC(AppID, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays, {}, Buffer.alloc(0));
+      pushGCCallback("RequestCoPlays", resolve, 30000);
+    });
+  }
+
+  function bindEvent() {
+    const _events = {
+      async disconnected(eresult, msg) {
+        state = "Offline";
+        log("disconnected", eresult, msg);
+
+        callEvent(events.disconnected, { eresult, msg });
+
+        if (["ServiceUnavailable", "NoConnection"].includes(msg) && autoReconnect && !isLogOff) {
+          async function relogin(retry) {
+            if (isLogOff) {
+              console.error("Cannot relogin (logoff)");
+              return false;
+            } else if (retry <= 0) {
+              console.error("Cannot relogin");
+              return false;
+            } else {
+              const isSuccess = await login(true);
+              if (isSuccess) {
+                const loggedOnResponse = await new Promise((resolve) => {
+                  onEvent("loggedOn", resolve, true, 180000);
+                });
+                if (loggedOnResponse) {
+                  console.log("Relogin success");
+                  return true;
+                } else {
+                  const isLogOff = await new Promise((resolve, reject) => {
+                    logOffEvent = resolve;
+                    setTimeout(resolve, 120000);
+                  });
+                  logOffEvent = null;
+                  if (isLogOff === true) {
+                    return false;
+                  }
+                  return await relogin(retry - 1);
+                }
+              } else {
+                const isLogOff = await new Promise((resolve, reject) => {
+                  logOffEvent = resolve;
+                  setTimeout(resolve, 120000);
+                });
+                logOffEvent = null;
+                if (isLogOff === true) {
+                  return false;
+                }
+                return await relogin(retry - 1);
+              }
+            }
+          }
+
+          const isLogOff = await new Promise((resolve, reject) => {
+            logOffEvent = resolve;
+            setTimeout(resolve, 60000);
+          });
+          logOffEvent = null;
+          if (isLogOff === true) {
+            offAllEvent();
+            doClearIntervals();
+          } else {
+            const isSuccess = await relogin(50);
+            if (!isSuccess) {
+              offAllEvent();
+              doClearIntervals();
+            }
+          }
+        } else {
+          offAllEvent();
+          doClearIntervals();
+        }
+      },
+      async error(e) {
+        let errorStr = "";
+        switch (e.eresult) {
+          case 5:
+            errorStr = "Invalid Password";
+            break;
+          case 6:
+          case 34:
+            errorStr = "Logged In Elsewhere";
+            break;
+          case 84:
+            errorStr = "Rate Limit Exceeded";
+            break;
+          case 65:
+            errorStr = "steam guard is invalid";
+            break;
+          default:
+            errorStr = `Unknown: ${e.eresult}`;
+            break;
+        }
+        log(`error [isLogOff: ${isLogOff}]`, e?.message);
+        doClearIntervals();
+        callEvent(events.error, { eresult: e.eresult, msg: e.message, error: errorStr });
+      },
+      async webSession(sessionID, cookies) {
+        const webSession = { sessionID, cookies };
+        steamClient.webSession = webSession;
+        callEvent(events.webSession, webSession);
+      },
+      async receivedFromGC(appid, msgType, payload) {
+        const key = getECsgoGCMsgKey(msgType);
+        switch (msgType) {
+          case Protos.csgo.EMsg.k_EMsgClientChatInvite: {
+            log(payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgClientMMSJoinLobbyResponse: {
+            const msg = protoDecode(Protos.csgo.CMsgClientMMSJoinLobbyResponse, payload);
+            log(msg);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Invite: {
+            const msg = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Party_Invite, payload);
+            const sid64 = SteamID.fromIndividualAccountID(msg.accountid).getSteamID64();
+            if (events.partyInvite?.length) {
+              const personas = await getPersonas([sid64]);
+              const player_name = personas.find((p) => p.id == sid64)?.player_name;
+              if (player_name === undefined) {
+                log(sid64, personas);
+              }
+              callEvent(events.partyInvite, { player_name, steamId: sid64, lobbyId: msg.lobbyid });
+            }
+            // log(player_name, `https://steamcommunity.com/profiles/${sid64}`);
+            // joinLobby(msg.lobbyid, msg.accountid)
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays: {
+            const msg = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Account_RequestCoPlays, payload);
+            const personas = msg.players.map((p) => SteamID.fromIndividualAccountID(p.accountid));
+            callGCCallback("RequestCoPlays", personas);
+            break;
+          }
+          case Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientWelcome: {
+            prime = false;
+            const CMsgClientWelcome = protoDecode(Protos.csgo.CMsgClientWelcome, payload);
+            const obj = {};
+            for (const outofdate_cache of CMsgClientWelcome.outofdate_subscribed_caches) {
+              for (const cache_object of outofdate_cache.objects) {
+                for (const object_data of cache_object.object_data) {
+                  switch (cache_object.type_id) {
+                    case 1: {
+                      const result = protoDecode(Protos.csgo.CSOEconItem, object_data);
+                      result.id = result.id.toNumber();
+                      break;
+                    }
+                    case 2: {
+                      const result = protoDecode(Protos.csgo.CSOPersonaDataPublic, object_data);
+                      obj.PersonaDataPublic = result;
+                      const example = {
+                        player_level: 4,
+                        commendation: {
+                          cmd_friendly: 149,
+                          cmd_teaching: 108,
+                          cmd_leader: 115,
+                        },
+                        elevated_state: true,
+                      };
+                      break;
+                    }
+                    case 5: {
+                      const result = protoDecode(Protos.csgo.CSOItemRecipe, object_data);
+                      break;
+                    }
+                    case 7: {
+                      const CSOEconGameAccountClient = protoDecode(Protos.csgo.CSOEconGameAccountClient, object_data);
+                      const CSOEconGameAccountClientExample = {
+                        additional_backpack_slots: 0,
+                        bonus_xp_timestamp_refresh: 1688518800, //Wednesday 1:00:00 AM every week
+                        bonus_xp_usedflags: 19,
+                        elevated_state: 5,
+                        elevated_timestamp: 5,
+                      }; //1688518800
+                      if ((CSOEconGameAccountClient.bonus_xp_usedflags & 16) != 0) {
+                        // EXPBonusFlag::PrestigeEarned
+                        prime = true;
+                        CSOEconGameAccountClient.prime = true;
+                      }
+                      if (CSOEconGameAccountClient.elevated_state === 5) {
+                        // bought prime
+                        prime = true;
+                        CSOEconGameAccountClient.prime = true;
+                      }
+                      obj.GameAccountClient = CSOEconGameAccountClient;
+                      break;
+                    }
+
+                    case 35: {
+                      // const result =protoDecode(Protos.csgo.CSOSelectedItemPreset, object_data);
+                      break;
+                    }
+
+                    case 36: {
+                      // const result =protoDecode(Protos.csgo.CSOEconItemPresetInstance, object_data);
+                      break;
+                    }
+                    case 38: {
+                      const result = protoDecode(Protos.csgo.CSOEconItemDropRateBonus, object_data);
+                      break;
+                    }
+                    case 39: {
+                      const result = protoDecode(Protos.csgo.CSOEconItemLeagueViewPass, object_data);
+                      break;
+                    }
+                    case 40: {
+                      const result = protoDecode(Protos.csgo.CSOEconItemEventTicket, object_data);
+                      break;
+                    }
+                    case 41: {
+                      const result = protoDecode(Protos.csgo.CSOAccountSeasonalOperation, object_data);
+                      break;
+                    }
+                    case 42: {
+                      // const result =protoDecode(Protos.csgo.CSOEconItemTournamentPassport, object_data);
+                      break;
+                    }
+                    case 43: {
+                      const result = protoDecode(Protos.csgo.CSOEconDefaultEquippedDefinitionInstanceClient, object_data);
+                      const example = {
+                        account_id: 1080136620,
+                        item_definition: 61,
+                        class_id: 3,
+                        slot_id: 2,
+                      };
+                      break;
+                    }
+                    case 45: {
+                      const result = protoDecode(Protos.csgo.CSOEconCoupon, object_data);
+                      break;
+                    }
+                    case 46: {
+                      const result = protoDecode(Protos.csgo.CSOQuestProgress, object_data);
+                      break;
+                    }
+                    case 4: {
+                      const result = protoDecode(Protos.csgo.CSOAccountItemPersonalStore, object_data);
+                      result.generation_time = result.generation_time * 1000;
+                      if (Array.isArray(result.items)) {
+                        result.items = result.items.map((item) => item.toNumber());
+                      }
+                      obj.personalStore = result;
+                      break;
+                    }
+
+                    default: {
+                      log("cache_object.type_id", cache_object.type_id);
+                    }
+                  }
+                }
+              }
+            }
+            callEvent(events.csgoOnline, obj);
+
+            if (isPartyRegister) {
+              partyRegister();
+              doSetInterval(
+                function () {
+                  partyRegister();
+                },
+                [60000, 120000],
+                "autoPartyRegister",
+              );
+            }
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate, payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GC2ClientGlobalStats: {
+            const result = protoDecode(Protos.csgo.CMsgClientUGSGetGlobalStatsResponse, payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientReportPlayer: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientReportPlayer, payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GC2ClientTextMsg: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_GC2ClientTextMsg, payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientHello: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchmakingGC2ClientHello, payload);
+            const example = {
+              my_current_event_teams: [],
+              my_current_event_stages: [],
+              rankings: [],
+              account_id: 1080136620,
+              ongoingmatch: null,
+              global_stats: {
+                search_statistics: [
+                  {
+                    game_type: 520,
+                    search_time_avg: 0,
+                    players_searching: 5141,
+                  },
+                  {
+                    game_type: 32776,
+                    search_time_avg: 0,
+                    players_searching: 6561,
+                  },
+                ],
+                players_online: 617207,
+                servers_online: 230638,
+                players_searching: 13550,
+                servers_available: 126352,
+                ongoing_matches: 23264,
+                search_time_avg: 95993,
+                main_post_url: "*XA=https://blast.tv/live*XT=https://www.twitch.tv/blastpremier*XB=https://live.bilibili.com/35*XG=playcast://https://gotv.blast.tv/major-a*T=SGTAB*L=2@https://steamcommunity.com/broadcast/watch/76561199492362089",
+                required_appid_version: 13879,
+                pricesheet_version: 1688084844,
+                twitch_streams_version: 2,
+                active_tournament_eventid: 21,
+                active_survey_id: 0,
+                rtime32_cur: 0,
+                rtime32_event_start: 0,
+              },
+              penalty_seconds: 0,
+              penalty_reason: 0,
+              vac_banned: 0,
+              ranking: {
+                account_id: 1080136620,
+                rank_id: 10,
+                wins: 209,
+                rank_change: 0,
+                rank_type_id: 6,
+                tv_control: 0,
+              },
+              commendation: {
+                cmd_friendly: 149,
+                cmd_teaching: 108,
+                cmd_leader: 115,
+              },
+              medals: null,
+              my_current_event: null,
+              my_current_team: null,
+              survey_vote: 0,
+              activity: null,
+              player_level: 4,
+              player_cur_xp: 327684501,
+              player_xp_bonus_flags: 0,
+            };
+            if (result?.global_stats?.required_appid_version && (!CSGO_VER || result.global_stats.required_appid_version > CSGO_VER)) {
+              CSGO_VER = result.global_stats.required_appid_version;
+            }
+            callEvent(events.csgoClientHello, result);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientReportResponse: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientReportResponse, payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientCommendPlayerQueryResponse: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientCommendPlayer, payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment, payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchList: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchList, payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GetEventFavorites_Response: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_GetEventFavorites_Response, payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_StartAgreementSessionInGame: {
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_ClientDeepStats: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_ClientDeepStats, payload);
+            break;
+          }
+          case Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientConnectionStatus: {
+            const result = protoDecode(Protos.csgo.CMsgConnectionStatus, payload);
+            break;
+          }
+          case Protos.csgo.EGCItemMsg.k_EMsgGCStoreGetUserDataResponse: {
+            const result = protoDecode(Protos.csgo.CMsgStoreGetUserDataResponse, payload);
+            break;
+          }
+          case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseFinalizeResponse: {
+            const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseFinalizeResponse, payload);
+            break;
+          }
+          case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseCancelResponse: {
+            const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseCancelResponse, payload);
+            break;
+          }
+          case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseInitResponse: {
+            const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseInitResponse, payload);
+            break;
+          }
+          case Protos.csgo.EMsg.k_EMsgClientMMSCreateLobbyResponse: {
+            const result = protoDecode(Protos.csgo.CMsgClientMMSCreateLobbyResponse, payload);
+            console.log("k_EMsgClientMMSCreateLobbyResponse", result);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientGCRankUpdate: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientGCRankUpdate, payload);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search: {
+            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Party_SearchResults, payload);
+            const entries = _.uniqBy(result.entries, "id");
+            //{
+            //   id: 144900402,
+            //   grp: 0,
+            //   game_type: 8,
+            //   apr: 1,
+            //   ark: 17,
+            //   loc: 20041,
+            //   accountid: 0
+            // }
+
+            //{
+            //   id: "76561199265943339",
+            //   rich_presence: [],
+            //   persona_state: null,
+            //   game_played_app_id: null,
+            //   game_server_ip: null,
+            //   game_server_port: null,
+            //   persona_state_flags: null,
+            //   online_session_instances: null,
+            //   persona_set_by_user: null,
+            //   player_name: "杀人不见血",
+            //   query_port: null,
+            //   steamid_source: null,
+            //   avatar_hash: "33994e26f1fe7e2093f8c7dee66c1ac91531050d",
+            //   last_logoff: null,
+            //   last_logon: null,
+            //   last_seen_online: null,
+            //   clan_rank: null,
+            //   game_name: null,
+            //   gameid: null,
+            //   game_data_blob: null,
+            //   clan_data: null,
+            //   clan_tag: null,
+            //   broadcast_id: null,
+            //   game_lobby_id: null,
+            //   watching_broadcast_accountid: null,
+            //   watching_broadcast_appid: null,
+            //   watching_broadcast_viewers: null,
+            //   watching_broadcast_title: null,
+            //   is_community_banned: null,
+            //   player_name_pending_review: null,
+            //   avatar_pending_review: null,
+            //   avatar_url_icon: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d.jpg",
+            //   avatar_url_medium: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d_medium.jpg",
+            //   avatar_url_full: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/33/33994e26f1fe7e2093f8c7dee66c1ac91531050d_full.jpg"
+            // }
+
+            const players = [];
+            for (const player of entries) {
+              try {
+                const prime = player.apr === 1 ? "PRIME" : "NON-PRIME";
+                const loc = LOCS[player.loc] || player.loc;
+                const steamId = SteamID.fromIndividualAccountID(player.id).getSteamID64();
+                const friendCode = FriendCode.encode(steamId);
+
+                // if ((LOCS[player.loc] == 'VN' || !LOCS[player.loc])) {
+                players.push({
+                  prime,
+                  rank: RANKS[player.ark] !== undefined ? RANKS[player.ark] : player.ark,
+                  loc,
+                  steamId,
+                  friendCode,
+                });
+                // }
+              } catch (e) {}
+            }
+
+            callGCCallback("partySearch", players);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayersProfile: {
+            let data = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_PlayersProfile, payload)?.account_profiles;
+            const dataExample = [
+              {
+                my_current_event_teams: [],
+                my_current_event_stages: [],
+                rankings: [
+                  {
+                    account_id: 1225887169,
+                    rank_id: 0,
+                    wins: 6,
+                    rank_change: 0,
+                    rank_type_id: 7,
+                    tv_control: 0,
+                  },
+                  {
+                    account_id: 1225887169,
+                    rank_id: 0,
+                    wins: 0,
+                    rank_change: 0,
+                    rank_type_id: 10,
+                    tv_control: 0,
+                  },
+                ],
+                account_id: 1225887169,
+                ongoingmatch: null,
+                global_stats: null,
+                penalty_seconds: 0,
+                penalty_reason: 0,
+                vac_banned: 0,
+                ranking: {
+                  account_id: 1225887169,
+                  rank_id: 8,
+                  wins: 469,
+                  rank_change: 0,
+                  rank_type_id: 6,
+                  tv_control: 0,
+                },
+                commendation: {
+                  cmd_friendly: 51,
+                  cmd_teaching: 40,
+                  cmd_leader: 40,
+                },
+                medals: {
+                  display_items_defidx: [4819, 4737],
+                  featured_display_item_defidx: 4819,
+                },
+                my_current_event: null,
+                my_current_team: null,
+                survey_vote: 0,
+                activity: null,
+                player_level: 32,
+                player_cur_xp: 327682846,
+                player_xp_bonus_flags: 0,
+              },
+            ];
+
+            const player = data?.[0];
+            if (player) {
+              player.prime = !!(player.ranking?.account_id || player.player_level || player.player_cur_xp);
+              player.steamId = SteamID.fromIndividualAccountID(player.account_id).getSteamID64();
+              callGCCallback(`PlayersProfile_${player.account_id}`, player);
+            }
+            callEvent(events.playersProfile, player);
+            break;
+          }
+          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientLogonFatalError: {
+            const data = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientLogonFatalError, payload);
+            console.log(data);
+            const dataExample = {
+              errorcode: 4,
+              message: "",
+              country: "VN",
+            };
+            callEvent(events.fatalError, data);
+            break;
+          }
+          default:
+            log(`receivedFromGC ${msgType} ${key}`);
+            const results = Object.values(Protos.csgo)
+              .map(function (p) {
+                try {
+                  return protoDecode(p, payload);
+                } catch (e) {}
+              })
+              .filter(function (result) {
+                return result && Object.keys(result).length;
+              });
+            log(key, results);
+        }
+      },
+      async loggedOn(loggedOnResponse) {
+        callEvent(events.loggedOn, loggedOnResponse);
+        updateInvisible();
+        updateAutoRequestFreeLicense();
+        updateAutoGamePlay();
+      },
+      async user(steamId, data) {
+        callEvent(events.user, { steamId: steamId.getSteamID64(), data });
+        const dataExample = {
+          rich_presence: [
+            {
+              key: "status",
+              value: "Competitive Mirage [ 3 : 6 ]",
+            },
+            {
+              key: "version",
+              value: "13875",
+            },
+            {
+              key: "game:state",
+              value: "game",
+            },
+            {
+              key: "steam_display",
+              value: "#display_GameKnownMapScore",
+            },
+            {
+              key: "game:mode",
+              value: "competitive",
+            },
+            {
+              key: "game:mapgroupname",
+              value: "mg_de_mirage",
+            },
+            {
+              key: "game:map",
+              value: "de_mirage",
+            },
+            {
+              key: "game:server",
+              value: "kv",
+            },
+            {
+              key: "watch",
+              value: "1",
+            },
+            {
+              key: "steam_player_group",
+              value: "2134948645",
+            },
+            {
+              key: "game:score",
+              value: "[ 3 : 6 ]",
+            },
+          ],
+          friendid: "76561199405834425",
+          persona_state: 1,
+          game_played_app_id: 730,
+          game_server_ip: null,
+          game_server_port: null,
+          persona_state_flags: 1,
+          online_session_instances: 1,
+          persona_set_by_user: null,
+          player_name: "quỷ súng",
+          query_port: null,
+          steamid_source: "0",
+          avatar_hash: {
+            type: "Buffer",
+            data: [23, 163, 216, 209, 236, 179, 73, 228, 225, 30, 48, 190, 192, 170, 177, 246, 139, 71, 122, 205],
+          },
+          last_logoff: 1683950268,
+          last_logon: 1683950281,
+          last_seen_online: 1683950268,
+          clan_rank: null,
+          game_name: "",
+          gameid: "730",
+          game_data_blob: {
+            type: "Buffer",
+            data: [],
+          },
+          clan_data: null,
+          clan_tag: null,
+          broadcast_id: "0",
+          game_lobby_id: "0",
+          watching_broadcast_accountid: null,
+          watching_broadcast_appid: null,
+          watching_broadcast_viewers: null,
+          watching_broadcast_title: null,
+          is_community_banned: null,
+          player_name_pending_review: null,
+          avatar_pending_review: null,
+        };
+      },
+      async playingState(playing_blocked, playing_app) {
+        playingBlocked = playing_blocked;
+        if (playing_app === 0) {
+          playing_app = null;
+        }
+        if (playing_blocked) {
+          //true, false
+          console.log("Playing else where");
+        }
+        log("playingState", playing_blocked, playing_app);
+        callEvent(events.playingState, { playing_blocked, playing_app });
+      },
+      async friendRelationship(sid, relationship, previousRelationship) {
+        callEvent(events.friendRelationship, {
+          steamId: sid.getSteamID64(),
+          relationship,
+          previousRelationship,
+        });
+        switch (relationship) {
+          case EFriendRelationship.None: {
+            //we got unfriended.
+            break;
+          }
+          case EFriendRelationship.RequestRecipient: {
+            //we got invited as a friend
+            break;
+          }
+          case EFriendRelationship.Friend: {
+            //we got added as a friend
+            break;
+          }
+        }
+      },
+      async tradeOffers(count) {
+        callEvent(events.tradeOffers, count);
+      },
+      async offlineMessages(count, friends) {
+        callEvent(events.offlineMessages, { count, steamIdList: friends });
+      },
+      async tradeRequest(steamID, respond) {
+        if (autoAcceptTradeRequest) {
+          log(`Incoming trade request from ${steamID.getSteam3RenderedID()}, accepting`);
+          respond(true);
+        } else {
+          log(`Incoming trade request from ${steamID.getSteam3RenderedID()}, wating`);
+        }
+      },
+      async friendsList() {
+        callEvent(events.friendsList, getFriendList());
+      },
+      async gifts(gid, packageid, TimeCreated, TimeExpiration, TimeSent, TimeAcked, TimeRedeemed, RecipientAddress, SenderAddress, SenderName) {
+        callEvent(events.gifts, {
+          gid,
+          packageid,
+          TimeCreated,
+          TimeExpiration,
+          TimeSent,
+          TimeAcked,
+          TimeRedeemed,
+          RecipientAddress,
+          SenderAddress,
+          SenderName,
+        });
+      },
+      async emailInfo(address, validated) {
+        callEvent(events.emailInfo, { address, validated });
+      },
+      async appLaunched() {
+        setTimeout(function () {
+          state = getPlayingAppIds().length ? "InGame" : isInvisible ? "Invisible" : "Online";
+        }, 1000);
+      },
+      async appQuit() {
+        setTimeout(function () {
+          state = getPlayingAppIds().length ? "InGame" : isInvisible ? "Invisible" : "Online";
+        }, 1000);
+      },
+      async accountLimitations(bis_limited_account, bis_community_banned, bis_locked_account, bis_limited_account_allowed_to_invite_friends) {
+        callEvent(events.accountLimitations, {
+          limited: bis_limited_account,
+          communityBanned: bis_community_banned,
+          locked: bis_locked_account,
+          canInviteFriends: bis_limited_account_allowed_to_invite_friends,
+        });
+      },
+    };
+
+    const _chatEvents = {
+      async friendMessage(data) {
+        if (!data) return;
+        data.message_no_bbcode = data.message_no_bbcode?.replaceAll("ː", ":");
+        data.message = data.message?.replaceAll("ː", ":");
+        const example = {
+          steamid_friend: {
+            universe: 1,
+            type: 1,
+            instance: 1,
+            accountid: 1080136620,
+          },
+          chat_entry_type: 1,
+          from_limited_account: false,
+          message: "xxx",
+          ordinal: 0,
+          local_echo: false,
+          message_no_bbcode: "xxx",
+          low_priority: false,
+          server_timestamp: "2023-05-14T09:26:25.000Z",
+          message_bbcode_parsed: ["xxx"],
+        };
+        const timestamp = new Date(data.server_timestamp).getTime();
+        const steamId = data.steamid_friend.getSteamID64();
+        const invite = ["Invited you to play a game!", "Đã mời bạn chơi một trò chơi!"].includes(data.message_no_bbcode || data.message);
+        const emotion = (data.message_no_bbcode || "").split(" ").find((m) => m.startsWith(":") && m.endsWith(":"));
+
+        callEvent(events.friendMessage, {
+          ...data,
+          message: data.message_no_bbcode,
+          invite,
+          steamId,
+          timestamp,
+          emotion,
+        });
+      },
+      async friendTyping(steamId, message) {
+        callEvent(events.friendTyping, {
+          steamId,
+          message,
+        });
+      },
+    };
+
+    // steamClient.on('lobbyInvite', (inviterID, lobbyID ) => {
+    //     joinLobby(lobbyID)
+    // })
+
+    // steamClient.on('debug', (msg) => {
+    //     if (!["ClientPersonaState","ClientClanState"].some(c => msg.includes(c))) {
+    //         if(msg.startsWith("Received")){
+    //             console.log(`-------  ${msg}`)
+    //         } else {
+    //             console.log(msg)
+    //         }
+    //     }
+    // })
+
+    function getECsgoGCMsgKey(_key) {
+      for (let key in Protos.csgo.ECsgoGCMsg) {
+        if (Protos.csgo.ECsgoGCMsg[key] == _key) {
+          return key;
+        }
+      }
+      for (let key in Protos.csgo.EGCBaseClientMsg) {
+        if (Protos.csgo.EGCBaseClientMsg[key] == _key) {
+          return key;
+        }
+      }
+      for (let key in Protos.csgo.EMsg) {
+        if (Protos.csgo.EMsg[key] == _key) {
+          return key;
+        }
+      }
+      for (let key in Protos.csgo.EGCItemMsg) {
+        if (Protos.csgo.EGCItemMsg[key] == _key) {
+          return key;
+        }
+      }
+    }
+
+    for (const [name, _event] of Object.entries(_events)) {
+      steamClient.on(name, _event);
+    }
+
+    for (const [name, _event] of Object.entries(_chatEvents)) {
+      steamClient.chat.on(name, _event);
+    }
+  }
+
+  function getHandlerResult(msg, handler) {
+    const timeout = { current: null };
+    return new Promise((resolve) => {
+      function myhandler(...args) {
+        timeout.current && clearTimeout(timeout.current);
+        removeHandler();
+        resolve(handler?.(...args));
+      }
+
+      function removeHandler() {
+        if (Array.isArray(steamClient._handlerManager._handlers[msg])) {
+          const index = steamClient._handlerManager._handlers[msg].findIndex((_handler) => _handler === myhandler);
+          if (index > -1) {
+            steamClient._handlerManager._handlers[msg].splice(index, 1);
+          }
+        }
+      }
+
+      timeout.current = setTimeout(function () {
+        removeHandler();
+        resolve();
+      }, 60000);
+      steamClient._handlerManager.add(msg, myhandler);
+    });
+  }
+
+  function getFriendList() {
+    return Object.keys(steamClient.myFriends).filter((steamId) => steamClient.myFriends[steamId] === NodeSteamUser.EFriendRelationship.Friend);
+  }
+
+  function sendFriendTyping(steamId, callback) {
+    steamClient.chat.sendFriendTyping(steamId, callback);
+  }
+
+  /*
+   * usually take 400 -> 800 miliseconds
+   * */
+  function getPlayersProfile(steamId) {
+    const accountid = new SteamID(steamId).accountid;
+    steamClient.sendToGC(
+      730,
+      Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile,
+      {},
+      protoEncode(Protos.csgo.CMsgGCCStrike15_v2_ClientRequestPlayersProfile, {
+        account_id: accountid, // account_id: new SteamID('76561199184696945').accountid,
+        request_level: 32,
+      }),
+    );
+    return new Promise((resolve) => {
+      pushGCCallback(`PlayersProfile_${accountid}`, resolve, 2000);
+    });
+  }
+
+  async function checkPlayerPrimeStatus(steamId) {
+    const profile = await getPlayersProfile(steamId);
+    if (!profile) return false;
+
+    if (profile.ranking?.account_id) {
+      return true;
+    }
+
+    if (profile.player_level || profile.player_cur_xp) {
+      return true;
+    }
+    return false;
+  }
+
+  async function _getStoreSteamPoweredResponse(cookie) {
+    let response = null;
+    for (let i = 0; i < 50; i++) {
+      if (!response) {
+        try {
+          response = await axios.request({
+            url: "https://store.steampowered.com/",
+            headers: {
+              cookie,
+              accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.75",
+            },
+          });
+        } catch (e) {
+          await sleep(1000);
+        }
+      }
+    }
+    return response;
+  }
+
+  async function getNewCookie(cookie) {
+    if (!cookie) {
+      return;
+    }
+    let response = await _getStoreSteamPoweredResponse(cookie);
+    if (!response) {
+      return;
+    }
+    while (Array.isArray(response?.headers?.["set-cookie"])) {
+      console.log(cookie);
+      const cookieObj = cookie.split(";").reduce(function (accumulator, currentValue) {
+        accumulator[currentValue.trim().split("=")[0].trim()] = currentValue.trim().split("=")[1].trim();
+        return accumulator;
+      }, {});
+      for (const mcookie of response.headers["set-cookie"]) {
+        const name = mcookie.split("=")[0].trim();
+        const value = mcookie.split("=")[1].split(";")[0].trim();
+        cookieObj[name] = value;
+      }
+      cookie = Object.keys(cookieObj)
+        .map((name) => `${name}=${cookieObj[name]}`)
+        .join(";");
+      response = await _getStoreSteamPoweredResponse(cookie);
+    }
+    return cookie;
+  }
+
+  async function loginWithCookie(cookie, tryNewCookie = false) {
+    let response;
+    for (let i = 0; i < 20; i++) {
+      try {
+        response = await axios.request({
+          url: "https://steamcommunity.com/chat/clientjstoken",
+          headers: {
+            cookie,
+          },
+        });
+      } catch (e) {
+        await sleep(1000);
+      }
+      if (response) {
+        break;
+      }
+    }
+
+    const result = response?.data;
+    if (result?.logged_in) {
+      Object.assign(result, {
+        steamID: new SteamID(result.steamid),
+        accountName: result.account_name,
+        webLogonToken: result.token,
+      });
+      steamClient.logOn(result);
+      return cookie;
+    } else {
+      if (tryNewCookie) {
+        log("You are not logged in", cookie);
+        return null;
+      } else {
+        const newCookie = await getNewCookie(cookie);
+        if (!newCookie) {
+          console.error("Cannot get new cookie");
+          return null;
+        } else {
+          return await loginWithCookie(newCookie, true);
+        }
+      }
+    }
+  }
+
+  async function login(reconnect = false) {
+    if (clientJsToken?.logged_in === true) {
+      log(reconnect ? "reconnect with clientJsToken" : "login with clientJsToken");
+      steamClient.logOn(clientJsToken);
+      setTimeout(function () {
+        clientJsToken = null;
+      }, 1000);
+      return true;
+    } else if (cookie) {
+      log(reconnect ? "reconnect with cookie" : "login with cookie");
+      const _clientJsToken = await new SteamUser(typeof cookie === "function" ? await cookie() : cookie).getClientJsToken();
+      if (_clientJsToken?.logged_in === true) {
+        try {
+          await steamClient.logOn(_clientJsToken);
+          return true;
+        } catch (e) {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    } else if (username && password) {
+      log(reconnect ? `reconnect with username ${username}` : `login with username ${username}`);
+      steamClient.logOn({
+        accountName: username,
+        password: password,
+        rememberPassword: true,
+        machineName: "Natri",
+      });
+      return true;
+    }
+  }
+
+  async function logOff() {
+    isLogOff = true;
+    logOffEvent?.(true);
+    steamClient.logOff();
+  }
+
+  function onCookie(callback) {
+    if (getCookies()) {
+      callback(getCookies());
+    } else {
+      onEvent(
+        "webSession",
+        function (webSession) {
+          callback(webSession?.cookies?.join?.(";"));
+        },
+        true,
+      );
+    }
+  }
+
+  function init() {
+    bindEvent();
+    login();
+
+    steamClient._handlerManager.add(Protos.csgo.EMsg.k_EMsgClientRequestedClientStats, function (payload) {
+      const result = protoDecode(Protos.csgo.CMsgClientRequestedClientStats, payload.toBuffer());
+      // console.log("CMsgClientRequestedClientStats", result);
+    });
+    steamClient._handlerManager.add(Protos.csgo.EMsg.k_EMsgClientMMSLobbyData, function (payload) {
+      const result = protoDecode(Protos.csgo.CMsgClientMMSLobbyData, payload.toBuffer());
+      // console.log("CMsgClientMMSLobbyData", result, result.metadata);
+    });
+  }
+
+  function partyRegister() {
+    if (prime === null) {
+      _partyRegister(true);
+      _partyRegister(false);
+    } else {
+      _partyRegister(prime);
+    }
+  }
+
+  function _partyRegister(prime) {
+    log("partyRegister", prime);
+    lastTimePartyRegister = new Date().getTime();
+    steamClient.sendToGC(
+      730,
+      Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Register,
+      {},
+      protoEncode(Protos.csgo.CMsgGCCStrike15_v2_Party_Register, {
+        // id : 0,
+        ver: CSGO_VER,
+        apr: prime ? 1 : 0, //prime
+        ark: prime ? 180 : 0,
+        grps: [],
+        launcher: 0,
+        game_type: 8,
+      }),
+    );
+  }
+
+  async function sendFriendMessage(steamId, message) {
+    while (sendMessageTimestamp && new Date().getTime() - sendMessageTimestamp < 2000) {
+      await sleep(1000);
+    }
+
+    while (isSendingFriendMessages) {
+      await sleep(5000);
+    }
+
+    isSendingFriendMessages = true;
+    const now = new Date().getTime();
+    while (new Date().getTime() - now < 2 * 60000) {
+      //2 minutes
+      const result = await new Promise((resolve) => {
+        steamClient.chat.sendFriendMessage(steamId, message, undefined, function (...arg) {
+          sendMessageTimestamp = new Date().getTime();
+          resolve(arg);
+        });
+      });
+
+      if (result?.[1]?.server_timestamp) {
+        isSendingFriendMessages = false;
+        return result?.[1];
+      } else if (result?.[0]?.message?.includes?.("RateLimitExceeded")) {
+        await sleep(5000);
+      } else {
+        isSendingFriendMessages = false;
+        return result;
+      }
+    }
+    isSendingFriendMessages = false;
+  }
+
+  async function autoRequestFreeLicense(shouldLog = false, max = 10) {
+    return;
+    // const mCookies = await getCookiesWait()
+    // if (!mCookies) return
+    // let freeAppList = Array.isArray(steamClient.licenses) ? FreeAppList.filter(appId => steamClient.licenses.every(({package_id}) => package_id !== appId)) : FreeAppList;
+    const freeAppList = freeAppList.filter((appId) => ownedApps.some((app) => app.appid == appId));
+    const recommendedApps = _.shuffle(freeAppList);
+    if (max) {
+      recommendedApps.length = Math.min(recommendedApps.length, max);
+    }
+    try {
+      const response = await steamClient.requestFreeLicense(recommendedApps);
+      if (shouldLog) {
+        log(response);
+      }
+    } catch (e) {
+      log(e);
+    }
+    // if (Math.random() > 0.7) {
+    //     for (const recommendedApp of recommendedApps) {
+    //         try {
+    //             await steamUtils.requestFreeLicense(recommendedApp)
+    //         } catch (e) {
+    //         }
+    //         await sleep(2000)
+    //     }
+    // } else {
+    //     try {
+    //         await steamClient.requestFreeLicense(recommendedApps)
+    //     } catch (e) {
+    //         log(e);
+    //     }
+    // }
+
+    // if (shouldLog) {
+    //     await sleep(20000)
+    //     const ownedAppsCount2 = (await steamUtils.getDynamicStoreUserData())?.rgOwnedApps?.length || 0
+    //     const increaseNumber = ownedAppsCount2 - ownedAppsCount;
+    //     log(`OwnedApps length ${ownedAppsCount2}, increase ${increaseNumber}`)
+    // }
+  }
+
+  async function playCSGO() {
+    try {
+      await steamClient.requestFreeLicense(AppID);
+      await sleep(5000);
+    } catch (e) {}
+    gamesPlayed(AppID);
+  }
+
+  function doFakeGameScore() {
+    const maxRound = Math.random() > 0.7 ? 16 : 12;
+    const maps = [
+      "ar_baggage",
+      "ar_dizzy",
+      "ar_monastery",
+      "ar_shoots",
+      "cs_agency",
+      "cs_assault",
+      "cs_italy",
+      "cs_militia",
+      "cs_office",
+      "de_ancient",
+      "de_anubis",
+      "de_bank",
+      "de_boyard",
+      "de_cache",
+      "de_canals",
+      "de_cbble",
+      "de_chalice",
+      "de_dust2",
+      "de_inferno",
+      "de_lake",
+      "de_mirage",
+      "de_nuke",
+      "de_overpass",
+      "de_safehouse",
+      // "de_shortnuke",
+      "de_stmarc",
+      "de_sugarcane",
+      "de_train",
+      "de_tuscan",
+      "de_vertigo",
+      "dz_ember",
+      "dz_vineyard",
+      "gd_cbble",
+      "training1",
+    ];
+
+    if (richPresence.myScore === undefined) {
+      richPresence.myScore = _.random(0, maxRound);
+    }
+    if (richPresence.theirScore === undefined) {
+      richPresence.theirScore = _.random(0, maxRound);
+    }
+    if (richPresence.map === undefined) {
+      richPresence.map = maps[Math.floor(Math.random() * maps.length)];
+    }
+    if (richPresence.myScore === maxRound || richPresence.theirScore === maxRound) {
+      richPresence.myScore = 0;
+      richPresence.theirScore = 0;
+      richPresence.map = maps[Math.floor(Math.random() * maps.length)];
+    } else {
+      const isMyTeamWin = Math.random() > 0.5;
+      if (isMyTeamWin) {
+        richPresence.myScore++;
+      } else {
+        richPresence.theirScore++;
+      }
+    }
+
+    const score = richPresence.myScore === 0 && richPresence.theirScore === 0 ? "" : `[ ${richPresence.myScore} : ${richPresence.theirScore} ]`;
+    steamClient.uploadRichPresence(730, {
+      "game:state": "game",
+      steam_display: "#display_GameKnownMapScore",
+      connect: "+gcconnectG082AA752",
+      version: CSGO_VER.toString(),
+      "game:mode": "competitive",
+      "game:map": richPresence.map,
+      "game:server": "kv",
+      watch: _.random(1, 5).toString(),
+      "game:score": score,
+    });
+  }
+
+  function updateFakeGameScore() {
+    if (isFakeGameScore && getPlayingAppIds().some((a) => a == 730)) {
+      doSetInterval(doFakeGameScore, [60000, 180000], "uploadRichPresenceCSGO");
+    } else {
+      doClearInterval("uploadRichPresenceCSGO");
+    }
+  }
+
+  function updateAutoRequestFreeLicense() {
+    if (isAutoRequestFreeLicense) {
+      doSetInterval(
+        function () {
+          autoRequestFreeLicense(false, 50);
+        },
+        [5 * 60000, 10 * 60000],
+        "autoRequestFreeLicense",
+      );
+    } else {
+      doClearInterval("autoRequestFreeLicense");
+    }
+  }
+
+  function updateInvisible() {
+    if (isInvisible) {
+      steamClient.setPersona(NodeSteamUser.EPersonaState.Invisible);
+      state = "Invisible";
+    } else {
+      steamClient.setPersona(NodeSteamUser.EPersonaState.Online);
+      state = "Online";
+    }
+  }
+
+  async function gamesPlayed(apps) {
+    if (!Array.isArray(apps)) {
+      apps = [apps];
+    }
+
+    steamClient.gamesPlayed(apps);
+    const shouldHello = apps.some((app) => parseInt(app) === 730);
+    await sleep(10000);
+    if (shouldHello) {
+      await sendHello();
+    }
+    await sleep(1000);
+    if (shouldHello) {
+      await sendHello();
+    }
+    updateFakeGameScore();
+
+    // await sleep(10000)
+    // self.steamUser.uploadRichPresence(730, {
+    //     status: 'bussssss',
+    //     'game:state': 'lobby',
+    //     steam_display: '#display_watch',
+    //     currentmap: '#gamemap_de_empire',
+    //     connect: '+gcconnectG082AA752',
+    //     'game:mode': 'competitive'
+    // })
+  }
+
+  function getFriendsList() {
+    const methodName = "FriendsList.GetFriendsList#1";
+    const { users, myFriends } = steamClient; //object
+    /*
+        users
+        * {
+              rich_presence: [],
+              player_name: "Kei #SkinsMonkey",
+              avatar_hash: [123,4543],
+              last_logoff: "2023-05-20T05:00:42.000Z",
+              last_logon: "2023-05-20T05:02:16.000Z",
+              last_seen_online: "2023-05-20T05:00:42.000Z",
+              avatar_url_icon: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/3e/3e9da0b107ac2ec384759544368a8a977359537a.jpg",
+              avatar_url_medium: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/3e/3e9da0b107ac2ec384759544368a8a977359537a_medium.jpg",
+              avatar_url_full: "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/3e/3e9da0b107ac2ec384759544368a8a977359537a_full.jpg"
+            }
+        *
+
+        myFriends
+        {
+          76561198365087582: 3,
+          76561199490395123: 3
+        }
+        * */
+    /*steamClient._send({
+            msg: 151,
+            proto: {
+                target_job_name: methodName
+            }
+        }, Buffer.alloc(0), function (body, hdr) {
+            const result = hdr.proto.eresult
+            const errorMessage = hdr.proto.error_message
+            const responseData = body.toBuffer()
+            console.log(`xxx`, result)
+        })*/
+
+    steamClient.sendToGC(730, 767, {}, Buffer.alloc(0));
+  }
+
+  async function getUserOwnedApps(steamId = steamClient.steamID) {
+    if (!steamId) {
+      return [];
+    }
+    if (typeof steamId?.getSteamID64 === "function") {
+      steamId = steamId.getSteamID64();
+    }
+    const isMe = steamId === steamClient.steamID.getSteamID64();
+    if (isMe && ownedApps.length) {
+      return ownedApps;
+    }
+    let result = {};
+    try {
+      result = await steamClient.getUserOwnedApps(steamId);
+    } catch (e) {
+      try {
+        result = await steamClient.getUserOwnedApps(steamId);
+      } catch (e) {
+        result = {};
+      }
+    }
+    if (isMe && Array.isArray(result.apps)) {
+      ownedApps.length = 0;
+      ownedApps.push(...result.apps);
+    }
+    return result.apps || [];
+    const resultExample = {
+      app_count: 22,
+      apps: [
+        {
+          content_descriptorids: [],
+          appid: 208030,
+          name: "Moon Breakers",
+          playtime_2weeks: null,
+          playtime_forever: 0,
+          img_icon_url: "",
+          has_community_visible_stats: null,
+          playtime_windows_forever: 0,
+          playtime_mac_forever: 0,
+          playtime_linux_forever: 0,
+          rtime_last_played: 0,
+          capsule_filename: null,
+          sort_as: null,
+          has_workshop: null,
+          has_market: null,
+          has_dlc: null,
+          has_leaderboards: null,
+        },
+      ],
+    };
+  }
+
+  function getPlayingAppIds() {
+    return steamClient._playingAppIds || [];
+  }
+
+  return {
+    init,
+    partySearch,
+    invite2Lobby,
+    createLobby,
+    updateLobby,
+    createThenInvite2Lobby,
+    joinLobby,
+    getLobbyData,
+    partyRegister,
+    requestCoPlays,
+    getPersonas,
+    getUsername() {
+      return username;
+    },
+    getCookies,
+    getCookiesWait,
+    getLogOnDetails() {
+      return steamClient?._logOnDetails;
+    },
+    onEvent,
+    offEvent,
+    offAllEvent,
+    setPersona(state, name) {
+      steamClient.setPersona(state, name);
+    },
+    sendFriendMessage,
+    sendFriendTyping,
+    getSteamClient() {
+      return steamClient;
+    },
+    getAccountInfoName,
+    getPersonaName,
+    async getPlayersProfile(steamId, retry = 3) {
+      for (let i = 0; i < retry; i++) {
+        const profile = await getPlayersProfile(steamId);
+        if (profile) {
+          return profile;
+        }
+      }
+      return null;
+    },
+    autoRequestFreeLicense,
+    playCSGO,
+    doSetInterval,
+    doClearIntervals,
+    gamesPlayed,
+    sendHello,
+    checkPlayerPrimeStatus,
+    doClearInterval,
+    gamePlay,
+    autoGamePlay,
+    offAutoGamePlay,
+    updateAutoGamePlay,
+    getFriendsList,
+    setIsPartyRegister(change) {
+      change = !!change;
+      if (isPartyRegister !== change) {
+        isPartyRegister = change;
+        if (!isPartyRegister) {
+          doClearInterval("autoPartyRegister");
+        } else {
+          sendHello();
+        }
+      }
+    },
+    setAutoPlay(change) {
+      change = !!change;
+      if (isAutoPlay !== change) {
+        isAutoPlay = change;
+        updateAutoGamePlay();
+      }
+    },
+    setIsInvisible(change) {
+      change = !!change;
+      if (isInvisible !== change) {
+        isInvisible = change;
+        updateInvisible();
+      }
+    },
+    setFakeGameScore(change) {
+      change = !!change;
+      if (isFakeGameScore !== change) {
+        isFakeGameScore = change;
+        updateFakeGameScore();
+      }
+    },
+    setAutoRequestFreeLicense(change) {
+      change = !!change;
+      if (isAutoRequestFreeLicense !== change) {
+        isAutoRequestFreeLicense = change;
+        updateAutoRequestFreeLicense();
+      }
+    },
+    getState() {
+      return state;
+    },
+    log,
+    isPrime() {
+      return prime === true;
+    },
+    getFriendList,
+    logOff,
+    isPlayingBlocked() {
+      return playingBlocked;
+    },
+    async getChatHistory(steamId) {
+      if (!steamClient.steamID) return [];
+      const mySteamId = typeof steamClient.steamID.getSteamID64 === "function" ? steamClient.steamID.getSteamID64() : steamClient.steamID;
+      return new Promise((resolve) => {
+        setTimeout(resolve, 90000);
+        steamClient.getChatHistory(steamId, async function (error, result) {
+          const messages = (result || []).map(function (msg) {
+            const fromSteamId = typeof msg.steamID?.getSteamID64 === "function" ? msg.steamID.getSteamID64() : msg.steamID;
+            return {
+              message: msg.message,
+              from: fromSteamId,
+              to: fromSteamId == mySteamId ? steamId : mySteamId,
+              _id: new Date(msg.timestamp).getTime().toString(),
+              timestamp: new Date(msg.timestamp).getTime(),
+              isMe: fromSteamId !== steamId,
+            };
+          });
+          resolve(messages);
+        });
+      });
+    },
+    onAnyEvent,
+    async redeemGift(gid) {
+      try {
+        const community = new SteamCommunity();
+        let cookies = await getCookiesWait();
+        community.setCookies(typeof cookies === "string" ? cookies.split(";") : cookies);
+        community.redeemGift(gid);
+      } catch (e) {}
+    },
+    async requestFreeLicense(...args) {
+      try {
+        return await steamClient.requestFreeLicense(...args);
+      } catch (e) {}
+    },
+    getSteamId() {
+      try {
+        return steamClient.steamID.getSteamID64();
+      } catch (e) {}
+    },
+    getLastTimePartyRegister() {
+      return lastTimePartyRegister;
+    },
+    getLastTimePartySearch() {
+      return lastTimePartySearch;
+    },
+    getLicenses() {
+      return steamClient.licenses;
+      const exampleLicenses = [
+        {
+          package_id: 303386,
+          time_created: 1680491335,
+          time_next_process: 0,
+          minute_limit: 0,
+          minutes_used: 0,
+          payment_method: 1024,
+          flags: 512,
+          purchase_country_code: "VN",
+          license_type: 1,
+          territory_code: 0,
+          change_number: 20615891,
+          owner_id: 1530068060,
+          initial_period: 0,
+          initial_time_unit: 0,
+          renewal_period: 0,
+          renewal_time_unit: 0,
+          access_token: "8049398090486337961",
+          master_package_id: null,
+        },
+      ];
+    },
+    uploadRichPresence(appid, richPresence) {
+      if (Array.isArray(richPresence)) {
+        richPresence = richPresence.reduce(function (previousValue, currentValue, currentIndex, array) {
+          if (currentValue.key) {
+            previousValue[currentValue.key] = currentValue.value?.toString() || "";
+          }
+          return previousValue;
+        });
+      }
+      steamClient.uploadRichPresence(appid, richPresence);
+    },
+    getUserOwnedApps,
+    getPlayingAppIds,
+    getCurrentLobby() {
+      return currentLobby;
+    },
+  };
+}
+
+export default SteamClient;
+
+export function increaseCSGO_VER() {
+  return ++CSGO_VER;
+}
+
+SteamClient.isAccountPlayable = async function isAccountPlayable(params, timeoutMs) {
+  let clientJsToken = params.clientJsToken;
+  delete params.clientJsToken;
+  if (!clientJsToken && params.cookie) {
+    clientJsToken = await new SteamUser(typeof params.cookie === "function" ? await params.cookie() : params.cookie).getClientJsToken();
+  }
+  if (clientJsToken?.logged_in !== true) {
+    return false;
+  }
+  params.clientJsToken = clientJsToken;
+
+  return await new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      doResolve();
+    }, timeoutMs || 30000);
+
+    const steamClient = new SteamClient({
+      isFakeGameScore: false,
+      isAutoPlay: true,
+      isPartyRegister: false,
+      isInvisible: false,
+      MAX_GAME_PLAY: 10,
+      games: 730,
+      ...params,
+    });
+
+    steamClient.onEvent("error", ({ eresult, msg, error }) => {
+      doResolve();
+    });
+
+    steamClient.onEvent("csgoOnline", (ClientWelcome) => {
+      doResolve(ClientWelcome);
+    });
+
+    steamClient.onEvent("csgoClientHello", (ClientHello) => {
+      doResolve(ClientHello);
+    });
+
+    steamClient.onEvent("playingState", ({ playing_blocked, playing_app }) => {
+      if (playing_blocked) {
+        doResolve();
+      }
+    });
+
+    steamClient.onEvent("fatalError", () => {
+      doResolve();
+    });
+
+    steamClient.init();
+
+    function doResolve(data) {
+      clearTimeout(timeout);
+      steamClient.doClearIntervals();
+      steamClient.offAllEvent();
+      steamClient.logOff();
+      return resolve(!!data);
+    }
+  });
+};