yolkbot 1.4.8 → 1.5.1

package/dist/api.d.ts

@@ -1,43 +1,61 @@
+import { APIErrorEnum } from './enums';
+
+export interface RawFirebase {
+    kind: string;
+    idToken: string;
+    refreshToken: string;
+    expiresIn: string; // in seconds
+    localId: string;
+}
+
 export interface QueryRequest {
     cmd: string;
     [key: string]: any;
 }
 
 export interface QueryResponse {
+    ok: true;
     [key: string]: any;
 }
 
+export interface AuthResponse extends QueryResponse {
+    firebase: RawFirebase;
+}
+
+export interface EmailResponse {
+    ok: true;
+    email: string;
+}
+
 interface APIParams {
     proxy?: string;
     protocol?: string;
     instance?: string;
-    maxRetries?: number;
-    suppressErrors?: boolean;
+    customKey?: string | null;
     connectionTimeout?: number;
+    errorLogger?: (...args: any[]) => void;
 }
 
-export type QueryServicesError = 'websocket_connect_fail' | 'bad_json' | 'unknown_socket_error' | 'services_closed_early';
-export type AnonError = 'firebase_network_failed' | 'firebase_no_token';
-export type LoginError = AnonError | 'firebase_no_credentials' | 'firebase_bad_request' | 'firebase_unknown_error';
-export type EmailVerifyError = 'no_idtoken_passed' | 'firebase_invalid_response';
-export type OobCodeError = 'no_oob_code_passed' | 'firebase_unknown_error';
+type ReturnError = { ok: false; error: APIErrorEnum };
+
+type AnyObject = { [key: string]: any };
 
 export class API {
     proxy?: string;
     protocol: string;
     instance: string;
-    maxRetries: number;
-    suppressErrors: boolean;
+    customKey?: string | null;
     connectionTimeout: number;
 
     constructor(params?: APIParams);
 
-    queryServices(request: QueryRequest): Promise<QueryResponse | QueryServicesError>;
+    queryServices(request: QueryRequest): Promise<QueryResponse | ReturnError>;
+
+    createAccount(email: string, password: string, customServicesParams?: AnyObject): Promise<AuthResponse | ReturnError>;
+    loginWithCredentials(email: string, password: string, customServicesParams?: AnyObject): Promise<AuthResponse | ReturnError>;
+    loginWithRefreshToken(refreshToken: string, customServicesParams?: AnyObject): Promise<AuthResponse | ReturnError>;
+    loginAnonymously(customServicesParams?: AnyObject): Promise<AuthResponse | ReturnError>;
 
-    loginWithCredentials(email: string, password: string): Promise<QueryResponse | LoginError>;
-    loginWithRefreshToken(refreshToken: string): Promise<QueryResponse | LoginError>;
-    loginAnonymously(): Promise<QueryResponse | AnonError>;
-    createAccount(email: string, password: string): Promise<QueryResponse | LoginError>;
-    sendEmailVerification(idToken?: string): Promise<{ email: string } | EmailVerifyError>;
-    verifyOobCode(oobCode: string): Promise<QueryResponse | OobCodeError>;
+    sendEmailVerification(idToken?: string): Promise<EmailResponse | ReturnError>;
+    verifyOobCode(oobCode: string): Promise<EmailResponse | ReturnError>;
 }

package/dist/api.js

@@ -1,61 +1,71 @@
 import globals from "./env/globals.js";
 import yolkws from "./socket.js";
+import { APIError } from "./enums.js";
+import { createError } from "./util.js";
 import { FirebaseKey, UserAgent } from "./constants/index.js";
 const baseHeaders = {
   origin: "https://shellshock.io",
-  "user-agent": UserAgent,
+  "user-agent": typeof process === "undefined" ? null : UserAgent,
   "x-client-version": "Chrome/JsCore/9.17.2/FirebaseCore-web",
   "x-firebase-locale": "en"
 };
 
 export class API {
+  errorLogger = (...args) => console.error(...args);
   constructor(params = {}) {
     this.proxy = params.proxy;
     this.instance = params.instance || "shellshock.io";
     this.protocol = params.protocol || "wss";
-    this.maxRetries = params.maxRetries || 5;
-    this.suppressErrors = params.suppressErrors || false;
+    this.customKey = params.customKey || null;
     this.connectionTimeout = params.connectionTimeout || 5000;
+    if (typeof params.errorLogger === "function")
+      this.errorLogger = params.errorLogger;
   }
   queryServices = async (request) => {
-    const ws = new yolkws(`${this.protocol}://${this.instance}/services/`, this.proxy);
+    const ws = new yolkws(`${this.protocol}://${this.instance}/services/`, { proxy: this.proxy, errorLogger: this.errorLogger });
     ws.connectionTimeout = this.connectionTimeout;
-    const didConnect = await ws.tryConnect(-2);
+    const didConnect = await ws.tryConnect();
     if (!didConnect || ws.socket.readyState !== 1)
-      return "websocket_connect_fail";
+      return createError(APIError.WebSocketConnectFail);
     return new Promise((resolve) => {
       let resolved = false;
       ws.onmessage = (mes) => {
         resolved = true;
         try {
           const resp = JSON.parse(mes.data);
-          resolve(resp);
-        } catch {
-          if (!this.suppressErrors) {
-            console.error("queryServices: Bad API JSON response with call:", request.cmd, "and data:", JSON.stringify(request));
-            console.error("queryServices: Full data sent:", JSON.stringify(request));
-          }
-          resolve("bad_json");
+          resolve({ ok: true, ...resp });
+        } catch (e) {
+          this.errorLogger("queryServices: error! command:", request.cmd, "and data:", request, e);
+          resolve(createError(APIError.InternalError));
         }
         ws.close();
       };
-      ws.onerror = () => !resolved && resolve("unknown_socket_error");
-      ws.onclose = () => !resolved && resolve("services_closed_early");
+      ws.onerror = (error) => {
+        if (resolved)
+          return;
+        resolved = true;
+        this.errorLogger("queryServices: websocket error! command:", request.cmd, "and data:", request, "error:", error);
+        resolve(createError(APIError.InternalError));
+      };
+      ws.onclose = () => {
+        if (resolved)
+          return;
+        resolved = true;
+        this.errorLogger("queryServices: services closed before sending back message");
+        this.errorLogger("queryServices: command:", request.cmd, "and data:", request);
+        resolve(createError(APIError.ServicesClosedEarly));
+      };
       ws.send(JSON.stringify(request));
     });
   };
-  #authWithEmailPass = async (email, password, endpoint) => {
+  #authWithEmailPass = async (email, password, customServicesParams, endpoint) => {
     if (!email || !password)
-      return "firebase_no_credentials";
-    let body, firebaseToken;
+      return createError(APIError.MissingParams);
+    let body;
     try {
-      const request = await globals.fetch(`https://identitytoolkit.googleapis.com/v1/accounts:${endpoint}?key=${FirebaseKey}`, {
+      const request = await globals.fetch(`https://identitytoolkit.googleapis.com/v1/accounts:${endpoint}?key=${this.customKey || FirebaseKey}`, {
         method: "POST",
-        body: JSON.stringify({
-          email,
-          password,
-          returnSecureToken: true
-        }),
+        body: JSON.stringify({ email, password, returnSecureToken: true }),
         headers: {
           ...baseHeaders,
           "content-type": "application/json"
@@ -63,47 +73,43 @@ export class API {
         proxy: this.proxy
       });
       body = await request.json();
-      firebaseToken = body.idToken;
     } catch (error) {
-      if (error.code === "auth/network-request-failed") {
-        if (!this.suppressErrors)
-          console.error("loginWithCredentials: Network req failed (auth/network-request-failed)");
-        return "firebase_network_failed";
-      } else if (error.code === "auth/missing-email") {
-        return "firebase_no_credentials";
+      if (error.code === "auth/too-many-requests")
+        return createError(APIError.FirebaseRateLimited);
+      else if (error.code === "auth/network-request-failed") {
+        this.errorLogger("authWithEmailPass: network error", body || error);
+        return createError(APIError.NetworkFail);
       } else if (error.code === "ERR_BAD_REQUEST") {
-        if (!this.suppressErrors)
-          console.error("loginWithCredentials: Error:", email, password);
-        if (!this.suppressErrors)
-          console.error("loginWithCredentials: Error:", body || error);
-        return "firebase_bad_request";
+        this.errorLogger("authWithEmailPass: bad request", body || error);
+        return createError(APIError.InternalError);
+      } else if (error.code === "ECONNREFUSED") {
+        this.errorLogger("authWithEmailPass: connection refused", body || error);
+        return createError(APIError.NetworkFail);
       }
-      if (!this.suppressErrors)
-        console.error("loginWithCredentials: Error:", email, password, error);
-      return "firebase_unknown_error";
+      this.errorLogger("authWithEmailPass: unknown error:", email, error);
+      return createError(APIError.InternalError);
     }
-    if (!firebaseToken) {
-      if (!this.suppressErrors)
-        console.error("loginWithCredentials: the game sent no idToken", body);
-      return "firebase_no_token";
+    if (!body.idToken) {
+      this.errorLogger("authWithEmailPass: missing idToken", body);
+      return createError(APIError.InternalError);
     }
-    this.idToken = firebaseToken;
-    const servicesQuery = await this.queryServices({ cmd: "auth", firebaseToken });
-    return typeof servicesQuery === "object" ? { firebase: body, ...servicesQuery } : servicesQuery;
+    this.idToken = body.idToken;
+    const servicesQuery = await this.queryServices({ cmd: "auth", firebaseToken: body.idToken, ...customServicesParams });
+    return servicesQuery.ok ? { firebase: body, ...servicesQuery } : servicesQuery;
   };
-  createAccount = async (email, password) => await this.#authWithEmailPass(email, password, "signUp");
-  loginWithCredentials = async (email, password) => await this.#authWithEmailPass(email, password, "signInWithPassword");
-  loginWithRefreshToken = async (refreshToken) => {
+  createAccount = (email, password, customServicesParams) => this.#authWithEmailPass(email, password, customServicesParams, "signUp");
+  loginWithCredentials = (email, password, customServicesParams) => this.#authWithEmailPass(email, password, customServicesParams, "signInWithPassword");
+  loginWithRefreshToken = async (refreshToken, customServicesParams) => {
     if (!refreshToken)
-      return "firebase_no_credentials";
+      return createError(APIError.MissingParams);
     const formData = new URLSearchParams;
     formData.append("grant_type", "refresh_token");
     formData.append("refresh_token", refreshToken);
-    let body, token;
+    let body;
     try {
-      const request = await globals.fetch(`https://securetoken.googleapis.com/v1/token?key=${FirebaseKey}`, {
+      const request = await globals.fetch(`https://securetoken.googleapis.com/v1/token?key=${this.customKey || FirebaseKey}`, {
         method: "POST",
-        body: formData,
+        body: formData.toString(),
         headers: {
           ...baseHeaders,
           "content-type": "application/x-www-form-urlencoded"
@@ -111,90 +117,127 @@ export class API {
         proxy: this.proxy
       });
       body = await request.json();
-      token = body.id_token;
     } catch (error) {
-      if (error.code === "auth/network-request-failed") {
-        if (!this.suppressErrors)
-          console.error("loginWithRefreshToken: Network req failed (auth/network-request-failed)");
-        return "firebase_network_failed";
-      } else if (error.code === "auth/missing-email") {
-        return "firebase_no_credentials";
+      if (error.code === "auth/too-many-requests")
+        return createError(APIError.FirebaseRateLimited);
+      else if (error.code === "auth/network-request-failed") {
+        this.errorLogger("loginWithRefreshToken: network error", body || error);
+        return createError(APIError.NetworkFail);
+      } else if (error.code === "ECONNREFUSED") {
+        this.errorLogger("loginWithRefreshToken: connection refused", body || error);
+        return createError(APIError.NetworkFail);
       }
-      if (!this.suppressErrors)
-        console.error("loginWithRefreshToken: Error:", error, refreshToken);
-      return "firebase_unknown_error";
+      this.errorLogger("loginWithRefreshToken: unknown error:", body, error);
+      return createError(APIError.InternalError);
     }
-    if (!token) {
-      if (!this.suppressErrors)
-        console.error("loginWithRefreshToken: the game sent no idToken", body);
-      return "firebase_no_token";
+    if (!body.id_token) {
+      this.errorLogger("loginWithRefreshToken: missing idToken", body);
+      return createError(APIError.InternalError);
     }
-    this.idToken = token;
-    const response = await this.queryServices({ cmd: "auth", firebaseToken: token });
-    return typeof response === "object" ? { firebase: body, ...response } : response;
+    this.idToken = body.id_token;
+    const response = await this.queryServices({ cmd: "auth", firebaseToken: body.id_token, ...customServicesParams });
+    return response.ok ? { firebase: body, ...response } : response;
   };
-  loginAnonymously = async () => {
-    const req = await globals.fetch(`https://identitytoolkit.googleapis.com/v1/accounts:signUp?key=${FirebaseKey}`, {
-      method: "POST",
-      body: JSON.stringify({ returnSecureToken: true }),
-      headers: {
-        ...baseHeaders,
-        "content-type": "application/json"
-      },
-      proxy: this.proxy
-    });
-    const body = await req.json();
-    const firebaseToken = body.idToken;
-    if (!firebaseToken) {
-      if (!this.suppressErrors)
-        console.error("loginAnonymously: the game sent no idToken", body);
-      return "firebase_no_token";
+  loginAnonymously = async (customServicesParams) => {
+    let body;
+    try {
+      const req = await globals.fetch(`https://identitytoolkit.googleapis.com/v1/accounts:signUp?key=${this.customKey || FirebaseKey}`, {
+        method: "POST",
+        body: JSON.stringify({ returnSecureToken: true }),
+        headers: {
+          ...baseHeaders,
+          "content-type": "application/json"
+        },
+        proxy: this.proxy
+      });
+      body = await req.json();
+    } catch (error) {
+      if (error.code === "auth/too-many-requests")
+        return createError(APIError.FirebaseRateLimited);
+      else if (error.code === "ECONNREFUSED") {
+        this.errorLogger("loginAnonymously: connection refused", body || error);
+        return createError(APIError.NetworkFail);
+      }
+      this.errorLogger("loginAnonymously: unknown error:", body, error);
+      return createError(APIError.InternalError);
     }
-    this.idToken = firebaseToken;
-    const query = await this.queryServices({ cmd: "auth", firebaseToken });
-    return typeof query === "object" ? { firebase: body, ...query } : query;
+    if (!body.idToken) {
+      this.errorLogger("loginAnonymously: missing idToken", body);
+      return createError(APIError.InternalError);
+    }
+    this.idToken = body.idToken;
+    const query = await this.queryServices({ cmd: "auth", firebaseToken: body.idToken, ...customServicesParams });
+    return query.ok ? { firebase: body, ...query } : query;
   };
   sendEmailVerification = async (idToken = this.idToken) => {
     if (!idToken)
-      return "no_idtoken_passed";
-    const req = await globals.fetch(`https://identitytoolkit.googleapis.com/v1/accounts:sendOobCode?key=${FirebaseKey}`, {
-      method: "POST",
-      body: JSON.stringify({ requestType: "VERIFY_EMAIL", idToken }),
-      headers: {
-        ...baseHeaders,
-        "content-type": "application/json"
-      },
-      proxy: this.proxy
-    });
-    const body = await req.json();
+      return createError(APIError.MissingParams);
+    let body;
+    try {
+      const req = await globals.fetch(`https://identitytoolkit.googleapis.com/v1/accounts:sendOobCode?key=${this.customKey || FirebaseKey}`, {
+        method: "POST",
+        body: JSON.stringify({ requestType: "VERIFY_EMAIL", idToken }),
+        headers: {
+          ...baseHeaders,
+          "content-type": "application/json"
+        },
+        proxy: this.proxy
+      });
+      body = await req.json();
+    } catch (error) {
+      if (error.code === "auth/too-many-requests")
+        return createError(APIError.FirebaseRateLimited);
+      else if (error.code === "auth/network-request-failed") {
+        this.errorLogger("sendEmailVerification: network error", body || error);
+        return createError(APIError.NetworkFail);
+      } else if (error.code === "ECONNREFUSED") {
+        this.errorLogger("sendEmailVerification: connection refused", body || error);
+        return createError(APIError.NetworkFail);
+      }
+      this.errorLogger("sendEmailVerification: unknown error:", idToken, error);
+      return createError(APIError.InternalError);
+    }
     if (body.kind !== "identitytoolkit#GetOobConfirmationCodeResponse") {
-      if (!this.suppressErrors)
-        console.error("sendEmailVerification: the game sent an invalid response", body);
-      return "firebase_invalid_response";
+      this.errorLogger("sendEmailVerification: the game sent an invalid response", body);
+      return createError(APIError.InternalError);
     }
-    return { email: body.email };
+    return { ok: true, email: body.email };
   };
   verifyOobCode = async (oobCode) => {
     if (!oobCode)
-      return "no_oob_code_passed";
-    const req = await globals.fetch(`https://www.googleapis.com/identitytoolkit/v3/relyingparty/setAccountInfo?key=${FirebaseKey}`, {
-      method: "POST",
-      body: JSON.stringify({ oobCode }),
-      headers: {
-        ...baseHeaders,
-        "x-client-version": "Chrome/JsCore/3.7.5/FirebaseCore-web",
-        referer: "https://shellshockio-181719.firebaseapp.com/",
-        "content-type": "application/json"
-      },
-      proxy: this.proxy
-    });
-    const body = await req.json();
+      return createError(APIError.MissingParams);
+    let body;
+    try {
+      const req = await globals.fetch(`https://www.googleapis.com/identitytoolkit/v3/relyingparty/setAccountInfo?key=${this.customKey || FirebaseKey}`, {
+        method: "POST",
+        body: JSON.stringify({ oobCode }),
+        headers: {
+          ...baseHeaders,
+          "x-client-version": "Chrome/JsCore/3.7.5/FirebaseCore-web",
+          referer: "https://shellshockio-181719.firebaseapp.com/",
+          "content-type": "application/json"
+        },
+        proxy: this.proxy
+      });
+      body = await req.json();
+    } catch (error) {
+      if (error.code === "auth/too-many-requests")
+        return createError(APIError.FirebaseRateLimited);
+      else if (error.code === "auth/network-request-failed") {
+        this.errorLogger("verifyOobCode: network error", body || error);
+        return createError(APIError.NetworkFail);
+      } else if (error.code === "ECONNREFUSED") {
+        this.errorLogger("verifyOobCode: connection refused", body || error);
+        return createError(APIError.NetworkFail);
+      }
+      this.errorLogger("verifyOobCode: unknown error:", oobCode, error);
+      return createError(APIError.InternalError);
+    }
     if (!body.emailVerified) {
-      if (!this.suppressErrors)
-        console.error("verifyOobCode: the game sent an invalid response", body);
-      return "firebase_invalid_response";
+      this.errorLogger("verifyOobCode: the game sent an invalid response", body);
+      return createError(APIError.InternalError);
     }
-    return body.email;
+    return { ok: true, email: body.email };
   };
 }
 export default API;

package/dist/bot/GamePlayer.d.ts

@@ -1,4 +1,4 @@
-import { AnyGun, Cluck9mm } from '../constants/guns';
+import { CreatedGun } from '../constants/guns';
 import { Item } from '../constants/items';
 
 export interface Position {
@@ -87,7 +87,7 @@ export interface Social {
     active: boolean;
 }
 
-export type PlayerWeapons = [AnyGun, Cluck9mm];
+export type PlayerWeapons = [CreatedGun, CreatedGun];
 
 export interface PlayerAdminData {
     ip: string;

package/dist/bot/GamePlayer.js

@@ -1,5 +1,6 @@
 import { GunList, Movement, ShellStreak, SocialMedia } from "../constants/index.js";
 import { Cluck9mm } from "../constants/guns.js";
+import { createGun } from "../util.js";
 const RSocialMedia = Object.fromEntries(Object.entries(SocialMedia).map(([key, value]) => [value, key.toLowerCase()]));
 
 export class GamePlayer {
@@ -10,9 +11,18 @@ export class GamePlayer {
     this.safeName = playerData.safeName;
     this.team = playerData.team;
     this.playing = playerData.playing;
-    this.socials = playerData.social && JSON.parse(playerData.social);
-    if (this.socials)
-      this.socials.forEach((social) => social.type = RSocialMedia[social.id]);
+    this.socials = [];
+    if (typeof playerData.social === "string" && playerData.social.length) {
+      try {
+        const parsed = JSON.parse(playerData.social);
+        if (Array.isArray(parsed))
+          this.socials = parsed;
+      } catch (e) {
+        console.error("Error parsing socials:", e);
+        console.error("Report this on Github!");
+      }
+    }
+    this.socials.forEach((social) => social.type = RSocialMedia[social.id]);
     this.isVip = playerData.upgradeProductId > 0;
     this.showBadge = !playerData.hideBadge || false;
     this.streak = playerData.score;
@@ -53,8 +63,8 @@ export class GamePlayer {
     this.selectedGun = playerData.charClass;
     this.weapons = [];
     if (this.character.primaryGun) {
-      this.weapons[0] = new GunList[this.selectedGun];
-      this.weapons[1] = new Cluck9mm;
+      this.weapons[0] = createGun(GunList[this.selectedGun]);
+      this.weapons[1] = createGun(Cluck9mm);
     }
     this.grenades = 1;
     this.hp = playerData.hp;