@lightsparkdev/core 0.1.3

package/dist/index.js

@@ -0,0 +1,602 @@
+// src/LightsparkException.ts
+var LightsparkException = class extends Error {
+  code;
+  message;
+  extraInfo;
+  constructor(code, message, extraInfo) {
+    super(message);
+    this.code = code;
+    this.message = message;
+    this.extraInfo = extraInfo;
+  }
+};
+var LightsparkException_default = LightsparkException;
+
+// src/auth/LightsparkAuthException.ts
+var LightsparkAuthException = class extends LightsparkException_default {
+  constructor(message, extraInfo) {
+    super("AuthException", message, extraInfo);
+  }
+};
+var LightsparkAuthException_default = LightsparkAuthException;
+
+// src/auth/StubAuthProvider.ts
+var StubAuthProvider = class {
+  async addAuthHeaders(headers) {
+    return headers;
+  }
+  async isAuthorized() {
+    return false;
+  }
+  addWsConnectionParams(params) {
+    return params;
+  }
+};
+
+// src/utils/base64.ts
+var b64decode = (encoded) => {
+  return Uint8Array.from(atob(encoded), (c) => c.charCodeAt(0));
+};
+var urlsafe_b64decode = (encoded) => {
+  return b64decode(encoded.replace(/_/g, "/").replace(/-/g, "+"));
+};
+var b64encode = (data) => {
+  return btoa(
+    String.fromCharCode.apply(null, Array.from(new Uint8Array(data)))
+  );
+};
+
+// src/crypto/LightsparkSigningException.ts
+var LightsparkSigningException = class extends LightsparkException_default {
+  constructor(message, extraInfo) {
+    super("SigningException", message, extraInfo);
+  }
+};
+var LightsparkSigningException_default = LightsparkSigningException;
+
+// src/crypto/crypto.ts
+var ITERATIONS = 5e5;
+function getCrypto() {
+  let cryptoImplPromise;
+  if (typeof crypto !== "undefined") {
+    cryptoImplPromise = Promise.resolve(crypto);
+  } else {
+    cryptoImplPromise = import("crypto").then((nodeCrypto) => {
+      return nodeCrypto;
+    });
+  }
+  return cryptoImplPromise;
+}
+var getRandomValues = async (arr) => {
+  if (typeof crypto !== "undefined") {
+    return crypto.getRandomValues(arr);
+  } else {
+    const cryptoImpl2 = await getCrypto();
+    return cryptoImpl2.getRandomValues(arr);
+  }
+};
+var getRandomValues32 = async (arr) => {
+  if (typeof crypto !== "undefined") {
+    return crypto.getRandomValues(arr);
+  } else {
+    const cryptoImpl2 = await getCrypto();
+    return cryptoImpl2.getRandomValues(arr);
+  }
+};
+var deriveKey = async (password, salt, iterations, algorithm, bit_len) => {
+  const enc = new TextEncoder();
+  const cryptoImpl2 = await getCrypto();
+  const password_key = await cryptoImpl2.subtle.importKey(
+    "raw",
+    enc.encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits", "deriveKey"]
+  );
+  const derived = await cryptoImpl2.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt,
+      iterations,
+      hash: "SHA-256"
+    },
+    password_key,
+    bit_len
+  );
+  const key = await cryptoImpl2.subtle.importKey(
+    "raw",
+    derived.slice(0, 32),
+    { name: algorithm, length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+  const iv = derived.slice(32);
+  return [key, iv];
+};
+var encrypt = async (plaintext, password, salt) => {
+  if (!salt) {
+    salt = new Uint8Array(16);
+    getRandomValues(salt);
+  }
+  const [key, iv] = await deriveKey(password, salt, ITERATIONS, "AES-GCM", 352);
+  const cryptoImpl2 = await getCrypto();
+  const encrypted = new Uint8Array(
+    await cryptoImpl2.subtle.encrypt({ name: "AES-GCM", iv }, key, plaintext)
+  );
+  const output = new Uint8Array(salt.byteLength + encrypted.byteLength);
+  output.set(salt);
+  output.set(encrypted, salt.byteLength);
+  const header = {
+    v: 4,
+    i: ITERATIONS
+  };
+  return [JSON.stringify(header), b64encode(output)];
+};
+var decrypt = async (header_json, ciphertext, password) => {
+  var decoded = b64decode(ciphertext);
+  var header;
+  if (header_json === "AES_256_CBC_PBKDF2_5000_SHA256") {
+    header = {
+      v: 0,
+      i: 5e3
+    };
+    decoded = decoded.slice(8);
+  } else {
+    header = JSON.parse(header_json);
+  }
+  if (header.v < 0 || header.v > 4) {
+    throw new LightsparkException_default(
+      "DecryptionError",
+      "Unknown version ".concat(header.v)
+    );
+  }
+  const cryptoImpl2 = await getCrypto();
+  const algorithm = header.v < 2 ? "AES-CBC" : "AES-GCM";
+  const bit_len = header.v < 4 ? 384 : 352;
+  const salt_len = header.v < 4 ? 8 : 16;
+  if (header.lsv === 2 || header.v === 3) {
+    const salt = decoded.slice(decoded.length - 8, decoded.length);
+    const nonce = decoded.slice(0, 12);
+    const cipherText = decoded.slice(12, decoded.length - 8);
+    const [key, _iv] = await deriveKey(
+      password,
+      salt,
+      header.i,
+      algorithm,
+      256
+    );
+    return await cryptoImpl2.subtle.decrypt(
+      { name: algorithm, iv: nonce.buffer },
+      key,
+      cipherText
+    );
+  } else {
+    const salt = decoded.slice(0, salt_len);
+    const encrypted = decoded.slice(salt_len);
+    const [key, iv] = await deriveKey(
+      password,
+      salt,
+      header.i,
+      algorithm,
+      bit_len
+    );
+    return await cryptoImpl2.subtle.decrypt(
+      { name: algorithm, iv },
+      key,
+      encrypted
+    );
+  }
+};
+async function decryptSecretWithNodePassword(cipher, encryptedSecret, nodePassword) {
+  let decryptedValue = null;
+  try {
+    decryptedValue = await decrypt(cipher, encryptedSecret, nodePassword);
+  } catch (ex) {
+    console.error(ex);
+  }
+  return decryptedValue;
+}
+function decode(arrBuff) {
+  const dec = new TextDecoder();
+  return dec.decode(arrBuff);
+}
+var generateSigningKeyPair = async () => {
+  const cryptoImpl2 = await getCrypto();
+  return await cryptoImpl2.subtle.generateKey(
+    /*algorithm:*/
+    {
+      name: "RSA-PSS",
+      modulusLength: 4096,
+      publicExponent: new Uint8Array([1, 0, 1]),
+      hash: "SHA-256"
+    },
+    /*extractable*/
+    true,
+    /*keyUsages*/
+    ["sign", "verify"]
+  );
+};
+var serializeSigningKey = async (key, format) => {
+  const cryptoImpl2 = await getCrypto();
+  return await cryptoImpl2.subtle.exportKey(
+    /*format*/
+    format,
+    /*key*/
+    key
+  );
+};
+var encryptWithNodeKey = async (key, data) => {
+  const enc = new TextEncoder();
+  const encoded = enc.encode(data);
+  const encrypted = await cryptoImpl.subtle.encrypt(
+    /*algorithm:*/
+    {
+      name: "RSA-OAEP"
+    },
+    /*key*/
+    key,
+    /*data*/
+    encoded
+  );
+  return b64encode(encrypted);
+};
+var loadNodeEncryptionKey = async (rawPublicKey) => {
+  const encoded = b64decode(rawPublicKey);
+  const cryptoImpl2 = await getCrypto();
+  return await cryptoImpl2.subtle.importKey(
+    /*format*/
+    "spki",
+    /*keyData*/
+    encoded,
+    /*algorithm:*/
+    {
+      name: "RSA-OAEP",
+      hash: "SHA-256"
+    },
+    /*extractable*/
+    true,
+    /*keyUsages*/
+    ["encrypt"]
+  );
+};
+var getNonce = async () => {
+  const nonceSt = await getRandomValues32(new Uint32Array(1));
+  return Number(nonceSt);
+};
+
+// src/crypto/NodeKeyCache.ts
+import autoBind from "auto-bind";
+var NodeKeyCache = class {
+  idToKey;
+  constructor() {
+    this.idToKey = /* @__PURE__ */ new Map();
+    autoBind(this);
+  }
+  async loadKey(id, rawKey) {
+    const decoded = b64decode(rawKey);
+    try {
+      const cryptoImpl2 = await getCrypto();
+      const key = await cryptoImpl2.subtle.importKey(
+        "pkcs8",
+        decoded,
+        {
+          name: "RSA-PSS",
+          hash: "SHA-256"
+        },
+        true,
+        ["sign"]
+      );
+      this.idToKey.set(id, key);
+      return key;
+    } catch (e) {
+      console.log("Error importing key: ", e);
+    }
+    return null;
+  }
+  getKey(id) {
+    return this.idToKey.get(id);
+  }
+  hasKey(id) {
+    return this.idToKey.has(id);
+  }
+};
+var NodeKeyCache_default = NodeKeyCache;
+
+// src/requester/Requester.ts
+import autoBind2 from "auto-bind";
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+import { createClient } from "graphql-ws";
+import NodeWebSocket from "ws";
+import { Observable } from "zen-observable-ts";
+
+// src/utils/environment.ts
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+
+// src/requester/Requester.ts
+var DEFAULT_BASE_URL = "api.lightspark.com";
+var LIGHTSPARK_BETA_HEADER_KEY = "X-Lightspark-Beta";
+var LIGHTSPARK_BETA_HEADER_VALUE = "z2h0BBYxTA83cjW7fi8QwWtBPCzkQKiemcuhKY08LOo";
+dayjs.extend(utc);
+var Requester = class {
+  constructor(nodeKeyCache, schemaEndpoint, authProvider = new StubAuthProvider(), baseUrl = DEFAULT_BASE_URL) {
+    this.nodeKeyCache = nodeKeyCache;
+    this.schemaEndpoint = schemaEndpoint;
+    this.authProvider = authProvider;
+    this.baseUrl = baseUrl;
+    let websocketImpl;
+    if (typeof WebSocket === "undefined" && typeof window === "undefined") {
+      websocketImpl = NodeWebSocket;
+    }
+    this.wsClient = createClient({
+      url: `wss://${this.baseUrl}/${this.schemaEndpoint}`,
+      connectionParams: authProvider.addWsConnectionParams({}),
+      webSocketImpl: websocketImpl
+    });
+    autoBind2(this);
+  }
+  wsClient;
+  async executeQuery(query) {
+    const data = await this.makeRawRequest(
+      query.queryPayload,
+      query.variables || {},
+      query.signingNodeId
+    );
+    return query.constructObject(data);
+  }
+  subscribe(queryPayload, variables = {}) {
+    const operationNameRegex = /^\s*(query|mutation|subscription)\s+(\w+)/i;
+    const operationMatch = queryPayload.match(operationNameRegex);
+    if (!operationMatch || operationMatch.length < 3) {
+      throw new LightsparkException_default("InvalidQuery", "Invalid query payload");
+    }
+    const operationType = operationMatch[1];
+    if (operationType == "mutation") {
+      throw new LightsparkException_default(
+        "InvalidQuery",
+        "Mutation queries should call makeRawRequest instead"
+      );
+    }
+    for (const key in variables) {
+      if (variables[key] === void 0) {
+        variables[key] = null;
+      }
+    }
+    const operation = operationMatch[2];
+    let bodyData = {
+      query: queryPayload,
+      variables,
+      operationName: operation
+    };
+    return new Observable(
+      (observer) => this.wsClient.subscribe(bodyData, {
+        next: (data) => observer.next(data),
+        error: (err) => observer.error(err),
+        complete: () => observer.complete()
+      })
+    );
+  }
+  async makeRawRequest(queryPayload, variables = {}, signingNodeId = void 0) {
+    const operationNameRegex = /^\s*(query|mutation|subscription)\s+(\w+)/i;
+    const operationMatch = queryPayload.match(operationNameRegex);
+    if (!operationMatch || operationMatch.length < 3) {
+      throw new LightsparkException_default("InvalidQuery", "Invalid query payload");
+    }
+    const operationType = operationMatch[1];
+    if (operationType == "subscription") {
+      throw new LightsparkException_default(
+        "InvalidQuery",
+        "Subscription queries should call subscribe instead"
+      );
+    }
+    for (const key in variables) {
+      if (variables[key] === void 0) {
+        variables[key] = null;
+      }
+    }
+    const operation = operationMatch[2];
+    let bodyData = {
+      query: queryPayload,
+      variables,
+      operationName: operation
+    };
+    const browserUserAgent = typeof navigator !== "undefined" ? navigator.userAgent : "";
+    const sdkUserAgent = this.getSdkUserAgent();
+    const headers = await this.authProvider.addAuthHeaders({
+      "Content-Type": "application/json",
+      [LIGHTSPARK_BETA_HEADER_KEY]: LIGHTSPARK_BETA_HEADER_VALUE,
+      "X-Lightspark-SDK": sdkUserAgent,
+      "User-Agent": browserUserAgent || sdkUserAgent
+    });
+    bodyData = await this.addSigningDataIfNeeded(
+      bodyData,
+      headers,
+      signingNodeId
+    );
+    const response = await fetch(
+      `https://${this.baseUrl}/${this.schemaEndpoint}`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(bodyData)
+      }
+    );
+    if (!response.ok) {
+      throw new LightsparkException_default(
+        "RequestFailed",
+        `Request ${operation} failed. ${response.statusText}`
+      );
+    }
+    const responseJson = await response.json();
+    const data = responseJson.data;
+    if (!data) {
+      throw new LightsparkException_default(
+        "RequestFailed",
+        `Request ${operation} failed. ${JSON.stringify(responseJson.errors)}`
+      );
+    }
+    return data;
+  }
+  getSdkUserAgent() {
+    const platform = isNode ? "NodeJS" : "Browser";
+    const platformVersion = isNode ? process.version : "";
+    const sdkVersion = "1.0.4";
+    return `lightspark-js-sdk/${sdkVersion} ${platform}/${platformVersion}`;
+  }
+  async addSigningDataIfNeeded(queryPayload, headers, signingNodeId) {
+    if (!signingNodeId) {
+      return queryPayload;
+    }
+    const query = queryPayload.query;
+    const variables = queryPayload.variables;
+    const operationName = queryPayload.operationName;
+    const nonce = await getNonce();
+    const expiration = dayjs.utc().add(1, "hour").format();
+    const payload = {
+      query,
+      variables,
+      operationName,
+      nonce,
+      expires_at: expiration
+    };
+    const key = await this.nodeKeyCache.getKey(signingNodeId);
+    if (!key) {
+      throw new LightsparkSigningException_default(
+        "Missing node of encrypted_signing_private_key"
+      );
+    }
+    const encodedPayload = new TextEncoder().encode(JSON.stringify(payload));
+    const cryptoImpl2 = await getCrypto();
+    const signedPayload = await cryptoImpl2.subtle.sign(
+      {
+        name: "RSA-PSS",
+        saltLength: 32
+      },
+      key,
+      encodedPayload
+    );
+    const encodedSignedPayload = b64encode(signedPayload);
+    headers["X-Lightspark-Signing"] = JSON.stringify({
+      v: "1",
+      signature: encodedSignedPayload
+    });
+    return payload;
+  }
+};
+var Requester_default = Requester;
+
+// src/ServerEnvironment.ts
+var ServerEnvironment = /* @__PURE__ */ ((ServerEnvironment2) => {
+  ServerEnvironment2["PRODUCTION"] = "production";
+  ServerEnvironment2["DEV"] = "dev";
+  return ServerEnvironment2;
+})(ServerEnvironment || {});
+var apiDomainForEnvironment = (environment) => {
+  switch (environment) {
+    case "dev" /* DEV */:
+      return "api.dev.dev.sparkinfra.net";
+    case "production" /* PRODUCTION */:
+      return "api.lightspark.com";
+  }
+};
+var ServerEnvironment_default = ServerEnvironment;
+
+// src/utils/currency.ts
+var CONVERSION_MAP = {
+  ["BITCOIN" /* BITCOIN */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => v,
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v * 1e6,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => v * 1e3,
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e11,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 1e9,
+    ["SATOSHI" /* SATOSHI */]: (v) => v * 1e8
+  },
+  ["MICROBITCOIN" /* MICROBITCOIN */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e6),
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e3),
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e5,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 1e3,
+    ["SATOSHI" /* SATOSHI */]: (v) => v * 100
+  },
+  ["MILLIBITCOIN" /* MILLIBITCOIN */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e3),
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => v * 1e3,
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => v,
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e8,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 1e6,
+    ["SATOSHI" /* SATOSHI */]: (v) => v * 1e5
+  },
+  ["MILLISATOSHI" /* MILLISATOSHI */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e11),
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => Math.round(v / 1e5),
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e8),
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => Math.round(v / 100),
+    ["SATOSHI" /* SATOSHI */]: (v) => Math.round(v / 1e3)
+  },
+  ["NANOBITCOIN" /* NANOBITCOIN */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e9),
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => Math.round(v / 1e3),
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e6),
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 100,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v,
+    ["SATOSHI" /* SATOSHI */]: (v) => Math.round(v / 10)
+  },
+  ["SATOSHI" /* SATOSHI */]: {
+    ["BITCOIN" /* BITCOIN */]: (v) => Math.round(v / 1e8),
+    ["MICROBITCOIN" /* MICROBITCOIN */]: (v) => Math.round(v / 100),
+    ["MILLIBITCOIN" /* MILLIBITCOIN */]: (v) => Math.round(v / 1e5),
+    ["MILLISATOSHI" /* MILLISATOSHI */]: (v) => v * 1e3,
+    ["NANOBITCOIN" /* NANOBITCOIN */]: (v) => v * 10,
+    ["SATOSHI" /* SATOSHI */]: (v) => v
+  }
+};
+var convertCurrencyAmount = (from, toUnit) => {
+  const conversionFn = CONVERSION_MAP[from.originalUnit][toUnit];
+  if (!conversionFn) {
+    throw new LightsparkException_default(
+      "CurrencyError",
+      `Cannot convert from ${from.originalUnit} to ${toUnit}`
+    );
+  }
+  return {
+    ...from,
+    preferredCurrencyUnit: toUnit,
+    preferredCurrencyValueApprox: conversionFn(from.originalValue),
+    preferredCurrencyValueRounded: conversionFn(from.originalValue)
+  };
+};
+
+// src/utils/types.ts
+var isType = (typename) => (node) => {
+  return node?.__typename === typename;
+};
+export {
+  LightsparkAuthException_default as LightsparkAuthException,
+  LightsparkException_default as LightsparkException,
+  LightsparkSigningException_default as LightsparkSigningException,
+  NodeKeyCache_default as NodeKeyCache,
+  Requester_default as Requester,
+  ServerEnvironment_default as ServerEnvironment,
+  StubAuthProvider,
+  apiDomainForEnvironment,
+  b64decode,
+  b64encode,
+  convertCurrencyAmount,
+  decode,
+  decrypt,
+  decryptSecretWithNodePassword,
+  encrypt,
+  encryptWithNodeKey,
+  generateSigningKeyPair,
+  getCrypto,
+  getNonce,
+  isBrowser,
+  isNode,
+  isType,
+  loadNodeEncryptionKey,
+  serializeSigningKey,
+  urlsafe_b64decode
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@lightsparkdev/core",
+  "version": "0.1.3",
+  "description": "Lightspark JS SDK",
+  "author": "Lightspark Inc.",
+  "keywords": [
+    "lightspark",
+    "bitcoin",
+    "lightning",
+    "payments",
+    "typescript"
+  ],
+  "homepage": "https://github.com/lightsparkdev/js-sdk",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lightsparkdev/js-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lightsparkdev/js-sdk/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "engines": {
+    "node": ">=14.16"
+  },
+  "browser": {
+    "crypto": false
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "yarn build -- --watch",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    "lint": "npx prettier --check ./src",
+    "format": "npx prettier --write ./src",
+    "test": "tsc --noEmit --project tsconfig-test.json && jest --no-cache --runInBand --bail",
+    "type-check": "tsc --noEmit",
+    "postversion": "yarn build"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@openid/appauth": "^1.3.1",
+    "auto-bind": "^5.0.1",
+    "crypto": "^1.0.1",
+    "crypto-browserify": "^3.12.0",
+    "dayjs": "^1.11.7",
+    "graphql": "^16.6.0",
+    "graphql-ws": "^5.11.3",
+    "ws": "^8.12.1",
+    "zen-observable-ts": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/crypto-js": "^4.1.1",
+    "@types/ws": "^8.5.4",
+    "jest": "^29.4.1",
+    "prettier": "^2.8.4",
+    "prettier-plugin-organize-imports": "^3.2.2",
+    "ts-jest": "^29.0.5",
+    "tsup": "^6.7.0",
+    "typescript": "^4.9.5"
+  }
+}

package/src/LightsparkException.ts

@@ -0,0 +1,16 @@
+// Copyright ©, 2023-present, Lightspark Group, Inc. - All Rights Reserved
+
+class LightsparkException extends Error {
+  code: string;
+  message: string;
+  extraInfo: any;
+
+  constructor(code: string, message: string, extraInfo?: any) {
+    super(message);
+    this.code = code;
+    this.message = message;
+    this.extraInfo = extraInfo;
+  }
+}
+
+export default LightsparkException;

package/src/ServerEnvironment.ts

@@ -0,0 +1,17 @@
+enum ServerEnvironment {
+  PRODUCTION = "production",
+  DEV = "dev",
+}
+
+export const apiDomainForEnvironment = (
+  environment: ServerEnvironment
+): string => {
+  switch (environment) {
+    case ServerEnvironment.DEV:
+      return "api.dev.dev.sparkinfra.net";
+    case ServerEnvironment.PRODUCTION:
+      return "api.lightspark.com";
+  }
+};
+
+export default ServerEnvironment;

package/src/auth/AuthProvider.ts

@@ -0,0 +1,7 @@
+// Copyright ©, 2023-present, Lightspark Group, Inc. - All Rights Reserved
+
+export default interface AuthProvider {
+  addAuthHeaders(headers: any): Promise<any>;
+  isAuthorized(): Promise<boolean>;
+  addWsConnectionParams(params: any): any;
+}