steamutils 1.4.63 → 1.4.65

package/SteamClient.js

@@ -90,11 +90,11 @@ export const SteamClientEvents = {
   accountLimitations: "accountLimitations",
   wallet: "wallet",
   licenses: "licenses",
+  logOff: "logOff",
 };
-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 }) {
+function SteamClient({ username, cookie, clientJsToken, isAutoRequestFreeLicense = true, isFakeGameScore = true, isPartyRegister = true, isAutoPlay = false, isInvisible = false, autoAcceptTradeRequest = false, autoReconnect = true, games = null }) {
   const steamClient = new NodeSteamUser();
   let prime = null;
   let state = "Offline"; //InGame, Online, Invisible
@@ -104,7 +104,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   let lastTimePartyRegister = 0;
   let lastTimePartySearch = 0;
   const ownedApps = [];
-  let logOffEvent = null;
+  const logOffEvents = {};
   let _cleanNodeSteamUserTimeout = null;
   let _cleanNodeSteamLicensesTimeout = null;
   let _cleanNodeSteamFriendTimeout = null;
@@ -119,79 +119,191 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
   const onAnyCallbacks = [];
 
-  const events = { ...SteamClientEvents };
+  /**
+   * @type {Object.<string, Array>}
+   * @property {Array} user
+   * @property {Array} loggedOn
+   * @property {Array} csgoOnline
+   * @property {Array} csgoClientHello
+   * @property {Array} webSession
+   * @property {Array} friendMessage
+   * @property {Array} friendTyping
+   * @property {Array} disconnected
+   * @property {Array} error
+   * @property {Array} playersProfile
+   * @property {Array} fatalError
+   * @property {Array} partyInvite
+   * @property {Array} friendRelationship
+   * @property {Array} tradeOffers
+   * @property {Array} offlineMessages
+   * @property {Array} friendsList
+   * @property {Array} gifts
+   * @property {Array} playingState
+   * @property {Array} emailInfo
+   * @property {Array} accountLimitations
+   * @property {Array} wallet
+   * @property {Array} licenses
+   * @property {Array} logOff
+   */
+  const events = {};
   for (const name in SteamClientEvents) {
     events[name] = [];
   }
 
-  const gcCallback = {};
+  /**
+   * @typedef {Object} GCEvents
+   * @property {Array} requestJoinFriendData
+   * @property {Array} requestCoPlays
+   * @property {Array} partySearch
+   * @property {Array} playersProfile
+   *
+   * @type {GCEvents}
+   */
+  const gcEvents = {
+    requestJoinFriendData: [],
+    requestCoPlays: [],
+    partySearch: [],
+    playersProfile: [],
+  };
 
-  function pushGCCallback(name, cb, timeout) {
-    if (!gcCallback[name]) {
-      gcCallback[name] = {};
+  function onGCEvent({ name, id, key, callback, timeoutMs }) {
+    if (typeof name !== "string") {
+      name = Object.keys(gcEvents).find((k) => gcEvents[k] === name);
     }
-    let t = null;
-    let id = uuidv4();
 
-    function callback(...arg) {
-      if (t) {
-        clearTimeout(t);
-      }
-      delete gcCallback[name][id];
-      cb?.apply(null, arg);
+    if (!gcEvents[name]) {
+      gcEvents[name] = [];
+    }
+    if (!id) {
+      id = uuidv4();
     }
+    const timeout = timeoutMs
+      ? setTimeout(function () {
+          callback?.();
+          clearGCCallback(id);
+        }, timeoutMs)
+      : null;
+
+    gcEvents[name].push({
+      id,
+      key,
+      timeout,
+      callback,
+    });
+    return id;
+  }
 
-    if (timeout) {
-      t = setTimeout(callback, timeout);
+  function clearGCCallback(name) {
+    for (const [eventName, events] of Object.entries(gcEvents)) {
+      if (eventName === name) {
+        for (const event of events) {
+          if (event.timeout) {
+            clearTimeout(event.timeout);
+          }
+        }
+        events.length = 0;
+      } else {
+        const removedEvents = _.remove(events, function (e) {
+          return Object.values(e).some((v) => v === name);
+        });
+        for (const removedEvent of removedEvents) {
+          if (removedEvent.timeout) {
+            clearTimeout(removedEvent.timeout);
+          }
+        }
+      }
     }
-    gcCallback[name][id] = callback;
   }
 
-  function callGCCallback(name, ...arg) {
-    if (gcCallback[name]) {
-      for (const id in gcCallback[name]) {
-        gcCallback[name][id]?.(...arg);
+  async function callGCCallback({ name, data, key }) {
+    if (typeof name !== "string") {
+      name = Object.keys(gcEvents).find((k) => gcEvents[k] === name);
+    }
+
+    if (!Array.isArray(gcEvents[name])) {
+      return;
+    }
+
+    const removedEvents = _.remove(gcEvents[name], (item) => !key || item.key === key);
+    let _data = null;
+    let calculated = false;
+
+    for (const removedEvent of removedEvents) {
+      if (removedEvent.timeout) {
+        clearTimeout(removedEvent.timeout);
+        delete removedEvent.timeout;
+      }
+
+      if (!calculated) {
+        calculated = true;
+        _data = typeof data === "function" ? await data() : data;
       }
+
+      removedEvent.callback(_data);
     }
   }
 
-  function callEvent(_events, data) {
-    const eventName = Object.keys(events).find((eventName) => events[eventName] === _events);
-    eventName && onAnyCallbacks.forEach((cb) => cb?.({ eventName, data }));
+  function callEvent(name, data) {
+    if (typeof name !== "string") {
+      name = Object.keys(events).find((eventName) => events[eventName] === name);
+    }
 
-    _events?.forEach?.((e) => {
+    const _events = events[name];
+    onAnyCallbacks.forEach((cb) => cb?.({ eventName: name, data }));
+    _events.forEach((e) => {
+      clearTimeout(e.timeout);
       e.callback?.(data);
-      e.timeout && clearTimeout(e.timeout);
-      delete e.timeout;
-      if (e.once) {
-        delete e.callback;
-      }
     });
-    _.remove(_events, (e) => !e || e?.once);
+    _.remove(_events, (e) => !e || e.once);
   }
 
-  function onEvent(name, callback, once, timeout) {
+  function onEvent({ name, id, callback, once, timeout }) {
     if (!events[name]) {
       events[name] = [];
     }
-    const t = timeout ? setTimeout(callback, timeout) : null;
+    if (!id) {
+      id = uuidv4();
+    }
+    const t = timeout
+      ? setTimeout(function () {
+          try {
+            callback?.();
+          } catch (e) {}
+          if (once) {
+            offEvent(id);
+          }
+        }, timeout)
+      : null;
     events[name].push({
+      id,
       once,
       callback,
       timeout: t,
     });
+    return id;
   }
 
+  // name, id, callback
   function offEvent(name) {
-    if (Array.isArray(events[name])) {
-      for (const eventElement of events[name]) {
-        if (eventElement.timeout) {
-          clearTimeout(eventElement.timeout);
+    for (const [eventName, _events] of Object.entries(events)) {
+      if (eventName === name) {
+        for (const event of _events) {
+          if (event.timeout) {
+            clearTimeout(event.timeout);
+          }
+        }
+        _events.length = 0;
+      } else {
+        const removedEvents = _.remove(_events, function (e) {
+          return Object.values(e).some((v) => v === name);
+        });
+        for (const removedEvent of removedEvents) {
+          if (removedEvent.timeout) {
+            clearTimeout(removedEvent.timeout);
+          }
         }
       }
     }
-
-    events[name] = [];
   }
 
   function onAnyEvent(callback) {
@@ -208,7 +320,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
           delete event.timeout;
         }
       }
-      events[name] = [];
+      events[name].length = 0;
     }
     onAnyCallbacks.length = 0;
   }
@@ -289,7 +401,13 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     console.log(`[${now}] [${getAccountInfoName()}]`, ...msg);
   }
 
+  function error(...msg) {
+    const now = moment().tz("Asia/Ho_Chi_Minh").format("DD/MM/YYYY HH:mm:ss");
+    console.error(`[${now}] [${getAccountInfoName()}]`, ...msg);
+  }
+
   async function getPersonas(steamIDs) {
+    if (isLogOff) return [];
     if (!steamIDs) return [];
     if (!Array.isArray(steamIDs)) {
       steamIDs = [steamIDs];
@@ -352,22 +470,28 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function getCookiesWait() {
+    if (isLogOff) {
+      return;
+    }
     return (
       getCookies() ||
       new Promise((resolve) => {
-        onEvent(
-          "webSession",
-          function (webSession) {
+        onEvent({
+          name: "webSession",
+          callback: function (webSession) {
             resolve(webSession?.cookies);
           },
-          true,
-          30000,
-        );
+          once: true,
+          timeout: 30000,
+        });
       })
     );
   }
 
   async function gamePlay() {
+    if (isLogOff) {
+      return;
+    }
     return await gamesPlayed(730);
   }
 
@@ -383,9 +507,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
   async function updateAutoGamePlay() {
     if (isAutoPlay) {
-      autoGamePlay();
+      await autoGamePlay();
     } else {
-      offAutoGamePlay();
+      await offAutoGamePlay();
     }
   }
 
@@ -398,6 +522,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
    * @returns {Promise.<Array>}
    */
   async function partySearch({ prime = false, game_type = "Premier", rank, timeout = 5000 } = {}) {
+    if (isLogOff) {
+      return;
+    }
     const gameTypeMap = {
       Competitive: 8,
       Wingman: 10,
@@ -408,23 +535,33 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
       rank = parseInt(Object.keys(RANKS).find((k) => RANKS[k] === rank)) * 10;
     }
 
-    const players = await new Promise((resolve) => {
-      steamClient.sendToGC(
-        AppID,
-        ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search,
-        {},
-        new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_Search).protoEncode({
-          ver: CSGO_VER,
-          apr: prime ? 1 : 0,
-          ark: rank,
-          grps: [],
-          launcher: 0, // If we are using the China CSGO launcher or not*
-          game_type: gameTypeMap[game_type],
-        }),
-      );
-      lastTimePartySearch = Date.now();
-      pushGCCallback("partySearch", resolve, timeout);
-    });
+    const gcEventId = uuidv4();
+    const players = await ensureLogin(
+      new Promise((resolve) => {
+        lastTimePartySearch = Date.now();
+        onGCEvent({
+          name: gcEvents.partySearch,
+          id: gcEventId,
+          callback: resolve,
+          timeoutMs: timeout,
+        });
+        steamClient.sendToGC(
+          AppID,
+          ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search,
+          {},
+          new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_Search).protoEncode({
+            ver: CSGO_VER,
+            apr: prime ? 1 : 0,
+            ark: rank,
+            grps: [],
+            launcher: 0, // If we are using the China CSGO launcher or not*
+            game_type: gameTypeMap[game_type],
+          }),
+        );
+      }),
+    );
+    clearGCCallback(gcEventId);
+
     if (Array.isArray(players) && players.length) {
       const personas = await getPersonas(players.map((p) => p.steamId));
       for (const player of players) {
@@ -434,11 +571,14 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
           player.avatar_hash = persona.avatar_hash;
         }
       }
+      return players;
     }
-    return players;
   }
 
   async function createLobby() {
+    if (isLogOff) {
+      return;
+    }
     if (!steamClient.steamID) {
       return;
     }
@@ -490,6 +630,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function updateLobby(lobbyID) {
+    if (isLogOff) {
+      return;
+    }
     if (!steamClient.steamID) {
       return;
     }
@@ -553,6 +696,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function invite2Lobby(lobbyID, steamId) {
+    if (isLogOff) {
+      return;
+    }
     if (!steamClient.steamID) {
       return;
     }
@@ -586,6 +732,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function createThenInvite2Lobby(steamIds, onInvite) {
+    if (isLogOff) {
+      return;
+    }
     if (!steamClient.steamID) {
       return;
     }
@@ -612,6 +761,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function getLobbyData(lobbyID) {
+    if (isLogOff) {
+      return;
+    }
     if (!steamClient.steamID) {
       return;
     }
@@ -644,6 +796,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function joinLobby(lobbyID) {
+    if (isLogOff) {
+      return;
+    }
     log("joinLobby", lobbyID); //SteamID.fromIndividualAccountID(lobbyId).accountid
 
     steamClient._send(
@@ -680,6 +835,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function sendHello() {
+    if (isLogOff) {
+      return;
+    }
     steamClient.sendToGC(AppID, ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingClient2GCHello, {}, Buffer.alloc(0));
     // steamClient.sendToGC(AppID, ESteamProto.EGCBaseClientMsg.k_EMsgGCClientHello, {}, Buffer.alloc(0));
 
@@ -697,10 +855,23 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function requestCoPlays() {
-    return new Promise((resolve) => {
-      steamClient.sendToGC(AppID, ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays, {}, Buffer.alloc(0));
-      pushGCCallback("RequestCoPlays", resolve, 30000);
-    });
+    if (isLogOff) {
+      return;
+    }
+    const gcEventId = uuidv4();
+    const response = await ensureLogin(
+      new Promise((resolve) => {
+        onGCEvent({
+          name: gcEvents.requestCoPlays,
+          id: gcEventId,
+          callback: resolve,
+          timeoutMs: 30000,
+        });
+        steamClient.sendToGC(AppID, ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays, {}, Buffer.alloc(0));
+      }),
+    );
+    clearGCCallback(gcEventId);
+    return response;
   }
 
   function bindEvent() {
@@ -712,62 +883,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
         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(SteamClientEvents.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();
-            }
-          }
+          reLogin();
         } else {
           offAllEvent();
           doClearIntervals();
@@ -802,7 +918,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
         steamClient.webSession = webSession;
         callEvent(events.webSession, webSession);
       },
-      async receivedFromGC(appid, msgType, payload) {
+      receivedFromGC: async function (appid, msgType, payload) {
         const key = getECsgoGCMsgKey(msgType);
         switch (msgType) {
           case ESteamProto.EMsg.k_EMsgClientChatInvite: {
@@ -830,9 +946,13 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
             break;
           }
           case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays: {
-            const msg = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Account_RequestCoPlays).protoDecode(payload);
-            const personas = msg.players.map((p) => SteamID.fromIndividualAccountID(p.accountid));
-            callGCCallback("RequestCoPlays", personas);
+            callGCCallback({
+              name: gcEvents.requestCoPlays,
+              data() {
+                const msg = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Account_RequestCoPlays).protoDecode(payload);
+                return msg.players.map((p) => SteamID.fromIndividualAccountID(p.accountid));
+              },
+            });
             break;
           }
           case ESteamProto.EGCBaseClientMsg.k_EMsgGCClientWelcome: {
@@ -1127,79 +1247,83 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
             break;
           }
           case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search: {
-            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_SearchResults).protoDecode(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 = [];
-            if (entries.length) {
-              const FriendCode = (await import("csgo-friendcode")).default;
-              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);
+            callGCCallback({
+              name: gcEvents.partySearch,
+              async data() {
+                const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_SearchResults).protoDecode(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 = [];
+                if (entries.length) {
+                  const FriendCode = (await import("csgo-friendcode")).default;
+                  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) {}
+                  }
+                }
+                return players;
+              },
+            });
             break;
           }
           case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayersProfile: {
@@ -1270,7 +1394,11 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
                   player.elo = ranking.rank_id;
                 }
               }
-              callGCCallback(`PlayersProfile_${player.account_id}`, player);
+              callGCCallback({
+                name: gcEvents.playersProfile,
+                data: player,
+                key: player.account_id,
+              });
             }
             callEvent(events.playersProfile, player);
             break;
@@ -1298,7 +1426,11 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
               res: null,
               errormsg: "Game is full",
             };
-            callGCCallback(`requestJoinFriendData_${data.account_id}`, data);
+            callGCCallback({
+              name: gcEvents.requestJoinFriendData,
+              data,
+              key: data.account_id,
+            });
             break;
           }
           default:
@@ -1316,6 +1448,36 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
         }
       },
       async loggedOn(loggedOnResponse) {
+        const example = {
+          eresult: 1,
+          legacy_out_of_game_heartbeat_seconds: 9,
+          heartbeat_seconds: 9,
+          deprecated_public_ip: 250140346,
+          rtime32_server_time: 1727758337,
+          account_flags: 2642053,
+          cell_id: 71,
+          email_domain: null,
+          steam2_ticket: null,
+          eresult_extended: null,
+          webapi_authenticate_user_nonce: null,
+          cell_id_ping_threshold: 2147483647,
+          deprecated_use_pics: null,
+          vanity_url: "",
+          public_ip: {
+            v4: 250140346,
+          },
+          client_supplied_steamid: "76561190347696",
+          ip_country_code: "VN",
+          parental_settings: null,
+          parental_setting_signature: null,
+          count_loginfailures_to_migrate: 0,
+          count_disconnects_to_migrate: 0,
+          ogs_data_report_time_window: null,
+          client_instance_id: "4130450042302948",
+          force_client_update_check: false,
+          agreement_session_url: null,
+          token_id: null,
+        };
         callEvent(events.loggedOn, loggedOnResponse);
         updateInvisible();
         updateAutoRequestFreeLicense();
@@ -1657,29 +1819,49 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   function sendFriendTyping(steamId, callback) {
+    if (isLogOff) {
+      return;
+    }
     steamClient.chat.sendFriendTyping(steamId, callback);
   }
 
   /*
    * usually take 400 -> 800 miliseconds
    * */
-  function getPlayersProfile(steamId) {
+  async function getPlayersProfile(steamId) {
+    if (isLogOff) {
+      return;
+    }
     const accountid = new SteamID(steamId).accountid;
-    steamClient.sendToGC(
-      730,
-      ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile,
-      {},
-      new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestPlayersProfile).protoEncode({
-        account_id: accountid, // account_id: new SteamID('76561199184696945').accountid,
-        request_level: 32,
+    const gcEventId = uuidv4();
+    const result = await ensureLogin(
+      new Promise((resolve) => {
+        onGCEvent({
+          name: gcEvents.playersProfile,
+          key: accountid,
+          id: gcEventId,
+          callback: resolve,
+          timeoutMs: 5000,
+        });
+        steamClient.sendToGC(
+          730,
+          ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile,
+          {},
+          new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestPlayersProfile).protoEncode({
+            account_id: accountid, // account_id: new SteamID('76561199184696945').accountid,
+            request_level: 32,
+          }),
+        );
       }),
     );
-    return new Promise((resolve) => {
-      pushGCCallback(`PlayersProfile_${accountid}`, resolve, 2000);
-    });
+    clearGCCallback(gcEventId);
+    return result;
   }
 
   async function checkPlayerPrimeStatus(steamId) {
+    if (isLogOff) {
+      return;
+    }
     const profile = await getPlayersProfile(steamId);
     if (!profile) return false;
 
@@ -1783,23 +1965,114 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     }
   }
 
-  async function login(reconnect = false) {
-    function logOn(clientJsToken) {
-      try {
-        steamClient.logOn({
-          ...clientJsToken,
-          steamId: new SteamID(clientJsToken.steamid),
-          steamID: new SteamID(clientJsToken.steamid),
-          accountName: clientJsToken.account_name,
-          webLogonToken: clientJsToken.token,
-        });
-        return true;
-      } catch (e) {
-        console.error(e);
-        return false;
-      }
+  /**
+   * Logs on to the Steam client using the provided token.
+   *
+   * @async
+   * @function logOn
+   *
+   * @param {Object} [token] - The token object containing credentials and other information. Defaults to a pre-filled sample token.
+   * @param {boolean} [token.logged_in=true] - Indicates whether the user is logged in.
+   * @param {string} [token.steamid="76561199027696"] - The user's SteamID in string format.
+   * @param {number} [token.accountid=10671968] - The user's account ID.
+   * @param {string} [token.account_name="helloword"] - The user's account name.
+   * @param {string} [token.accountName="helloword"] - The user's account name (duplicate).
+   * @param {boolean} [token.is_support=false] - Whether the user is a support member.
+   * @param {boolean} [token.is_limited=true] - Indicates if the user's account is limited.
+   * @param {boolean} [token.is_partner_member=false] - Whether the user is a partner member.
+   * @param {string} [token.country_code="CN"] - The user's country code.
+   * @param {string} [token.token="AAAAAAAAAAAAAAA"] - The web logon token.
+   * @param {string} [token.webLogonToken="AAAAAAAAAAAAAAA"] - The web logon token (duplicate).
+   * @param {string} [token.token_use_id="e6a33a62c1d403b71761301c"] - The token use ID.
+   * @param {Object} [token.steamId] - SteamID details.
+   * @param {Object} [token.steamID] - Duplicate SteamID object (legacy support).
+   *
+   * @returns {Promise<boolean>} Resolves to `true` if login is successful, `false` otherwise.
+   *
+   * @throws Will log an error to the console if the login fails.
+   */
+  async function logOn(token) {
+    try {
+      isLogOff = false;
+      steamClient.logOn({
+        ...token,
+        steamId: new SteamID(token.steamid),
+        steamID: new SteamID(token.steamid),
+        accountName: token.account_name,
+        webLogonToken: token.token,
+      });
+      let timeout = null;
+      const eventIds = [];
+      const loggedOnResponse = await Promise.race([
+        new Promise((resolve) => {
+          timeout = setTimeout(function () {
+            resolve();
+          }, 180000);
+        }),
+        new Promise((resolve) => {
+          eventIds.push(
+            onEvent({
+              name: SteamClientEvents.loggedOn,
+              callback: resolve,
+              once: true,
+            }),
+            onEvent({
+              name: SteamClientEvents.logOff,
+              callback: function () {
+                resolve();
+              },
+              once: true,
+            }),
+            onEvent({
+              name: SteamClientEvents.error,
+              callback: function () {
+                resolve();
+              },
+              once: true,
+            }),
+          );
+        }),
+      ]);
+      clearTimeout(timeout);
+      offEvent(eventIds);
+      return loggedOnResponse?.eresult === 1;
+    } catch (e) {
+      console.error("logOn", e);
+      return false;
+    }
+  }
+
+  async function reLogin(retry = 50) {
+    if (isLogOff || retry <= 0) {
+      offAllEvent();
+      doClearIntervals();
+
+      error(`Cannot relogin (${isLogOff ? "logoff" : "retry limit reached"})`);
+      return false;
+    }
+
+    const isSuccess = await login(true);
+    if (isSuccess) {
+      log("Relogin success");
+      return true;
+    }
+
+    if (isLogOff) {
+      offAllEvent();
+      doClearIntervals();
+      error(`Cannot relogin (${isLogOff ? "logoff" : "retry limit reached"})`);
+      return false;
     }
 
+    if (retry > 1) {
+      await sleep(60000);
+      return await reLogin(retry - 1);
+    } else {
+      return false;
+    }
+  }
+
+  async function login(reconnect = false) {
     if (clientJsToken?.logged_in === true) {
       log(`[${clientJsToken.steamid}] ${reconnect ? "reconnect with clientJsToken" : "login with clientJsToken"}`);
       setTimeout(function () {
@@ -1814,27 +2087,36 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
         return logOn(_clientJsToken);
       } else {
         log(`Account not logged in ${clientJsToken?.account_name || steamUser.getSteamIdUser() || ""}`);
-        console.log(clientJsToken);
-        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;
     } else {
       log(`Account not logged in ${clientJsToken?.account_name || ""}`);
       return false;
     }
   }
 
-  function logOff() {
+  function clearLogOffEvent(id) {
+    if (typeof id === "string") {
+      delete logOffEvents[id];
+      return id;
+    } else if (typeof id === "function") {
+      for (const idKey in logOffEvents) {
+        if (logOffEvents[idKey] === id) {
+          delete logOffEvents[idKey];
+          return idKey;
+        }
+      }
+    }
+  }
+
+  async function logOff() {
+    log("logOff");
     isLogOff = true;
-    logOffEvent?.(true);
+
+    MessageQueue.length = 0;
+
+    callEvent(events.logOff);
+    events.logOff = [];
+
     if (_cleanNodeSteamUserTimeout) {
       clearTimeout(_cleanNodeSteamUserTimeout);
     }
@@ -1849,25 +2131,44 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     steamClient.licenses = [];
 
     steamClient.logOff();
-  }
-
-  function onCookie(callback) {
-    if (getCookies()) {
-      callback(getCookies());
-    } else {
-      onEvent(
-        "webSession",
-        function (webSession) {
-          callback(webSession?.cookies?.join?.(";"));
-        },
-        true,
-      );
+    await sleep(5000);
+    delete steamClient._logOnDetails;
+    delete steamClient.logOnResult;
+    delete steamClient._httpClient;
+    delete steamClient._lastChosenCM;
+    steamClient._connection.end(true);
+
+    for (const connKey in steamClient._connection) {
+      delete steamClient._connection[connKey];
+    }
+    delete steamClient._connection;
+    delete steamClient.accountInfo;
+    delete steamClient.emailInfo;
+    delete steamClient.limitations;
+    delete steamClient.vac;
+    delete steamClient.wallet;
+    delete steamClient.licenses;
+    delete steamClient.gifts;
+    delete steamClient.myGroups;
+    delete steamClient.playingState;
+
+    delete steamClient._heartbeatInterval;
+    delete steamClient.chat;
+    delete steamClient._httpClient;
+    delete steamClient._events;
+    delete steamClient.picsCache;
+    delete steamClient.options;
+
+    for (const key in steamClient) {
+      delete steamClient[key];
     }
   }
 
   async function init() {
+    isLogOff = false;
     bindEvent();
-    if (await login()) {
+    const logged = await login();
+    if (logged) {
       steamClient._handlerManager.add(ESteamProto.EMsg.k_EMsgClientRequestedClientStats, function (payload) {
         const result = new SteamProto(SteamProtoType.CMsgClientRequestedClientStats).protoDecode(payload.toBuffer());
         // console.log("CMsgClientRequestedClientStats", result);
@@ -1880,6 +2181,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   function partyRegister() {
+    if (isLogOff) {
+      return;
+    }
     if (prime === null) {
       _partyRegister(true);
       _partyRegister(false);
@@ -1889,6 +2193,10 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   function _partyRegister(prime) {
+    if (isLogOff) {
+      return;
+    }
+
     log("partyRegister", prime);
     lastTimePartyRegister = Date.now();
     steamClient.sendToGC(
@@ -1910,6 +2218,10 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   const MessageQueue = [];
 
   async function _execMessageQueue() {
+    if (isLogOff) {
+      return;
+    }
+
     if (isSendingFriendMessages) {
       return;
     }
@@ -1928,6 +2240,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   async function _sendFriendMessage(steamId, message) {
     let result = null;
     for (let i = 0; i < 10; i++) {
+      if (isLogOff) {
+        return;
+      }
       result = await new Promise((resolve) => {
         steamClient.chat.sendFriendMessage(steamId, message, undefined, function (...arg) {
           resolve(arg);
@@ -1945,6 +2260,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function sendFriendMessage(steamId, message) {
+    if (isLogOff) {
+      return;
+    }
     return new Promise((resolve) => {
       MessageQueue.push({ steamId, message, callback: resolve });
       _execMessageQueue();
@@ -1998,44 +2316,61 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     isInvisible = false;
     isAutoPlay = true;
     isPartyRegister = false;
-    const online = await new Promise((resolve) => {
-      const timeout = setTimeout(function () {
-        resolve(false);
-      }, 60000);
 
-      onEvent(
-        SteamClientEvents.csgoOnline,
-        function () {
-          clearTimeout(timeout);
-          resolve(true);
-        },
-        true,
-      );
-      onEvent(
-        SteamClientEvents.error,
-        function () {
-          clearTimeout(timeout);
-          resolve(false);
-        },
-        true,
-      );
-      onEvent(
-        SteamClientEvents.playingState,
-        function ({ playing_blocked, playing_app }) {
-          if (playing_blocked) {
-            clearTimeout(timeout);
-            resolve(false);
-          }
-        },
-        true,
-      );
-      init();
-    });
-    offAllEvent();
+    let timeout = null;
+    const eventIds = [];
+
+    const online = await Promise.race([
+      new Promise((resolve) => {
+        setTimeout(function () {
+          resolve();
+        }, 60000);
+      }),
+      new Promise((resolve) => {
+        eventIds.push(
+          onEvent({
+            name: SteamClientEvents.logOff,
+            callback: function () {
+              resolve(false);
+            },
+            once: true,
+          }),
+          onEvent({
+            name: SteamClientEvents.csgoOnline,
+            callback: function () {
+              resolve(true);
+            },
+            once: true,
+          }),
+          onEvent({
+            name: SteamClientEvents.error,
+            callback: function () {
+              resolve(false);
+            },
+            once: true,
+          }),
+          onEvent({
+            name: SteamClientEvents.playingState,
+            callback: function ({ playing_blocked }) {
+              if (playing_blocked) {
+                resolve(false);
+              }
+            },
+          }),
+        );
+        init();
+      }),
+    ]);
+
+    clearTimeout(timeout);
+    offEvent(eventIds);
     return online;
   }
 
   function doFakeGameScore() {
+    if (isLogOff) {
+      return;
+    }
     const maxRound = Math.random() > 0.7 ? 16 : 12;
     const maps = ["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_sugarcane", "de_train", "de_tuscan", "de_vertigo", "de_thera", "de_mills", "de_memento", "de_assembly", "training1"];
 
@@ -2117,6 +2452,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function gamesPlayed(apps) {
+    if (isLogOff) {
+      return;
+    }
     if (!Array.isArray(apps)) {
       apps = [apps];
     }
@@ -2154,6 +2492,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   function getFriendsList() {
+    if (isLogOff) {
+      return;
+    }
     const methodName = "FriendsList.GetFriendsList#1";
     const { users, myFriends } = steamClient; //object
     /*
@@ -2193,6 +2534,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   async function getUserOwnedApps(steamId = steamClient.steamID) {
+    if (isLogOff) {
+      return;
+    }
     if (!steamId) {
       return [];
     }
@@ -2248,7 +2592,10 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     return steamClient._playingAppIds || [];
   }
 
-  function requestJoinFriendData(token, version) {
+  async function requestJoinFriendData(token, version) {
+    if (isLogOff) {
+      return;
+    }
     if (!steamClient.steamID) {
       return;
     }
@@ -2263,23 +2610,37 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     let accountID = conBuf.readInt32BE(4);
     let joinIpp = conBuf.readInt32BE(8);
 
-    return new Promise((resolve) => {
-      pushGCCallback(`requestJoinFriendData_${accountID}`, resolve, 30000);
-      steamClient.sendToGC(
-        AppID,
-        ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData,
-        {},
-        new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestJoinFriendData).protoEncode({
-          version: version || CSGO_VER,
-          account_id: accountID,
-          join_token: joinToken,
-          join_ipp: joinIpp,
-        }),
-      );
-    });
+    const gcEventId = uuidv4();
+    const response = await ensureLogin(
+      new Promise((resolve) => {
+        onGCEvent({
+          name: gcEvents.requestJoinFriendData,
+          id: gcEventId,
+          key: accountID,
+          callback: resolve,
+          timeoutMs: 30000,
+        });
+        steamClient.sendToGC(
+          AppID,
+          ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData,
+          {},
+          new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestJoinFriendData).protoEncode({
+            version: version || CSGO_VER,
+            account_id: accountID,
+            join_token: joinToken,
+            join_ipp: joinIpp,
+          }),
+        );
+      }),
+    );
+    clearGCCallback(gcEventId);
+    return response;
   }
 
   function redeemFreeReward(itemIds, generation_time) {
+    if (isLogOff) {
+      return;
+    }
     console.log(`Sent message to GC: AppID ${AppID}, MessageType ${ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRedeemFreeReward}`);
 
     const encodedMessages = new SteamProto(SteamProtoType.CMsgGCCstrike15_v2_ClientRedeemFreeReward).protoEncode({
@@ -2300,6 +2661,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   function requestRankingInfo() {
+    if (isLogOff) {
+      return;
+    }
     return new Promise((resolve) => {
       const timeout = setTimeout(function () {
         resolve();
@@ -2335,6 +2699,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   function acknowledgePenalty() {
+    if (isLogOff) {
+      return;
+    }
     steamClient.sendToGC(
       730,
       ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_AcknowledgePenalty,
@@ -2345,6 +2712,28 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     );
   }
 
+  async function ensureLogin(promise) {
+    if (isLogOff) {
+      return null;
+    }
+    const logOffEventId = uuidv4();
+    const result = await Promise.race([
+      new Promise((resolve) => {
+        onEvent({
+          name: SteamClientEvents.logOff,
+          id: logOffEventId,
+          callback: function () {
+            resolve(null);
+          },
+          once: true,
+        });
+      }),
+      promise,
+    ]);
+    offEvent(logOffEventId);
+    return result;
+  }
+
   return {
     init,
     partySearch,
@@ -2380,6 +2769,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     getPersonaName,
     async getPlayersProfile(steamId, retry = 3) {
       for (let i = 0; i < retry; i++) {
+        if (isLogOff) {
+          return;
+        }
         const profile = await getPlayersProfile(steamId);
         if (profile) {
           return profile;
@@ -2443,6 +2835,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
       return state;
     },
     log,
+    error,
     isPrime() {
       return prime === true;
     },
@@ -2563,111 +2956,6 @@ export function increaseCSGO_VER() {
   return ++CSGO_VER;
 }
 
-SteamClient.isAccountPlayable = async function isAccountPlayable({ cookie, clientJsToken, timeoutMs, onPlayable, onNotPlayable, keepLoginWhenPlayable, ...rest }) {
-  if (!clientJsToken && cookie) {
-    clientJsToken = await new SteamUser(typeof cookie === "function" ? await cookie() : cookie).getClientJsToken();
-  }
-  if (clientJsToken?.logged_in !== true) {
-    if (typeof onNotPlayable === "function") {
-      await onNotPlayable(null);
-    }
-    return { invalidClientJsToken: true };
-  }
-  return await new Promise((resolve) => {
-    const timeouts = [
-      setTimeout(() => {
-        doResolve({ timedOut: true });
-      }, timeoutMs || 30000),
-    ];
-
-    const steamClient = new SteamClient({
-      isFakeGameScore: false,
-      isAutoPlay: true,
-      isPartyRegister: false,
-      isInvisible: true,
-      MAX_GAME_PLAY: 10,
-      games: 730,
-      clientJsToken,
-      ...rest,
-    });
-
-    steamClient.onEvent(
-      SteamClientEvents.error,
-      ({ eresult, msg, error }) => {
-        doResolve({ eresult, msg, error });
-      },
-      true,
-    );
-
-    steamClient.onEvent(
-      SteamClientEvents.csgoOnline,
-      (ClientWelcome) => {
-        doResolve({ playable: true });
-      },
-      true,
-    );
-
-    steamClient.onEvent(
-      SteamClientEvents.csgoClientHello,
-      (ClientHello) => {
-        doResolve({ playable: true });
-      },
-      true,
-    );
-
-    steamClient.onEvent(SteamClientEvents.playingState, ({ playing_blocked, playing_app }) => {
-      if (playing_blocked) {
-        doResolve({ playable: false });
-      } else {
-        timeouts.push(
-          setTimeout(function () {
-            const isBlocked = steamClient.isPlayingBlocked();
-            doResolve({ playable: !isBlocked });
-          }, 5000),
-        );
-      }
-    });
-
-    // steamClient.onEvent("fatalError", () => {
-    //   doResolve();
-    // });
-
-    steamClient.init();
-
-    async function doResolve(data) {
-      const playable = data?.playable === true;
-      timeouts.forEach((timeout) => clearTimeout(timeout));
-
-      if (!playable || !keepLoginWhenPlayable) {
-        steamClient.doClearIntervals();
-        steamClient.offAllEvent();
-      }
-
-      if (playable) {
-        if (typeof onPlayable === "function") {
-          try {
-            await onPlayable(steamClient);
-          } catch (e) {}
-        }
-      } else {
-        if (typeof onNotPlayable === "function") {
-          try {
-            await onNotPlayable(steamClient);
-          } catch (e) {}
-        }
-      }
-
-      if (!playable || !keepLoginWhenPlayable) {
-        steamClient.logOff();
-        return resolve(data);
-      } else {
-        steamClient.offAllEvent();
-        return resolve({ ...data, steamClient });
-      }
-    }
-  });
-};
-
 class XpBonuxFlagsHelper {
   static kCSXpBonusFlags_EarnedXpThisPeriod = 1 << 0;
   static kCSXpBonusFlags_FirstReward = 1 << 1;