@lightsparkdev/core 0.2.0 → 0.2.2

package/dist/chunk-ZUIUADXH.js

@@ -0,0 +1,616 @@
+// 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 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-5KM2YVOI.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-5KM2YVOI.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-5KM2YVOI.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-5KM2YVOI.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-5KM2YVOI.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-5KM2YVOI.js")).importPrivateSigningKey(
+      keyData,
+      format
+    );
+  }
+  return await cryptoImpl.subtle.importKey(
+    /*format*/
+    format,
+    /*keyData*/
+    keyData,
+    /*algorithm*/
+    {
+      name: "RSA-PSS",
+      hash: "SHA-256"
+    },
+    /*extractable*/
+    true,
+    /*keyUsages*/
+    ["sign"]
+  );
+};
+var DefaultCrypto = {
+  decryptSecretWithNodePassword,
+  generateSigningKeyPair,
+  serializeSigningKey,
+  getNonce,
+  sign,
+  importPrivateSigningKey
+};
+
+// src/crypto/NodeKeyCache.ts
+import autoBind from "auto-bind";
+var NodeKeyCache = class {
+  constructor(cryptoImpl = DefaultCrypto) {
+    this.cryptoImpl = cryptoImpl;
+    this.idToKey = /* @__PURE__ */ new Map();
+    autoBind(this);
+  }
+  idToKey;
+  async loadKey(id, rawKey, format = "pkcs8") {
+    const decoded = b64decode(this.stripPemTags(rawKey));
+    try {
+      const key = await this.cryptoImpl.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 = DefaultCrypto) {
+    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,
+  DefaultCrypto,
+  NodeKeyCache_default,
+  isBrowser,
+  isNode,
+  Requester_default,
+  apiDomainForEnvironment,
+  ServerEnvironment_default,
+  convertCurrencyAmount,
+  isType
+};

package/dist/crypto-rn-2BYOHLMG.js

@@ -0,0 +1,72 @@
+import {
+  LightsparkException_default,
+  LightsparkSigningException_default
+} from "./chunk-Q7UUXZNC.js";
+
+// src/crypto/crypto-rn.ts
+import QuickCrypto from "react-native-quick-crypto";
+var qCrypto = QuickCrypto;
+var getRandomValues32 = async (arr) => {
+  return qCrypto.getRandomValues(arr);
+};
+async function decryptSecretWithNodePassword(cipher, encryptedSecret, nodePassword) {
+  throw new LightsparkException_default(
+    "NOT_IMPLEMENTED",
+    "Recovering the signing key is not yet supported in React Native."
+  );
+}
+var generateSigningKeyPair = async () => {
+  return new Promise((resolve, reject) => {
+    console.info("Generating signing key pair");
+    const keypair = qCrypto.generateKeyPairSync("rsa-pss", {
+      modulusLength: 4096,
+      publicKeyEncoding: {
+        type: "spki",
+        format: "pem"
+      },
+      privateKeyEncoding: {
+        type: "pkcs8",
+        format: "pem"
+      }
+    });
+    resolve({
+      publicKey: keypair.publicKey.slice(27, keypair.publicKey.length - 25),
+      privateKey: keypair.privateKey.slice(28, keypair.publicKey.length - 26)
+    });
+  });
+};
+var serializeSigningKey = async (key, format) => {
+  throw new LightsparkException_default(
+    "NOT_IMPLEMENTED",
+    "Cannot serialize a signing key in React Native. The keys you get from generateSigningKeyPair are already serialized buffers."
+  );
+};
+var getNonce = async () => {
+  const nonceSt = await getRandomValues32(new Uint32Array(1));
+  return Number(nonceSt);
+};
+var sign = (key, data) => {
+  return new Promise((resolve, reject) => {
+    console.info("Signing data");
+    const sign2 = qCrypto.createSign("SHA256");
+    sign2.update(data, "utf8");
+    const signature = sign2.sign({
+      key: Buffer.from(key),
+      padding: qCrypto.constants.RSA_PKCS1_PSS_PADDING,
+      saltLength: qCrypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
+    });
+    resolve(signature);
+  });
+};
+var importPrivateSigningKey = async (keyData, format) => {
+  return Promise.resolve(keyData);
+};
+export {
+  LightsparkSigningException_default as LightsparkSigningException,
+  decryptSecretWithNodePassword,
+  generateSigningKeyPair,
+  getNonce,
+  importPrivateSigningKey,
+  serializeSigningKey,
+  sign
+};