@buildonspark/spark-sdk 0.1.46 → 0.1.47

package/dist/chunk-OFCJFZ4I.js

@@ -1,24 +0,0 @@
-// src/constants.ts
-import { isNode } from "@lightsparkdev/core";
-var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
-var isBun = globalThis.Bun !== void 0;
-var packageVersion = true ? "0.1.46" : "unknown";
-var baseEnvStr = "unknown";
-if (isBun) {
-  const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
-  baseEnvStr = `bun/${bunVersion}`;
-} else if (isNode) {
-  baseEnvStr = `node/${process.version}`;
-} else if (isReactNative) {
-  baseEnvStr = "react-native";
-} else {
-  const userAgent = typeof navigator !== "undefined" && navigator.userAgent || "unknown-user-agent";
-  baseEnvStr = `browser/${userAgent}`;
-}
-var clientEnv = `js-spark-sdk/${packageVersion} ${baseEnvStr}`;
-
-export {
-  isReactNative,
-  isBun,
-  clientEnv
-};

package/dist/chunk-QNNSEJ4P.js

@@ -1,232 +0,0 @@
-import {
-  ValidationError
-} from "./chunk-GSI4OLXZ.js";
-
-// src/utils/secret-sharing.ts
-import { bytesToHex, equalBytes } from "@noble/curves/abstract/utils";
-import { secp256k1 } from "@noble/curves/secp256k1";
-
-// src/utils/crypto.ts
-import nodeCrypto from "crypto";
-var getCrypto = () => {
-  let cryptoImpl = typeof window !== "undefined" ? window.crypto : typeof global !== "undefined" && global.crypto ? global.crypto : nodeCrypto;
-  return cryptoImpl;
-};
-
-// src/utils/secret-sharing.ts
-var crypto = getCrypto();
-function getRandomBigInt(max) {
-  const byteLength = max.toString(2).length + 7 >> 3;
-  const maxBigInt = max;
-  const mask = (1n << BigInt(max.toString(2).length)) - 1n;
-  while (true) {
-    const randBytes = crypto.getRandomValues(new Uint8Array(byteLength + 1));
-    const randValue = BigInt("0x" + bytesToHex(randBytes)) & mask;
-    if (randValue < maxBigInt) {
-      return randValue;
-    }
-  }
-}
-function modInverse(a, m) {
-  a = (a % m + m) % m;
-  let [old_r, r] = [a, m];
-  let [old_s, s] = [1n, 0n];
-  let [old_t, t] = [0n, 1n];
-  while (r !== 0n) {
-    const quotient = old_r / r;
-    [old_r, r] = [r, old_r - quotient * r];
-    [old_s, s] = [s, old_s - quotient * s];
-    [old_t, t] = [t, old_t - quotient * t];
-  }
-  if (old_r !== 1n) {
-    throw new ValidationError("Modular inverse does not exist", {
-      field: "modInverse",
-      value: `a: ${a}, m: ${m}`,
-      expected: "a and m must be coprime"
-    });
-  }
-  return (old_s % m + m) % m;
-}
-function evaluatePolynomial(polynomial, x) {
-  let result = 0n;
-  for (let i = 0; i < polynomial.coefficients.length; i++) {
-    const coeff = polynomial.coefficients[i];
-    if (!coeff) {
-      throw new ValidationError("Coefficient is undefined", {
-        field: "coefficient",
-        value: "undefined",
-        expected: "A valid bigint coefficient"
-      });
-    }
-    const xPow = x ** BigInt(i) % polynomial.fieldModulus;
-    result = (result + xPow * coeff) % polynomial.fieldModulus;
-  }
-  return result;
-}
-function fieldDiv(numerator, denominator, fieldModulus) {
-  if (denominator === 0n) {
-    throw new ValidationError("Division by zero", {
-      field: "denominator",
-      value: "0",
-      expected: "Non-zero value"
-    });
-  }
-  const inverse = modInverse(denominator, fieldModulus);
-  return numerator * inverse % fieldModulus;
-}
-function computerLagrangeCoefficients(index, points) {
-  let numerator = 1n;
-  let denominator = 1n;
-  let fieldModulus = points[0]?.fieldModulus;
-  if (!fieldModulus) {
-    throw new ValidationError("Field modulus is undefined", {
-      field: "fieldModulus",
-      value: "undefined",
-      expected: "A valid field modulus"
-    });
-  }
-  for (const point of points) {
-    if (point.index === index) {
-      continue;
-    }
-    numerator = numerator * point.index;
-    const value = point.index - index;
-    denominator = denominator * value;
-  }
-  return fieldDiv(numerator, denominator, fieldModulus);
-}
-function generatePolynomialForSecretSharing(fieldModulus, secret, degree) {
-  const coefficients = new Array(degree);
-  const proofs = new Array(degree);
-  coefficients[0] = secret;
-  proofs[0] = secp256k1.ProjectivePoint.fromPrivateKey(secret).toRawBytes(true);
-  for (let i = 1; i < degree; i++) {
-    const coefficient = getRandomBigInt(fieldModulus);
-    coefficients[i] = coefficient;
-    proofs[i] = secp256k1.ProjectivePoint.fromPrivateKey(coefficient).toRawBytes(true);
-  }
-  return {
-    fieldModulus,
-    coefficients,
-    proofs
-  };
-}
-function splitSecret(fieldModulus, secret, threshold, numberOfShares) {
-  const polynomial = generatePolynomialForSecretSharing(
-    fieldModulus,
-    secret,
-    threshold
-  );
-  const shares = [];
-  for (let i = 1; i <= numberOfShares; i++) {
-    const share = evaluatePolynomial(polynomial, BigInt(i));
-    shares.push({
-      fieldModulus,
-      threshold,
-      index: BigInt(i),
-      share
-    });
-  }
-  return shares;
-}
-function splitSecretWithProofs(secret, fieldModulus, threshold, numberOfShares) {
-  const polynomial = generatePolynomialForSecretSharing(
-    fieldModulus,
-    secret,
-    threshold
-  );
-  const shares = [];
-  for (let i = 1; i <= numberOfShares; i++) {
-    const share = evaluatePolynomial(polynomial, BigInt(i));
-    shares.push({
-      fieldModulus,
-      threshold,
-      index: BigInt(i),
-      share,
-      proofs: polynomial.proofs
-    });
-  }
-  return shares;
-}
-function recoverSecret(shares) {
-  if (shares.length === 0) return 0n;
-  const threshold = shares[0]?.threshold;
-  const fieldModulus = shares[0]?.fieldModulus;
-  if (!threshold || !fieldModulus) {
-    throw new ValidationError("Shares are not valid", {
-      field: "shares",
-      value: "Missing threshold or fieldModulus",
-      expected: "Valid shares with threshold and fieldModulus"
-    });
-  }
-  if (shares.length < threshold) {
-    throw new ValidationError("Not enough shares to recover secret", {
-      field: "shares",
-      value: shares.length,
-      expected: `At least ${threshold} shares`
-    });
-  }
-  let result = 0n;
-  for (const share of shares) {
-    const coeff = computerLagrangeCoefficients(share.index, shares);
-    const item = share.share * coeff % fieldModulus;
-    result = (result + item) % fieldModulus;
-  }
-  return result;
-}
-function validateShare(share) {
-  const targetPubkey = secp256k1.ProjectivePoint.fromPrivateKey(
-    share.share
-  ).toRawBytes(true);
-  let resultPubkey = share.proofs[0];
-  if (!resultPubkey) {
-    throw new ValidationError("Result pubkey is not valid", {
-      field: "resultPubkey",
-      value: "null",
-      expected: "Valid public key bytes"
-    });
-  }
-  for (let i = 1; i < share.proofs.length; i++) {
-    const pubkey = share.proofs[i];
-    if (!pubkey) {
-      throw new ValidationError("Pubkey is not valid", {
-        field: "pubkey",
-        value: "null",
-        expected: "Valid public key bytes"
-      });
-    }
-    const value = share.index ** BigInt(i) % share.fieldModulus;
-    const scaledPoint = secp256k1.ProjectivePoint.fromHex(pubkey).multiply(value);
-    resultPubkey = secp256k1.ProjectivePoint.fromHex(resultPubkey).add(scaledPoint).toRawBytes(true);
-  }
-  if (!equalBytes(resultPubkey, targetPubkey)) {
-    throw new ValidationError("Share is not valid", {
-      field: "share",
-      value: "Invalid proof",
-      expected: "Valid share with matching proofs"
-    });
-  }
-}
-function bigIntToPrivateKey(value) {
-  const hex = value.toString(16).padStart(64, "0");
-  const bytes = new Uint8Array(32);
-  for (let i = 0; i < 32; i++) {
-    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-
-export {
-  getCrypto,
-  getRandomBigInt,
-  modInverse,
-  evaluatePolynomial,
-  fieldDiv,
-  computerLagrangeCoefficients,
-  generatePolynomialForSecretSharing,
-  splitSecret,
-  splitSecretWithProofs,
-  recoverSecret,
-  validateShare,
-  bigIntToPrivateKey
-};