@lightsparkdev/core 0.2.2 → 0.2.4

package/dist/chunk-GFTKZSHK.js

@@ -1,627 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// 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/crypto/crypto.ts
-var crypto_exports = {};
-__export(crypto_exports, {
-  LightsparkSigningException: () => LightsparkSigningException_default,
-  decryptSecretWithNodePassword: () => decryptSecretWithNodePassword,
-  generateSigningKeyPair: () => generateSigningKeyPair,
-  getNonce: () => getNonce,
-  importPrivateSigningKey: () => importPrivateSigningKey,
-  serializeSigningKey: () => serializeSigningKey,
-  sign: () => sign
-});
-
-// src/utils/base64.ts
-var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
-var Base64 = {
-  btoa: (input = "") => {
-    let str = input;
-    let output = "";
-    for (let block = 0, charCode, i = 0, map = chars; str.charAt(i | 0) || (map = "=", i % 1); output += map.charAt(63 & block >> 8 - i % 1 * 8)) {
-      charCode = str.charCodeAt(i += 3 / 4);
-      if (charCode > 255) {
-        throw new Error("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");
-      }
-      block = block << 8 | charCode;
-    }
-    return output;
-  },
-  atob: (input = "") => {
-    let str = input.replace(/=+$/, "");
-    let output = "";
-    if (str.length % 4 == 1) {
-      throw new Error("'atob' failed: The string to be decoded is not correctly encoded.");
-    }
-    for (let bc = 0, bs = 0, buffer, i = 0; buffer = str.charAt(i++); ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer, bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {
-      buffer = chars.indexOf(buffer);
-    }
-    return output;
-  }
-};
-var b64decode = (encoded) => {
-  return Uint8Array.from(Base64.atob(encoded), (c) => c.charCodeAt(0));
-};
-var urlsafe_b64decode = (encoded) => {
-  return b64decode(encoded.replace(/_/g, "/").replace(/-/g, "+"));
-};
-var b64encode = (data) => {
-  return Base64.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 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-CBWHV2F5.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-CBWHV2F5.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-CBWHV2F5.js")).serializeSigningKey(
-      key,
-      format
-    );
-  }
-  return await cryptoImpl.subtle.exportKey(
-    /*format*/
-    format,
-    /*key*/
-    key
-  );
-};
-var getNonce = async () => {
-  const cryptoImpl = await getCrypto();
-  if (!cryptoImpl.subtle) {
-    return (await import("./crypto-rn-CBWHV2F5.js")).getNonce();
-  }
-  const nonceSt = await getRandomValues32(new Uint32Array(1));
-  return Number(nonceSt);
-};
-var sign = async (key, data) => {
-  const cryptoImpl = await getCrypto();
-  if (!cryptoImpl.subtle) {
-    console.log(typeof key, key);
-    return (await import("./crypto-rn-CBWHV2F5.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-CBWHV2F5.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") {
-    const decoded = b64decode(this.stripPemTags(rawKey));
-    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);
-  }
-  stripPemTags(pem) {
-    return pem.replace(/-----BEGIN (.*)-----/, "").replace(/-----END (.*)----/, "");
-  }
-};
-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, cryptoImpl = crypto_exports) {
-    this.nodeKeyCache = nodeKeyCache;
-    this.schemaEndpoint = schemaEndpoint;
-    this.sdkUserAgent = sdkUserAgent;
-    this.authProvider = authProvider;
-    this.baseUrl = baseUrl;
-    this.cryptoImpl = cryptoImpl;
-    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 this.cryptoImpl.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 this.cryptoImpl.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
-};