steamutils 1.4.34 → 1.4.36

package/SteamClient.js

@@ -1,28 +1,15 @@
 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 __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const Protos = helpers([
-  {
-    name: "csgo",
-    protos: loadProfos(`${__dirname}/protos/`),
-  },
-]);
+import { ESteamProto, SteamProto, SteamProtoType } from "./steamproto.js";
 
 export const RANKS = {
   0: "Unranked",
@@ -76,12 +63,34 @@ export const LOCS = {
 
 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;
 });
 
+export const SteamClientEvents = {
+  user: "user",
+  loggedOn: "loggedOn",
+  csgoOnline: "csgoOnline",
+  csgoClientHello: "csgoClientHello",
+  webSession: "webSession",
+  friendMessage: "friendMessage",
+  friendTyping: "friendTyping",
+  disconnected: "disconnected",
+  error: "error",
+  playersProfile: "playersProfile",
+  fatalError: "fatalError",
+  partyInvite: "partyInvite",
+  friendRelationship: "friendRelationship",
+  tradeOffers: "tradeOffers",
+  offlineMessages: "offlineMessages",
+  friendsList: "friendsList",
+  gifts: "gifts",
+  playingState: "playingState",
+  emailInfo: "emailInfo",
+  accountLimitations: "accountLimitations",
+  wallet: "wallet",
+};
 const PersonasCache = [];
 let isSendingFriendMessages = false;
 
@@ -92,7 +101,6 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   let isLogOff = false;
   let playingBlocked = null;
   const richPresence = {};
-  let sendMessageTimestamp = 0;
   let lastTimePartyRegister = 0;
   let lastTimePartySearch = 0;
   const ownedApps = [];
@@ -108,29 +116,10 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
   const onAnyCallbacks = [];
 
-  const events = {
-    user: [],
-    loggedOn: [],
-    csgoOnline: [],
-    csgoClientHello: [],
-    webSession: [],
-    friendMessage: [],
-    friendTyping: [],
-    disconnected: [],
-    error: [],
-    playersProfile: [],
-    fatalError: [],
-    partyInvite: [],
-    friendRelationship: [],
-    tradeOffers: [],
-    offlineMessages: [],
-    friendsList: [],
-    gifts: [],
-    playingState: [],
-    emailInfo: [],
-    accountLimitations: [],
-    wallet: [],
-  };
+  const events = { ...SteamClientEvents };
+  for (const name in SteamClientEvents) {
+    events[name] = [];
+  }
 
   const gcCallback = {};
 
@@ -395,9 +384,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     const players = await new Promise((resolve) => {
       steamClient.sendToGC(
         AppID,
-        Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search,
+        ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search,
         {},
-        protoEncode(Protos.csgo.CMsgGCCStrike15_v2_Party_Search, {
+        new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_Search).protoEncode({
           ver: CSGO_VER,
           apr: prime ? 1 : 0,
           ark: parseInt(Object.keys(RANKS).find((k) => RANKS[k] === rank)) * 10,
@@ -406,7 +395,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
           game_type: game_type === "Competitive" ? 8 : 10,
         }),
       );
-      lastTimePartySearch = new Date().getTime();
+      lastTimePartySearch = Date.now();
       pushGCCallback("partySearch", resolve, timeout);
     });
     if (Array.isArray(players) && players.length) {
@@ -434,13 +423,13 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
       steamClient._send(
         {
-          msg: Protos.csgo.EMsg.k_EMsgClientMMSCreateLobby,
+          msg: ESteamProto.EMsg.k_EMsgClientMMSCreateLobby,
           proto: {
             steamid: steamClient.steamID.getSteamID64(),
             routing_appid: 730,
           },
         },
-        protoEncode(Protos.csgo.CMsgClientMMSCreateLobby, {
+        new SteamProto(SteamProtoType.CMsgClientMMSCreateLobby).protoEncode({
           app_id: 730,
           max_members: 1,
           lobby_type: 1,
@@ -448,24 +437,24 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
         }),
         function (payload) {
           clearTimeout(timeout);
-          const result = protoDecode(Protos.csgo.CMsgClientMMSCreateLobbyResponse, payload.toBuffer());
+          const result = new SteamProto(SteamProtoType.CMsgClientMMSCreateLobbyResponse).protoEncode(payload.toBuffer());
           const steam_id_lobby = result.steam_id_lobby.toString();
           currentLobby.lobbyID = steam_id_lobby;
-          currentLobby.timestamp = new Date().getTime();
+          currentLobby.timestamp = Date.now();
           resolve(steam_id_lobby);
         },
       );
     });
 
-    // return await getHandlerResult(Protos.csgo.EMsg.k_EMsgClientMMSCreateLobbyResponse, function (payload) {
-    //     const result = protoDecode(Protos.csgo.CMsgClientMMSCreateLobbyResponse, payload.toBuffer())
+    // return await getHandlerResult(ESteamProto.EMsg.k_EMsgClientMMSCreateLobbyResponse, function (payload) {
+    //     const result = protoDecode(SteamProtoType.CMsgClientMMSCreateLobbyResponse, payload.toBuffer())
     //     return result.steam_id_lobby.toString()
     // })
 
-    // steamClient.sendToGC(730, Protos.csgo.EMsg.k_EMsgClientMMSCreateLobby, {
+    // steamClient.sendToGC(730, ESteamProto.EMsg.k_EMsgClientMMSCreateLobby, {
     //     steamid: steamClient.steamID,
     //     routing_appid: 730,
-    // }, protoEncode(Protos.csgo.CMsgClientMMSCreateLobby, {
+    // }, protoEncode(SteamProtoType.CMsgClientMMSCreateLobby, {
     //     app_id: 730,
     //     max_members: 1,
     //     lobby_type: 1,
@@ -485,13 +474,13 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
       steamClient._send(
         {
-          msg: Protos.csgo.EMsg.k_EMsgClientMMSSetLobbyData,
+          msg: ESteamProto.EMsg.k_EMsgClientMMSSetLobbyData,
           proto: {
             steamid: steamClient.steamID.getSteamID64(),
             routing_appid: 730,
           },
         },
-        protoEncode(Protos.csgo.CMsgClientMMSSetLobbyData, {
+        new SteamProto(SteamProtoType.CMsgClientMMSSetLobbyData).protoEncode({
           app_id: 730,
           steam_id_lobby: lobbyID,
           steam_id_member: "0",
@@ -521,17 +510,17 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
         }),
         function (payload) {
           clearTimeout(timeout);
-          const result = protoDecode(Protos.csgo.CMsgClientMMSSetLobbyDataResponse, payload.toBuffer());
+          const result = new SteamProto(SteamProtoType.CMsgClientMMSSetLobbyDataResponse).protoDecode(payload.toBuffer());
           const steam_id_lobby = result.steam_id_lobby.toString();
           currentLobby.lobbyID = steam_id_lobby;
-          currentLobby.timestamp = new Date().getTime();
+          currentLobby.timestamp = Date.now();
           resolve(steam_id_lobby);
         },
       );
     });
 
-    // return await getHandlerResult(Protos.csgo.EMsg.k_EMsgClientMMSSetLobbyDataResponse, function (payload) {
-    //     const result = protoDecode(Protos.csgo.CMsgClientMMSSetLobbyDataResponse, payload.toBuffer())
+    // return await getHandlerResult(ESteamProto.EMsg.k_EMsgClientMMSSetLobbyDataResponse, function (payload) {
+    //     const result = protoDecode(SteamProtoType.CMsgClientMMSSetLobbyDataResponse, payload.toBuffer())
     //     return result.steam_id_lobby.toString()
     // })
   }
@@ -543,13 +532,13 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
     steamClient._send(
       {
-        msg: Protos.csgo.EMsg.k_EMsgClientMMSInviteToLobby,
+        msg: ESteamProto.EMsg.k_EMsgClientMMSInviteToLobby,
         proto: {
           steamid: steamClient.steamID.getSteamID64(),
           routing_appid: 730,
         },
       },
-      protoEncode(Protos.csgo.CMsgClientMMSInviteToLobby, {
+      new SteamProto(SteamProtoType.CMsgClientMMSInviteToLobby).protoEncode({
         app_id: 730,
         steam_id_lobby: lobbyID,
         steam_id_user_invited: steamId,
@@ -558,9 +547,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
     // 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, {
+    // ESteamProto.EMsg.k_EMsgGCHInviteUserToLobby
+    // ESteamProto.EMsg.k_EMsgClientMMSInviteToLobby
+    // steamClient.sendToGC(730, ESteamProto.EMsg.k_EMsgClientMMSInviteToLobby, {}, protoEncode(SteamProtoType.CMsgClientMMSInviteToLobby, {
     //     app_id: 730,
     //     steam_id_lobby: lobbyID,
     //     steam_id_user_invited: accountid,
@@ -579,7 +568,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     }
 
     let lobbyID = null;
-    if (currentLobby.lobbyID && currentLobby.timestamp > new Date().getTime() - 30000) {
+    if (currentLobby.lobbyID && currentLobby.timestamp > Date.now() - 30000) {
       //30 seconds
       lobbyID = currentLobby.lobbyID;
     } else {
@@ -607,19 +596,19 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
       steamClient._send(
         {
-          msg: Protos.csgo.EMsg.k_EMsgClientMMSGetLobbyData,
+          msg: ESteamProto.EMsg.k_EMsgClientMMSGetLobbyData,
           proto: {
             steamid: steamClient.steamID.getSteamID64(),
             routing_appid: 730,
           },
         },
-        protoEncode(Protos.csgo.CMsgClientMMSGetLobbyData, {
+        new SteamProto(SteamProtoType.CMsgClientMMSGetLobbyData).protoEncode({
           app_id: 730,
           steam_id_lobby: lobbyID.toString(),
         }),
         function (payload) {
           clearTimeout(timeout);
-          const result = protoDecode(Protos.csgo.CMsgClientMMSLobbyData, payload.toBuffer());
+          const result = new SteamProto(SteamProtoType.CMsgClientMMSLobbyData).protoDecode(payload.toBuffer());
           result.steam_id_lobby = result.steam_id_lobby.toString();
           resolve(result);
         },
@@ -632,19 +621,19 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
     steamClient._send(
       {
-        msg: Protos.csgo.EMsg.k_EMsgClientMMSJoinLobby,
+        msg: ESteamProto.EMsg.k_EMsgClientMMSJoinLobby,
         proto: {
           steamid: steamClient.steamID.getSteamID64(),
           routing_appid: 730,
         },
       }, //CMsgClientMMSUserJoinedLobby CMsgClientMMSJoinLobby
-      protoEncode(Protos.csgo.CMsgClientMMSJoinLobby, {
+      new SteamProto(SteamProtoType.CMsgClientMMSJoinLobby).protoEncode({
         app_id: 730,
         steam_id_lobby: lobbyID,
         persona_name: steamClient.accountInfo.name,
       }),
       function (payload) {
-        const result = protoDecode(Protos.csgo.CMsgClientMMSJoinLobbyResponse, payload.toBuffer());
+        const result = new SteamProto(SteamProtoType.CMsgClientMMSJoinLobbyResponse).protoDecode(payload.toBuffer());
         result.steam_id_lobby = result.steam_id_lobby.toString();
         result.steam_id_owner = result.steam_id_owner.toString();
         console.log(result);
@@ -664,14 +653,14 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   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));
+    steamClient.sendToGC(AppID, ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingClient2GCHello, {}, Buffer.alloc(0));
+    // steamClient.sendToGC(AppID, ESteamProto.EGCBaseClientMsg.k_EMsgGCClientHello, {}, Buffer.alloc(0));
 
     steamClient.sendToGC(
       AppID,
-      Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientHello,
+      ESteamProto.EGCBaseClientMsg.k_EMsgGCClientHello,
       {},
-      protoEncode(Protos.csgo.CMsgClientHello, {
+      new SteamProto(SteamProtoType.CMsgClientHello).protoEncode({
         version: 2000258, //get from https://github.com/SteamDatabase/GameTracking-CS2/commits
         client_session_need: 0,
         client_launcher: 0,
@@ -682,7 +671,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
   async function requestCoPlays() {
     return new Promise((resolve) => {
-      steamClient.sendToGC(AppID, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays, {}, Buffer.alloc(0));
+      steamClient.sendToGC(AppID, ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays, {}, Buffer.alloc(0));
       pushGCCallback("RequestCoPlays", resolve, 30000);
     });
   }
@@ -707,7 +696,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
               const isSuccess = await login(true);
               if (isSuccess) {
                 const loggedOnResponse = await new Promise((resolve) => {
-                  onEvent("loggedOn", resolve, true, 180000);
+                  onEvent(SteamClientEvents.loggedOn, resolve, true, 180000);
                 });
                 if (loggedOnResponse) {
                   console.log("Relogin success");
@@ -789,17 +778,17 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
       async receivedFromGC(appid, msgType, payload) {
         const key = getECsgoGCMsgKey(msgType);
         switch (msgType) {
-          case Protos.csgo.EMsg.k_EMsgClientChatInvite: {
+          case ESteamProto.EMsg.k_EMsgClientChatInvite: {
             log(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgClientMMSJoinLobbyResponse: {
-            const msg = protoDecode(Protos.csgo.CMsgClientMMSJoinLobbyResponse, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgClientMMSJoinLobbyResponse: {
+            const msg = new SteamProto(SteamProtoType.CMsgClientMMSJoinLobbyResponse).protoDecode(payload);
             log(msg);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Invite: {
-            const msg = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Party_Invite, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Invite: {
+            const msg = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_Invite).protoDecode(payload);
             const sid64 = SteamID.fromIndividualAccountID(msg.accountid).getSteamID64();
             if (events.partyInvite?.length) {
               const personas = await getPersonas([sid64]);
@@ -813,22 +802,22 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
             // 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);
+          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);
             break;
           }
-          case Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientWelcome: {
+          case ESteamProto.EGCBaseClientMsg.k_EMsgGCClientWelcome: {
             prime = false;
-            const CMsgClientWelcome = protoDecode(Protos.csgo.CMsgClientWelcome, payload);
+            const CMsgClientWelcome = new SteamProto(SteamProtoType.CMsgClientWelcome).protoDecode(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);
+                      const result = new SteamProto(SteamProtoType.CSOEconItem).protoDecode(object_data);
                       result.id = result.id.toNumber();
                       result.original_id = result.original_id.toNumber();
                       if (!obj.items) {
@@ -838,7 +827,7 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
                       break;
                     }
                     case 2: {
-                      const result = protoDecode(Protos.csgo.CSOPersonaDataPublic, object_data);
+                      const result = new SteamProto(SteamProtoType.CSOPersonaDataPublic).protoDecode(object_data);
                       obj.PersonaDataPublic = result;
                       const example = {
                         player_level: 4, //CSGO_Profile_Rank
@@ -852,11 +841,11 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
                       break;
                     }
                     case 5: {
-                      const result = protoDecode(Protos.csgo.CSOItemRecipe, object_data);
+                      const result = new SteamProto(SteamProtoType.CSOItemRecipe).protoDecode(object_data);
                       break;
                     }
                     case 7: {
-                      const CSOEconGameAccountClient = protoDecode(Protos.csgo.CSOEconGameAccountClient, object_data);
+                      const CSOEconGameAccountClient = new SteamProto(SteamProtoType.CSOEconGameAccountClient).protoDecode(object_data);
                       const CSOEconGameAccountClientExample = {
                         additional_backpack_slots: 0,
                         bonus_xp_timestamp_refresh: 1688518800, //Wednesday 1:00:00 AM every week
@@ -881,36 +870,36 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
                     }
 
                     case 35: {
-                      // const result =protoDecode(Protos.csgo.CSOSelectedItemPreset, object_data);
+                      // const result =protoDecode(SteamProtoType.CSOSelectedItemPreset, object_data);
                       break;
                     }
 
                     case 36: {
-                      // const result =protoDecode(Protos.csgo.CSOEconItemPresetInstance, object_data);
+                      // const result =protoDecode(SteamProtoType.CSOEconItemPresetInstance, object_data);
                       break;
                     }
                     case 38: {
-                      const result = protoDecode(Protos.csgo.CSOEconItemDropRateBonus, object_data);
+                      const result = new SteamProto(SteamProtoType.CSOEconItemDropRateBonus).protoDecode(object_data);
                       break;
                     }
                     case 39: {
-                      const result = protoDecode(Protos.csgo.CSOEconItemLeagueViewPass, object_data);
+                      const result = new SteamProto(SteamProtoType.CSOEconItemLeagueViewPass).protoDecode(object_data);
                       break;
                     }
                     case 40: {
-                      const result = protoDecode(Protos.csgo.CSOEconItemEventTicket, object_data);
+                      const result = new SteamProto(SteamProtoType.CSOEconItemEventTicket).protoDecode(object_data);
                       break;
                     }
                     case 41: {
-                      const result = protoDecode(Protos.csgo.CSOAccountSeasonalOperation, object_data);
+                      const result = new SteamProto(SteamProtoType.CSOAccountSeasonalOperation).protoDecode(object_data);
                       break;
                     }
                     case 42: {
-                      // const result =protoDecode(Protos.csgo.CSOEconItemTournamentPassport, object_data);
+                      // const result =protoDecode(SteamProtoType.CSOEconItemTournamentPassport, object_data);
                       break;
                     }
                     case 43: {
-                      const result = protoDecode(Protos.csgo.CSOEconDefaultEquippedDefinitionInstanceClient, object_data);
+                      const result = new SteamProto(SteamProtoType.CSOEconDefaultEquippedDefinitionInstanceClient).protoDecode(object_data);
                       const example = {
                         account_id: 1080136620,
                         item_definition: 61,
@@ -920,15 +909,15 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
                       break;
                     }
                     case 45: {
-                      const result = protoDecode(Protos.csgo.CSOEconCoupon, object_data);
+                      const result = new SteamProto(SteamProtoType.CSOEconCoupon).protoDecode(object_data);
                       break;
                     }
                     case 46: {
-                      const result = protoDecode(Protos.csgo.CSOQuestProgress, object_data);
+                      const result = new SteamProto(SteamProtoType.CSOQuestProgress).protoDecode(object_data);
                       break;
                     }
                     case 4: {
-                      const result = protoDecode(Protos.csgo.CSOAccountItemPersonalStore, object_data);
+                      const result = new SteamProto(SteamProtoType.CSOAccountItemPersonalStore).protoDecode(object_data);
                       result.generation_time = result.generation_time * 1000;
                       if (Array.isArray(result.items)) {
                         result.items = result.items.map((item) => item.toNumber());
@@ -964,24 +953,24 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
             }
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate).protoDecode(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GC2ClientGlobalStats: {
-            const result = protoDecode(Protos.csgo.CMsgClientUGSGetGlobalStatsResponse, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GC2ClientGlobalStats: {
+            const result = new SteamProto(SteamProtoType.CMsgClientUGSGetGlobalStatsResponse).protoDecode(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientReportPlayer: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientReportPlayer, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientReportPlayer: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientReportPlayer).protoDecode(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GC2ClientTextMsg: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_GC2ClientTextMsg, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GC2ClientTextMsg: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_GC2ClientTextMsg).protoDecode(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientHello: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchmakingGC2ClientHello, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientHello: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_MatchmakingGC2ClientHello).protoDecode(payload);
             const example = {
               my_current_event_teams: [],
               my_current_event_stages: [],
@@ -1048,64 +1037,64 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
             callEvent(events.csgoClientHello, result);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientReportResponse: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientReportResponse, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientReportResponse: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientReportResponse).protoDecode(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientCommendPlayerQueryResponse: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientCommendPlayer, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientCommendPlayerQueryResponse: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientCommendPlayer).protoDecode(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment).protoDecode(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchList: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchList, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchList: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_MatchList).protoDecode(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GetEventFavorites_Response: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_GetEventFavorites_Response, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GetEventFavorites_Response: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_GetEventFavorites_Response).protoDecode(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_StartAgreementSessionInGame: {
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_StartAgreementSessionInGame: {
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_ClientDeepStats: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_ClientDeepStats, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_ClientDeepStats: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_ClientDeepStats).protoDecode(payload);
             break;
           }
-          case Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientConnectionStatus: {
-            const result = protoDecode(Protos.csgo.CMsgConnectionStatus, payload);
+          case ESteamProto.EGCBaseClientMsg.k_EMsgGCClientConnectionStatus: {
+            const result = new SteamProto(SteamProtoType.CMsgConnectionStatus).protoDecode(payload);
             break;
           }
-          case Protos.csgo.EGCItemMsg.k_EMsgGCStoreGetUserDataResponse: {
-            const result = protoDecode(Protos.csgo.CMsgStoreGetUserDataResponse, payload);
+          case ESteamProto.EGCItemMsg.k_EMsgGCStoreGetUserDataResponse: {
+            const result = new SteamProto(SteamProtoType.CMsgStoreGetUserDataResponse).protoDecode(payload);
             break;
           }
-          case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseFinalizeResponse: {
-            const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseFinalizeResponse, payload);
+          case ESteamProto.EGCItemMsg.k_EMsgGCStorePurchaseFinalizeResponse: {
+            const result = new SteamProto(SteamProtoType.CMsgGCStorePurchaseFinalizeResponse).protoDecode(payload);
             break;
           }
-          case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseCancelResponse: {
-            const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseCancelResponse, payload);
+          case ESteamProto.EGCItemMsg.k_EMsgGCStorePurchaseCancelResponse: {
+            const result = new SteamProto(SteamProtoType.CMsgGCStorePurchaseCancelResponse).protoDecode(payload);
             break;
           }
-          case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseInitResponse: {
-            const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseInitResponse, payload);
+          case ESteamProto.EGCItemMsg.k_EMsgGCStorePurchaseInitResponse: {
+            const result = new SteamProto(SteamProtoType.CMsgGCStorePurchaseInitResponse).protoDecode(payload);
             break;
           }
-          case Protos.csgo.EMsg.k_EMsgClientMMSCreateLobbyResponse: {
-            const result = protoDecode(Protos.csgo.CMsgClientMMSCreateLobbyResponse, payload);
+          case ESteamProto.EMsg.k_EMsgClientMMSCreateLobbyResponse: {
+            const result = new SteamProto(SteamProtoType.CMsgClientMMSCreateLobbyResponse).protoDecode(payload);
             console.log("k_EMsgClientMMSCreateLobbyResponse", result);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientGCRankUpdate: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientGCRankUpdate, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientGCRankUpdate: {
+            const result = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientGCRankUpdate).protoDecode(payload);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search: {
-            const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Party_SearchResults, payload);
+          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,
@@ -1177,8 +1166,8 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
             callGCCallback("partySearch", players);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayersProfile: {
-            let data = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_PlayersProfile, payload)?.account_profiles;
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayersProfile: {
+            let data = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_PlayersProfile).protoDecode(payload)?.account_profiles;
             const dataExample = [
               {
                 my_current_event_teams: [],
@@ -1250,8 +1239,8 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
             callEvent(events.playersProfile, player);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientLogonFatalError: {
-            const data = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientLogonFatalError, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientLogonFatalError: {
+            const data = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientLogonFatalError).protoDecode(payload);
             const dataExample = {
               errorcode: 4,
               message: "",
@@ -1260,8 +1249,8 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
             callEvent(events.fatalError, data);
             break;
           }
-          case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData: {
-            const data = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientRequestJoinFriendData, payload);
+          case ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData: {
+            const data = new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestJoinFriendData).protoDecode(payload);
             if (!data?.account_id) {
               return;
             }
@@ -1278,10 +1267,10 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
           }
           default:
             log(`receivedFromGC ${msgType} ${key}`);
-            const results = Object.values(Protos.csgo)
+            const results = Object.values(SteamProtoType)
               .map(function (p) {
                 try {
-                  return protoDecode(p, payload);
+                  return new SteamProto(p).protoDecode(payload);
                 } catch (e) {}
               })
               .filter(function (result) {
@@ -1536,23 +1525,23 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     // });
 
     function getECsgoGCMsgKey(_key) {
-      for (let key in Protos.csgo.ECsgoGCMsg) {
-        if (Protos.csgo.ECsgoGCMsg[key] == _key) {
+      for (let key in ESteamProto.ECsgoGCMsg) {
+        if (ESteamProto.ECsgoGCMsg[key] == _key) {
           return key;
         }
       }
-      for (let key in Protos.csgo.EGCBaseClientMsg) {
-        if (Protos.csgo.EGCBaseClientMsg[key] == _key) {
+      for (let key in ESteamProto.EGCBaseClientMsg) {
+        if (ESteamProto.EGCBaseClientMsg[key] == _key) {
           return key;
         }
       }
-      for (let key in Protos.csgo.EMsg) {
-        if (Protos.csgo.EMsg[key] == _key) {
+      for (let key in ESteamProto.EMsg) {
+        if (ESteamProto.EMsg[key] == _key) {
           return key;
         }
       }
-      for (let key in Protos.csgo.EGCItemMsg) {
-        if (Protos.csgo.EGCItemMsg[key] == _key) {
+      for (let key in ESteamProto.EGCItemMsg) {
+        if (ESteamProto.EGCItemMsg[key] == _key) {
           return key;
         }
       }
@@ -1608,9 +1597,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     const accountid = new SteamID(steamId).accountid;
     steamClient.sendToGC(
       730,
-      Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile,
+      ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile,
       {},
-      protoEncode(Protos.csgo.CMsgGCCStrike15_v2_ClientRequestPlayersProfile, {
+      new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestPlayersProfile).protoEncode({
         account_id: accountid, // account_id: new SteamID('76561199184696945').accountid,
         request_level: 32,
       }),
@@ -1796,12 +1785,12 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   async function init() {
     bindEvent();
     if (await login()) {
-      steamClient._handlerManager.add(Protos.csgo.EMsg.k_EMsgClientRequestedClientStats, function (payload) {
-        const result = protoDecode(Protos.csgo.CMsgClientRequestedClientStats, payload.toBuffer());
+      steamClient._handlerManager.add(ESteamProto.EMsg.k_EMsgClientRequestedClientStats, function (payload) {
+        const result = new SteamProto(SteamProtoType.CMsgClientRequestedClientStats).protoDecode(payload.toBuffer());
         // console.log("CMsgClientRequestedClientStats", result);
       });
-      steamClient._handlerManager.add(Protos.csgo.EMsg.k_EMsgClientMMSLobbyData, function (payload) {
-        const result = protoDecode(Protos.csgo.CMsgClientMMSLobbyData, payload.toBuffer());
+      steamClient._handlerManager.add(ESteamProto.EMsg.k_EMsgClientMMSLobbyData, function (payload) {
+        const result = new SteamProto(SteamProtoType.CMsgClientMMSLobbyData).protoDecode(payload.toBuffer());
         // console.log("CMsgClientMMSLobbyData", result, result.metadata);
       });
     }
@@ -1818,12 +1807,12 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
   function _partyRegister(prime) {
     log("partyRegister", prime);
-    lastTimePartyRegister = new Date().getTime();
+    lastTimePartyRegister = Date.now();
     steamClient.sendToGC(
       730,
-      Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Register,
+      ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Register,
       {},
-      protoEncode(Protos.csgo.CMsgGCCStrike15_v2_Party_Register, {
+      new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_Party_Register).protoEncode({
         // id : 0,
         ver: CSGO_VER,
         apr: prime ? 1 : 0, //prime
@@ -1835,37 +1824,48 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
     );
   }
 
-  async function sendFriendMessage(steamId, message) {
-    while (sendMessageTimestamp && new Date().getTime() - sendMessageTimestamp < 2000) {
-      await sleep(1000);
-    }
+  const MessageQueue = [];
 
-    while (isSendingFriendMessages) {
-      await sleep(5000);
+  async function _execMessageQueue() {
+    if (isSendingFriendMessages) {
+      return;
     }
+    while (MessageQueue.length) {
+      isSendingFriendMessages = true;
+      const item = MessageQueue.shift();
+      const result = await _sendFriendMessage(item.steamId, item.message);
+      item.callback(result);
+      if (MessageQueue.length) {
+        await sleep(1000);
+      }
+    }
+    isSendingFriendMessages = false;
+  }
 
-    isSendingFriendMessages = true;
-    const now = new Date().getTime();
-    while (new Date().getTime() - now < 2 * 60000) {
-      //2 minutes
-      const result = await new Promise((resolve) => {
+  async function _sendFriendMessage(steamId, message) {
+    let result = null;
+    for (let i = 0; i < 10; i++) {
+      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;
+    return result;
+  }
+
+  async function sendFriendMessage(steamId, message) {
+    return new Promise((resolve) => {
+      MessageQueue.push({ steamId, message, callback: resolve });
+      _execMessageQueue();
+    });
   }
 
   async function autoRequestFreeLicense(shouldLog = false, max = 10) {
@@ -2176,9 +2176,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
       pushGCCallback(`requestJoinFriendData_${accountID}`, resolve, 30000);
       steamClient.sendToGC(
         AppID,
-        Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData,
+        ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestJoinFriendData,
         {},
-        protoEncode(Protos.csgo.CMsgGCCStrike15_v2_ClientRequestJoinFriendData, {
+        new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientRequestJoinFriendData).protoEncode({
           version: version || CSGO_VER,
           account_id: accountID,
           join_token: joinToken,
@@ -2189,21 +2189,21 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   }
 
   function redeemFreeReward(itemIds, generation_time) {
-    console.log(`Sent message to GC: AppID ${AppID}, MessageType ${Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRedeemFreeReward}`);
+    console.log(`Sent message to GC: AppID ${AppID}, MessageType ${ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRedeemFreeReward}`);
 
-    const encodedMessages = protoEncode(Protos.csgo.CMsgGCCstrike15_v2_ClientRedeemFreeReward, {
+    const encodedMessages = new SteamProto(SteamProtoType.CMsgGCCstrike15_v2_ClientRedeemFreeReward).protoEncode({
       items: itemIds,
       redeemable_balance: 0,
       generation_time: generation_time,
     });
-    steamClient.sendToGC(730, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRedeemFreeReward, {}, encodedMessages, function (payload) {
+    steamClient.sendToGC(730, ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRedeemFreeReward, {}, encodedMessages, function (payload) {
       console.log(payload);
     });
 
     setTimeout(function () {
       steamClient._send(
         {
-          msg: Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRedeemFreeReward,
+          msg: ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRedeemFreeReward,
           proto: {
             steamid: steamClient.steamID.getSteamID64(),
             routing_appid: 730,
@@ -2225,13 +2225,13 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
 
       steamClient._send(
         {
-          msg: Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientGCRankUpdate,
+          msg: ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientGCRankUpdate,
           proto: {
             steamid: steamClient.steamID.getSteamID64(),
             routing_appid: 730,
           },
         },
-        protoEncode(Protos.csgo.CMsgGCCStrike15_v2_ClientGCRankUpdate, {
+        new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_ClientGCRankUpdate).protoEncode({
           rankings: [
             {
               rank_type_id: 7, //wing man
@@ -2255,9 +2255,9 @@ function SteamClient({ username, password, cookie, clientJsToken, isAutoRequestF
   function acknowledgePenalty() {
     steamClient.sendToGC(
       730,
-      Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_AcknowledgePenalty,
+      ESteamProto.ECsgoGCMsg.k_EMsgGCCStrike15_v2_AcknowledgePenalty,
       {},
-      protoEncode(Protos.csgo.CMsgGCCStrike15_v2_AcknowledgePenalty, {
+      new SteamProto(SteamProtoType.CMsgGCCStrike15_v2_AcknowledgePenalty).protoEncode({
         acknowledged: 1,
       }),
     );
@@ -2505,19 +2505,19 @@ SteamClient.isAccountPlayable = async function isAccountPlayable({ cookie, clien
       ...rest,
     });
 
-    steamClient.onEvent("error", ({ eresult, msg, error }) => {
+    steamClient.onEvent(SteamClientEvents.error, ({ eresult, msg, error }) => {
       doResolve({ eresult, msg, error });
     });
 
-    steamClient.onEvent("csgoOnline", (ClientWelcome) => {
+    steamClient.onEvent(SteamClientEvents.csgoOnline, (ClientWelcome) => {
       doResolve({ playable: true });
     });
 
-    steamClient.onEvent("csgoClientHello", (ClientHello) => {
+    steamClient.onEvent(SteamClientEvents.csgoClientHello, (ClientHello) => {
       doResolve({ playable: true });
     });
 
-    steamClient.onEvent("playingState", ({ playing_blocked, playing_app }) => {
+    steamClient.onEvent(SteamClientEvents.playingState, ({ playing_blocked, playing_app }) => {
       if (playing_blocked) {
         doResolve({ playable: false });
       } else {