@lightsparkdev/core 0.2.1 → 0.2.2

package/dist/crypto-rn-E4RZNGIB.js

@@ -0,0 +1,82 @@
+import {
+  LightsparkException_default,
+  LightsparkSigningException_default,
+  b64encode
+} from "./chunk-KX6HH6CX.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) => {
+    const keypair = qCrypto.generateKeyPairSync("rsa-pss", {
+      modulusLength: 4096,
+      publicExponent: 65537,
+      // We should be passing this line, but there's a bug in the library. Fix is in
+      // https://github.com/margelo/react-native-quick-crypto/pull/175, but waiting for approval.
+      // hashAlgorithm: "sha256",
+      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: addPemTags(key),
+      padding: qCrypto.constants.RSA_PKCS1_PSS_PADDING,
+      saltLength: qCrypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
+    });
+    resolve(signature);
+  });
+};
+var addPemTags = (key) => {
+  const keyString = b64encode(key);
+  return `-----BEGIN PRIVATE KEY-----
+${keyString}
+-----END PRIVATE KEY-----`;
+};
+var importPrivateSigningKey = async (keyData, format) => {
+  return Promise.resolve(keyData);
+};
+export {
+  LightsparkSigningException_default as LightsparkSigningException,
+  decryptSecretWithNodePassword,
+  generateSigningKeyPair,
+  getNonce,
+  importPrivateSigningKey,
+  serializeSigningKey,
+  sign
+};

package/dist/crypto-rn-H4NIT5CT.js

@@ -0,0 +1,70 @@
+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) => {
+    qCrypto.sign("rsa-pss", data, key, (error, data2) => {
+      if (error || !data2) {
+        reject(error);
+      } else {
+        resolve(data2);
+      }
+    });
+  });
+};
+var importPrivateSigningKey = async (keyData, format) => {
+  return Promise.resolve(keyData);
+};
+export {
+  LightsparkSigningException_default as LightsparkSigningException,
+  decryptSecretWithNodePassword,
+  generateSigningKeyPair,
+  getNonce,
+  importPrivateSigningKey,
+  serializeSigningKey,
+  sign
+};

package/dist/crypto-rn-IAC27WLZ.js

@@ -0,0 +1,74 @@
+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.buffer),
+      type: "pkcs8",
+      format: "pem",
+      // 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
+};

package/dist/crypto-rn-LLY6FCWE.js

@@ -0,0 +1,82 @@
+import {
+  LightsparkException_default,
+  LightsparkSigningException_default,
+  b64encode
+} from "./chunk-MZCDWVLH.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) => {
+    const keypair = qCrypto.generateKeyPairSync("rsa-pss", {
+      modulusLength: 4096,
+      publicExponent: 65537,
+      // We should be passing this line, but there's a bug in the library. Fix is in
+      // https://github.com/margelo/react-native-quick-crypto/pull/175, but waiting for approval.
+      // hashAlgorithm: "sha256",
+      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: addPemTags(key),
+      padding: qCrypto.constants.RSA_PKCS1_PSS_PADDING,
+      saltLength: qCrypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
+    });
+    resolve(signature);
+  });
+};
+var addPemTags = (key) => {
+  const keyString = b64encode(key);
+  return `-----BEGIN PRIVATE KEY-----
+${keyString}
+-----END PRIVATE KEY-----`;
+};
+var importPrivateSigningKey = async (keyData, format) => {
+  return Promise.resolve(keyData);
+};
+export {
+  LightsparkSigningException_default as LightsparkSigningException,
+  decryptSecretWithNodePassword,
+  generateSigningKeyPair,
+  getNonce,
+  importPrivateSigningKey,
+  serializeSigningKey,
+  sign
+};

package/dist/crypto-rn-MOWVVG3L.js

@@ -0,0 +1,78 @@
+import {
+  LightsparkException_default,
+  LightsparkSigningException_default,
+  b64encode
+} from "./chunk-J6LSW6XO.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) => {
+    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: addPemTags(key),
+      padding: qCrypto.constants.RSA_PKCS1_PSS_PADDING,
+      saltLength: qCrypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
+    });
+    resolve(signature);
+  });
+};
+var addPemTags = (key) => {
+  const keyString = b64encode(key);
+  return `-----BEGIN PRIVATE KEY-----
+${keyString}
+-----END PRIVATE KEY-----`;
+};
+var importPrivateSigningKey = async (keyData, format) => {
+  return Promise.resolve(keyData);
+};
+export {
+  LightsparkSigningException_default as LightsparkSigningException,
+  decryptSecretWithNodePassword,
+  generateSigningKeyPair,
+  getNonce,
+  importPrivateSigningKey,
+  serializeSigningKey,
+  sign
+};

package/dist/crypto-rn-OAPLHNM5.js

@@ -0,0 +1,73 @@
+import {
+  LightsparkException_default,
+  LightsparkSigningException_default,
+  b64encode
+} from "./chunk-YYVOX4YM.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: b64encode(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
+};

package/dist/crypto-rn-PVAG5TVH.js

@@ -0,0 +1,80 @@
+import {
+  LightsparkException_default,
+  LightsparkSigningException_default,
+  b64encode
+} from "./chunk-JUD4MOOQ.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) => {
+    const keypair = qCrypto.generateKeyPairSync("rsa-pss", {
+      modulusLength: 4096,
+      publicExponent: 65537,
+      hashAlgorithm: "sha256",
+      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: addPemTags(key),
+      padding: qCrypto.constants.RSA_PKCS1_PSS_PADDING,
+      saltLength: qCrypto.constants.RSA_PSS_SALTLEN_MAX_SIGN
+    });
+    resolve(signature);
+  });
+};
+var addPemTags = (key) => {
+  const keyString = b64encode(key);
+  return `-----BEGIN PRIVATE KEY-----
+${keyString}
+-----END PRIVATE KEY-----`;
+};
+var importPrivateSigningKey = async (keyData, format) => {
+  return Promise.resolve(keyData);
+};
+export {
+  LightsparkSigningException_default as LightsparkSigningException,
+  decryptSecretWithNodePassword,
+  generateSigningKeyPair,
+  getNonce,
+  importPrivateSigningKey,
+  serializeSigningKey,
+  sign
+};

package/dist/crypto-rn-QLVBL5DI.js

@@ -0,0 +1,75 @@
+import {
+  LightsparkException_default,
+  LightsparkSigningException_default,
+  b64encode
+} from "./chunk-5FD46UVI.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: b64encode(key),
+      format: "pkcs8",
+      type: "rsa-pss",
+      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
+};

package/dist/crypto-rn-TBKXR3SR.js

@@ -0,0 +1,68 @@
+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) => {
+    qCrypto.generateKeyPair(
+      "rsa-pss",
+      {
+        modulusLength: 4096,
+        hash: "SHA-256"
+      },
+      (error, pubKey, privKey) => {
+        if (error || !pubKey || !privKey) {
+          reject(error);
+        } else {
+          resolve({ publicKey: pubKey, privateKey: privKey });
+        }
+      }
+    );
+  });
+};
+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) => {
+    qCrypto.sign("rsa-pss", data, key, (error, data2) => {
+      if (error || !data2) {
+        reject(error);
+      } else {
+        resolve(data2);
+      }
+    });
+  });
+};
+var importPrivateSigningKey = async (keyData, format) => {
+  return Promise.resolve(keyData);
+};
+export {
+  LightsparkSigningException_default as LightsparkSigningException,
+  decryptSecretWithNodePassword,
+  generateSigningKeyPair,
+  getNonce,
+  importPrivateSigningKey,
+  serializeSigningKey,
+  sign
+};