steamutils 1.0.3 → 1.0.4

package/SteamClient.js

@@ -0,0 +1,534 @@
+import SteamUser 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 from "./helpers/protos.js";
+
+const Protos = helpers([{
+    name: 'csgo',
+    protos: fs.readdirSync(__dirname + '/protos/').filter(s => s.endsWith('.proto')).map(s => __dirname + '/protos/' + s)
+}])
+
+export const RANKS = {
+    0: 'Unranked',
+    1: 'Silver I',
+    2: 'Silver II',
+    3: 'Silver III',
+    4: 'Silver IV',
+    5: 'Silver Elite',
+    6: 'Silver Elite Master',
+    7: 'Gold Nova I',
+    8: 'Gold Nova II',
+    9: 'Gold Nova III',
+    10: 'Gold Nova Master',
+    11: 'Master Guardian I',
+    12: 'Master Guardian II',
+    13: 'Master Guardian Elite',
+    14: 'Distinguished Master Guardian',
+    15: 'Legendary Eagle',
+    16: 'Legendary Eagle Master',
+    17: 'Supreme Master First Class',
+    18: 'The Global Elite'
+}
+export const LOCS = {
+    20054: 'VN',
+    23115: 'KZ',
+    20041: 'IN',
+    20035: 'CN',
+    17474: 'BD',
+    17481: 'ID',
+    22861: 'MY',
+    18516: 'TH',
+    22356: 'TW',
+    21067: 'KR',
+    19272: 'HK',
+    18512: 'PH',
+    21842: 'RU',
+    16716: 'LA',
+    20558: 'NP',
+    18259: 'SG',
+    19789: 'MM',
+    20045: 'MN',
+    18251: 'KG',
+    18507: 'KH',
+    22605: 'MX',
+    19280: 'PK',
+    20301: 'HK/MO',//hongkong or macau
+    21333: 'Unknown',
+    21825: 'AU',
+}
+
+
+const appid = 730
+let CSGO_VER = null
+GetCurrentVersion(appid).then(function (ver) {
+    CSGO_VER = ver
+})
+
+async function GetCurrentVersion(appid) {
+    const result = await axios.request({
+        url: 'https://api.steampowered.com/ISteamApps/UpToDateCheck/v1/?format=json&appid=' + appid + '&version=0'
+    })
+    return result.data.response.required_version
+}
+
+function SteamClient({
+                         username,
+                         password,
+                         cookie,
+                     }) {
+    const steamClient = new SteamUser()
+    let prime = false
+    let gamename = null;
+
+    const events = {
+        loggedOn: []
+    }
+
+    const personasCache = []
+
+    async function getPersonas(steamIDs) {
+        const notCachesteamIDs = steamIDs.filter(id => !personasCache.some(p => p.id == id))
+        const cachedPersonas = personasCache.filter(p => steamIDs.includes(p.id))
+
+        if (notCachesteamIDs.length) {
+            let personas = null
+            try {
+                personas = (await steamClient.getPersonas(steamIDs))?.personas
+            } catch (e) {
+            }
+            if (!personas) {
+                try {
+                    personas = (await steamClient.getPersonas(steamIDs))?.personas
+                } catch (e) {
+                }
+            }
+            if (!personas) {
+                return {}
+            } else {
+                for (let sid64 in personas) {
+                    personas[sid64].avatar_hash = Buffer.from(personas[sid64].avatar_hash).toString("hex")
+                    personasCache.push(personas[sid64])
+                    cachedPersonas.push(personas[sid64])
+                }
+            }
+        }
+
+        while (personasCache.length > 500) {
+            personasCache.shift()
+        }
+        return cachedPersonas
+    }
+
+    const sleep = (ms) => {
+        return new Promise(resolve => {
+            setTimeout(resolve, ms)
+        })
+    }
+
+    const partySearchCallback = []
+
+    /**
+     * Get a list of lobbies (* = Unsure description could be wrong)
+     * @param {Number} ver Game version we are searching for
+     * @param {Boolean} apr Prime or not*
+     * @param {Number} ark Rank multiplied by 10*
+     * @param {Array.<Number>} grps *
+     * @param {Number} launcher If we are using the China CSGO launcher or not*
+     * @param {Number} game_type Game type, 8 Competitive, 10 Wingman
+     * @returns {Promise.<Object>}
+     */
+    async function partySearch({
+                                   prime = false, game_type = 'Competitive', rank = 'Silver Elite',
+                               }) {
+
+        return new Promise(resolve => {
+            steamClient.sendToGC(appid, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search, {}, protoEncode(Protos.csgo.CMsgGCCStrike15_v2_Party_Search, {
+                ver: CSGO_VER,
+                apr: prime ? 1 : 0,
+                ark: Object.keys(RANKS).find(k => RANKS[k] === rank) * 10,
+                grps: [],
+                launcher: 0,
+                game_type: game_type === 'Competitive' ? 8 : 10
+            }))
+            partySearchCallback.push(resolve)
+            setTimeout(resolve, 10000)
+        })
+    }
+
+    async function sendHello() {
+        console.log('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))
+        console.log('sendHello done')
+    }
+
+    const requestCoPlaysCallback = []
+
+    async function requestCoPlays() {
+        console.log('sendMessageAccount_RequestCoPlays')
+        return new Promise(resolve => {
+            steamClient.sendToGC(appid, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays, {}, Buffer.alloc(0))
+            requestCoPlaysCallback.push(resolve)
+            setTimeout(resolve, 10000)
+        })
+    }
+
+
+    function bindEvent() {
+        steamClient.on('disconnected', async (eresult, msg) => {
+            console.log('disconnected')
+        })
+        steamClient.on('error', async (e) => {
+            let errorStr = ``
+            switch (e.eresult) {
+                case 5:
+                    errorStr = `Invalid Password`
+                    break
+                case 6:
+                case 34:
+                    errorStr = `Logged In Elsewhere`
+                    break
+                case 84:
+                    errorStr = `Rate Limit Exceeded`
+                    break
+                case 65:
+                    errorStr = `steam guard is invalid`
+                    break
+                default:
+                    errorStr = `Unknown: ${e.eresult}`
+                    break
+            }
+            console.log('error', e?.message)
+        })
+
+        steamClient.on('webSession', (sessionID, cookies) => {
+            // console.log('webSession', sessionID, cookies);
+        })
+
+        steamClient.on('receivedFromGC', async (appid, msgType, payload) => {
+            const key = getECsgoGCMsgKey(msgType)
+            switch (msgType) {
+                case Protos.csgo.EMsg.k_EMsgClientChatInvite: {
+                    console.log(payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgClientMMSJoinLobbyResponse: {
+                    let msg = protoDecode(Protos.csgo.CMsgClientMMSJoinLobbyResponse, payload)
+                    console.log(msg)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Invite: {
+                    let msg = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Party_Invite, payload)
+                    let sid = SteamID.fromIndividualAccountID(msg.accountid);
+                    // console.log(msg)
+                    let personas = await getPersonas([sid])
+                    console.log(personas?.[sid]?.player_name, `https://steamcommunity.com/profiles/${sid.getSteamID64()}`);
+                    // joinLobby(msg.lobbyid, msg.accountid)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Account_RequestCoPlays: {
+                    const msg = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Account_RequestCoPlays, payload);
+                    const personas = msg.players.map(p => SteamID.fromIndividualAccountID(p.accountid));
+                    requestCoPlaysCallback?.shift()?.(personas)
+                    break
+                }
+                case Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientWelcome: {
+                    const CMsgClientWelcome = protoDecode(Protos.csgo.CMsgClientWelcome, payload);
+                    for (const outofdate_cache of CMsgClientWelcome.outofdate_subscribed_caches) {
+                        for (const cache_object of outofdate_cache.objects) {
+                            if (cache_object.object_data.length === 0) {
+                                continue
+                            }
+                            switch (cache_object.type_id) {
+                                case 7: {
+                                    let CSOEconGameAccountClient = protoDecode(Protos.csgo.CSOEconGameAccountClient, cache_object.object_data[0])
+                                    if ((CSOEconGameAccountClient.bonus_xp_usedflags & 16) != 0) { // EXPBonusFlag::PrestigeEarned
+                                        prime = true
+                                    }
+                                    if (CSOEconGameAccountClient.elevated_state == 5) { // bought prime
+                                        prime = true
+                                    }
+                                    break
+                                }
+                            }
+                        }
+                    }
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchmakingGC2ClientUpdate, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GC2ClientGlobalStats: {
+                    const result = protoDecode(Protos.csgo.CMsgClientUGSGetGlobalStatsResponse, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GC2ClientTextMsg: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_GC2ClientTextMsg, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchmakingGC2ClientHello: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchmakingGC2ClientHello, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientReportResponse: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientReportResponse, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientCommendPlayerQueryResponse: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientCommendPlayer, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_PlayerOverwatchCaseAssignment, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_MatchList: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_MatchList, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_GetEventFavorites_Response: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_GetEventFavorites_Response, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_StartAgreementSessionInGame: {
+
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_ClientDeepStats: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_ClientDeepStats, payload)
+                    break
+                }
+                case Protos.csgo.EGCBaseClientMsg.k_EMsgGCClientConnectionStatus: {
+                    const result = protoDecode(Protos.csgo.CMsgConnectionStatus, payload)
+                    break
+                }
+                case Protos.csgo.EGCItemMsg.k_EMsgGCStoreGetUserDataResponse: {
+                    const result = protoDecode(Protos.csgo.CMsgStoreGetUserDataResponse, payload)
+                    break
+                }
+                case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseFinalizeResponse: {
+                    const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseFinalizeResponse, payload)
+                    break
+                }
+                case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseCancelResponse: {
+                    const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseCancelResponse, payload)
+                    break
+                }
+                case Protos.csgo.EGCItemMsg.k_EMsgGCStorePurchaseInitResponse: {
+                    const result = protoDecode(Protos.csgo.CMsgGCStorePurchaseInitResponse, payload)
+                    break
+                }
+                case Protos.csgo.EMsg.k_EMsgClientMMSCreateLobbyResponse: {
+                    const result = protoDecode(Protos.csgo.CMsgClientMMSCreateLobbyResponse, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientGCRankUpdate: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_ClientGCRankUpdate, payload)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Search: {
+                    const result = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_Party_SearchResults, payload)
+                    const entries = _.uniqBy(result.entries, 'id')
+
+                    const players = []
+
+                    const steamIDs = entries
+                        .map(p => SteamID.fromIndividualAccountID(p.id).getSteamID64())
+                    const personas = await getPersonas(steamIDs)
+
+                    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 persona = personas.find(p => p.id == player.id)
+                            const player_name = persona.player_name
+                            const friendCode = FriendCode.encode(steamID)
+
+                            if ((LOCS[player.loc] == 'VN' || !LOCS[player.loc])) {
+                                players.push({
+                                    prime,
+                                    player_name: player_name,
+                                    rank: RANKS[player.ark],
+                                    loc: loc,
+                                    steamID,
+                                    friendCode,
+                                    avatar_hash: persona.avatar_hash,
+                                })
+                            }
+                        } catch (e) {
+                        }
+                    }
+
+                    partySearchCallback.shift()?.(players)
+                    break
+                }
+                case Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_PlayersProfile: {
+                    let data = protoDecode(Protos.csgo.CMsgGCCStrike15_v2_PlayersProfile, payload)?.account_profiles
+                    const dataExample = [{
+                        my_current_event_teams: [],
+                        my_current_event_stages: [],
+                        rankings: [{
+                            account_id: 1225887169, rank_id: 0, wins: 6, rank_change: 0, rank_type_id: 7, tv_control: 0
+                        }, {
+                            account_id: 1225887169, rank_id: 0, wins: 0, rank_change: 0, rank_type_id: 10, tv_control: 0
+                        }],
+                        account_id: 1225887169,
+                        ongoingmatch: null,
+                        global_stats: null,
+                        penalty_seconds: 0,
+                        penalty_reason: 0,
+                        vac_banned: 0,
+                        ranking: {
+                            account_id: 1225887169,
+                            rank_id: 8,
+                            wins: 469,
+                            rank_change: 0,
+                            rank_type_id: 6,
+                            tv_control: 0
+                        },
+                        commendation: {
+                            cmd_friendly: 51, cmd_teaching: 40, cmd_leader: 40
+                        },
+                        medals: {
+                            display_items_defidx: [4819, 4737], featured_display_item_defidx: 4819
+                        },
+                        my_current_event: null,
+                        my_current_team: null,
+                        survey_vote: 0,
+                        activity: null,
+                        player_level: 32,
+                        player_cur_xp: 327682846,
+                        player_xp_bonus_flags: 0
+                    }]
+                    console.log(data);
+                    break
+                }
+                default:
+                    console.log(`receivedFromGC ${msgType} ${key}`)
+                    const results = Object.values(Protos.csgo).map(function (p) {
+                        try {
+                            return protoDecode(p, payload)
+                        } catch (e) {
+                        }
+                    }).filter(function (result) {
+                        return result && Object.keys(result).length
+                    })
+                    console.log(key, results)
+            }
+        })
+
+        function getECsgoGCMsgKey(_key) {
+            for (let key in Protos.csgo.ECsgoGCMsg) {
+                if (Protos.csgo.ECsgoGCMsg[key] == _key) {
+                    return key
+                }
+            }
+            for (let key in Protos.csgo.EGCBaseClientMsg) {
+                if (Protos.csgo.EGCBaseClientMsg[key] == _key) {
+                    return key
+                }
+            }
+            for (let key in Protos.csgo.EMsg) {
+                if (Protos.csgo.EMsg[key] == _key) {
+                    return key
+                }
+            }
+            for (let key in Protos.csgo.EGCItemMsg) {
+                if (Protos.csgo.EGCItemMsg[key] == _key) {
+                    return key
+                }
+            }
+        }
+
+        steamClient.on('loggedOn', async (loggedOnResponse) => {
+            await steamClient.requestFreeLicense(appid)
+            await sleep(5000)
+
+            if (gamename) {
+                steamClient.gamesPlayed([{
+                    game_id: appid, game_extra_info: gamename
+                }], true);
+            } else {
+                steamClient.gamesPlayed(appid, true)
+            }
+
+            steamClient.setPersona(SteamUser.EPersonaState.LookingToPlay)
+
+            while (!steamClient.accountInfo) {
+                await sleep(500)
+            }
+
+            console.log(`app ${appid} launched on account ${steamClient.accountInfo.name}`)
+            await sendHello()
+
+            events.loggedOn.forEach(e => e?.invoke?.())
+        })
+    }
+
+    function getPlayersProfile(accountid) {
+        steamClient.sendToGC(730, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_ClientRequestPlayersProfile, {}, protoEncode(Protos.csgo.CMsgGCCStrike15_v2_ClientRequestPlayersProfile, {
+            account_id: accountid, // account_id: new SteamID('76561199184696945').accountid,
+            request_level: 32
+        }))
+    }
+
+    async function login() {
+        if (cookie) {
+            console.log('login with cookie')
+            const result = (await axios.request({
+                url: 'https://steamcommunity.com/chat/clientjstoken', headers: {
+                    cookie,
+                }
+            }))?.data
+            if (result) {
+                Object.assign(result, {
+                    steamID: new SteamID(result.steamid), accountName: result.account_name, webLogonToken: result.token
+                })
+                steamClient.logOn(result)
+            }
+        } else if (username && password) {
+            console.log(`login with username ${username}`)
+            steamClient.logOn({
+                accountName: username, password: password, rememberPassword: true, machineName: 'Natri',
+            })
+        }
+    }
+
+    function init() {
+        bindEvent()
+        login()
+    }
+
+
+    function partyRegister() {
+        console.log("partyRegister", steamClient?.accountInfo?.name || username, prime);
+        steamClient.sendToGC(730, Protos.csgo.ECsgoGCMsg.k_EMsgGCCStrike15_v2_Party_Register, {}, protoEncode(Protos.csgo.CMsgGCCStrike15_v2_Party_Register, {
+            // id : 0,
+            ver: CSGO_VER, apr: prime ? 1 : 0,//prime
+            ark: prime ? 180 : 0, grps: [], launcher: 0, game_type: 8
+        }))
+    }
+
+    return {
+        init, partySearch, partyRegister, requestCoPlays, getPersonas, getUsername: function () {
+            return username
+        }, onEvent: function (name, cb) {
+            if (!events[name]) {
+                events[name] = []
+            }
+            events[name].push(cb)
+        }, setPersona: function (state, name) {
+            steamClient.setPersona(state, name)
+        }, setGameName: function (name) {
+            gamename = name
+        },
+    }
+}
+
+export default SteamClient

package/helpers/protos.js

@@ -0,0 +1,33 @@
+import Protobuf from "protobufjs";
+import fs from "fs";
+import path from "path";
+
+export default function Protos(protos, ignoreErrors = true) {
+    const protobufs = {};
+
+    for (let proto of protos) {
+        let root = new Protobuf.Root();
+        let files = Array.isArray(proto.protos) ? proto.protos : fs.readdirSync(proto.protos).map(file => path.join(proto.protos, file));
+
+        for (let file of files) {
+            if (!file.endsWith(".proto") || !fs.existsSync(file)) {
+                continue;
+            }
+
+            try {
+                root = root.loadSync(file, {
+                    keepCase: true
+                });
+            } catch (err) {
+                if (!ignoreErrors) {
+                    throw err;
+                }
+            }
+            ;
+        }
+
+        protobufs[proto.name] = root;
+    }
+
+    return protobufs;
+}

package/helpers/util.js

@@ -0,0 +1,60 @@
+export function penalty_reason_string(id) {
+    switch (id) {
+        case 0:
+            return 0;
+        case 1:
+            return "Kicked";
+        case 2:
+            return "TK Limit";
+        case 3:
+            return "TK Spawn";
+        case 4:
+            return "Disconnected Too Long";
+        case 5:
+            return "Abandon";
+        case 6:
+            return "TD Limit";
+        case 7:
+            return "TD Spawn";
+        case 8:
+        case 14:
+            return "Untrusted";
+        case 9:
+            return "Kicked Too Much";
+        case 10:
+            return "Overwatch (Cheat)";
+        case 11:
+            return "Overwatch (Grief)";
+        case 16:
+            return "Failed To Connect";
+        case 17:
+            return "Kick Abuse";
+        case 18:
+        case 19:
+        case 20:
+            return "Rank Calibration";
+        case 21:
+            return "Reports (Grief)"
+        default:
+            return `Unknown(${id})`;
+    }
+}
+
+export function penalty_reason_permanent(id) {
+    switch (id) {
+        case 8:
+        case 14:
+        case 10:
+            return true;
+        default:
+            return false;
+    }
+}
+
+export function protoDecode(proto, obj) {
+    return proto.toObject(proto.decode(obj), {defaults: true});
+}
+
+export function protoEncode(proto, obj) {
+    return proto.encode(proto.create(obj)).finish();
+}

package/index.js

@@ -1864,6 +1864,7 @@ class SteamUser {
         let result = (await this._httpRequest('chat/clientjstoken'))?.data
         if (!result?.steamid) {
             if (retry !== null && retry !== undefined && retry >= 0) {
+                await sleep(2000)
                 return await this.getClientJsToken(retry - 1)
             } else {
                 return null

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "steamutils",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "dependencies": {
     "axios": "^1.3.4",
     "cheerio": "^1.0.0-rc.12",
     "crypto-js": "^4.1.1",
+    "csgo-friendcode": "^3.0.3",
     "lodash": "^4.17.21",
     "moment": "^2.29.4",
     "node-bignumber": "^1.2.2",
+    "steam-user": "^4.28.1",
     "steamid": "^2.0.0",
     "url-parse": "^1.5.10",
     "xml-js": "^1.6.11",