@lightsparkdev/core 0.2.1 → 0.2.2

package/dist/chunk-BAQMCJ7C.js

@@ -0,0 +1,630 @@
+// 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;
+  }
+  async addWsConnectionParams(params) {
+    return params;
+  }
+};
+
+// src/utils/base64.ts
+var encode = (input) => {
+  var output = [];
+  var chr1, chr2, chr3 = "";
+  var enc1, enc2, enc3, enc4 = "";
+  var i = 0;
+  do {
+    chr1 = input.charCodeAt(i++);
+    chr2 = input.charCodeAt(i++);
+    chr3 = input.charCodeAt(i++);
+    enc1 = chr1 >> 2;
+    enc2 = (chr1 & 3) << 4 | chr2 >> 4;
+    enc3 = (chr2 & 15) << 2 | chr3 >> 6;
+    enc4 = chr3 & 63;
+    if (isNaN(chr2)) {
+      enc3 = enc4 = 64;
+    } else if (isNaN(chr3)) {
+      enc4 = 64;
+    }
+    output.push(
+      keyStr.charAt(enc1) + keyStr.charAt(enc2) + keyStr.charAt(enc3) + keyStr.charAt(enc4)
+    );
+    chr1 = chr2 = chr3 = "";
+    enc1 = enc2 = enc3 = enc4 = "";
+  } while (i < input.length);
+  return output.join("");
+};
+var decode = (input) => {
+  var output = "";
+  var chr1, chr2, chr3 = "";
+  var enc1, enc2, enc3, enc4 = "";
+  var i = 0;
+  var base64test = /[^A-Za-z0-9\+\/\=]/g;
+  if (base64test.exec(input)) {
+    throw new Error("There were invalid base64 characters in the input text.\nValid base64 characters are A-Z, a-z, 0-9, '+', '/',and '='\nExpect errors in decoding.");
+  }
+  input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+  do {
+    enc1 = keyStr.indexOf(input.charAt(i++));
+    enc2 = keyStr.indexOf(input.charAt(i++));
+    enc3 = keyStr.indexOf(input.charAt(i++));
+    enc4 = keyStr.indexOf(input.charAt(i++));
+    chr1 = enc1 << 2 | enc2 >> 4;
+    chr2 = (enc2 & 15) << 4 | enc3 >> 2;
+    chr3 = (enc3 & 3) << 6 | enc4;
+    output = output + String.fromCharCode(chr1);
+    if (enc3 != 64) {
+      output = output + String.fromCharCode(chr2);
+    }
+    if (enc4 != 64) {
+      output = output + String.fromCharCode(chr3);
+    }
+    chr1 = chr2 = chr3 = "";
+    enc1 = enc2 = enc3 = enc4 = "";
+  } while (i < input.length);
+  return output;
+};
+var b64decode = (encoded) => {
+  return Uint8Array.from(decode(encoded), (c) => c.charCodeAt(0));
+};
+var urlsafe_b64decode = (encoded) => {
+  return b64decode(encoded.replace(/_/g, "/").replace(/-/g, "+"));
+};
+var b64encode = (data) => {
+  return encode(
+    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 getCrypto = () => {
+  let cryptoImplPromise;
+  if (typeof crypto !== "undefined") {
+    cryptoImplPromise = Promise.resolve(crypto);
+  } else {
+    cryptoImplPromise = import("crypto").then((nodeCrypto) => {
+      return nodeCrypto;
+    });
+  }
+  return cryptoImplPromise;
+};
+var getRandomValues32 = async (arr) => {
+  if (typeof crypto !== "undefined") {
+    return crypto.getRandomValues(arr);
+  } else {
+    const cryptoImpl = await getCrypto();
+    return cryptoImpl.getRandomValues(arr);
+  }
+};
+var deriveKey = async (password, salt, iterations, algorithm, bit_len) => {
+  const enc = new TextEncoder();
+  const cryptoImpl = await getCrypto();
+  const password_key = await cryptoImpl.subtle.importKey(
+    "raw",
+    enc.encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits", "deriveKey"]
+  );
+  const derived = await cryptoImpl.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt,
+      iterations,
+      hash: "SHA-256"
+    },
+    password_key,
+    bit_len
+  );
+  const key = await cryptoImpl.subtle.importKey(
+    "raw",
+    derived.slice(0, 32),
+    { name: algorithm, length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+  const iv = derived.slice(32);
+  return [key, iv];
+};
+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 cryptoImpl = 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 cryptoImpl.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 cryptoImpl.subtle.decrypt(
+      { name: algorithm, iv },
+      key,
+      encrypted
+    );
+  }
+};
+async function decryptSecretWithNodePassword(cipher, encryptedSecret, nodePassword) {
+  const cryptoImpl = await getCrypto();
+  if (!cryptoImpl.subtle) {
+    return (await import("./crypto-rn-7DWXMO2Q.js")).decryptSecretWithNodePassword(
+      cipher,
+      encryptedSecret,
+      nodePassword
+    );
+  }
+  let decryptedValue = null;
+  try {
+    decryptedValue = await decrypt(cipher, encryptedSecret, nodePassword);
+  } catch (ex) {
+    console.error(ex);
+  }
+  return decryptedValue;
+}
+var generateSigningKeyPair = async () => {
+  const cryptoImpl = await getCrypto();
+  if (!cryptoImpl.subtle) {
+    return (await import("./crypto-rn-7DWXMO2Q.js")).generateSigningKeyPair();
+  }
+  return await cryptoImpl.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 cryptoImpl = await getCrypto();
+  if (!cryptoImpl.subtle) {
+    return (await import("./crypto-rn-7DWXMO2Q.js")).serializeSigningKey(key, format);
+  }
+  return await cryptoImpl.subtle.exportKey(
+    /*format*/
+    format,
+    /*key*/
+    key
+  );
+};
+var getNonce = async () => {
+  const nonceSt = await getRandomValues32(new Uint32Array(1));
+  return Number(nonceSt);
+};
+var sign = async (key, data) => {
+  const cryptoImpl = await getCrypto();
+  if (!cryptoImpl.subtle) {
+    return (await import("./crypto-rn-7DWXMO2Q.js")).sign(key, data);
+  }
+  return await cryptoImpl.subtle.sign(
+    {
+      name: "RSA-PSS",
+      saltLength: 32
+    },
+    key,
+    data
+  );
+};
+var importPrivateSigningKey = async (keyData, format) => {
+  const cryptoImpl = await getCrypto();
+  if (!cryptoImpl.subtle) {
+    return (await import("./crypto-rn-7DWXMO2Q.js")).importPrivateSigningKey(
+      keyData,
+      format
+    );
+  }
+  return await cryptoImpl.subtle.importKey(
+    /*format*/
+    format,
+    /*keyData*/
+    keyData,
+    /*algorithm*/
+    {
+      name: "RSA-PSS",
+      hash: "SHA-256"
+    },
+    /*extractable*/
+    true,
+    /*keyUsages*/
+    ["sign"]
+  );
+};
+
+// 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, format = "pkcs8") {
+    console.log("Loading key: ", id, rawKey);
+    const decoded = b64decode(rawKey);
+    console.log("Decoded key: ", decoded);
+    console.log("b64 again", b64encode(decoded));
+    try {
+      const key = await importPrivateSigningKey(decoded, format);
+      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, sdkUserAgent, authProvider = new StubAuthProvider(), baseUrl = DEFAULT_BASE_URL) {
+    this.nodeKeyCache = nodeKeyCache;
+    this.schemaEndpoint = schemaEndpoint;
+    this.sdkUserAgent = sdkUserAgent;
+    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 : "";
+    return `${this.sdkUserAgent} ${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"
+      );
+    }
+    if (typeof TextEncoder === "undefined") {
+      const TextEncoder2 = (await import("text-encoding")).TextEncoder;
+    }
+    ;
+    const encodedPayload = new TextEncoder().encode(JSON.stringify(payload));
+    const signedPayload = await sign(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 {
+  LightsparkException_default,
+  LightsparkAuthException_default,
+  StubAuthProvider,
+  b64decode,
+  urlsafe_b64decode,
+  b64encode,
+  LightsparkSigningException_default,
+  decryptSecretWithNodePassword,
+  generateSigningKeyPair,
+  serializeSigningKey,
+  getNonce,
+  sign,
+  importPrivateSigningKey,
+  NodeKeyCache_default,
+  isBrowser,
+  isNode,
+  Requester_default,
+  apiDomainForEnvironment,
+  ServerEnvironment_default,
+  convertCurrencyAmount,
+  isType
+};