@buildonspark/spark-sdk 0.1.45 → 0.1.47

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
-};

package/dist/chunk-R5PXJZQS.js

@@ -1,277 +0,0 @@
-// src/tests/isHermeticTest.ts
-import { isNode } from "@lightsparkdev/core";
-import fs from "fs";
-function isHermeticTest() {
-  if (isNode) {
-    return (fs?.existsSync?.("/tmp/spark_hermetic") ?? false) || process.env.HERMETIC_TEST === "true";
-  }
-  return typeof process !== "undefined" && process.env?.HERMETIC_TEST === "true" || false;
-}
-
-// src/services/wallet-config.ts
-var SSP_IDENTITY_PUBLIC_KEYS = {
-  LOCAL: "028c094a432d46a0ac95349d792c2e3730bd60c29188db716f56a99e39b95338b4",
-  REGTEST: {
-    PROD: "022bf283544b16c0622daecb79422007d167eca6ce9f0c98c0c49833b1f7170bfe"
-  },
-  MAINNET: {
-    PROD: "023e33e2920326f64ea31058d44777442d97d7d5cbfcf54e3060bc1695e5261c93"
-  }
-};
-var URL_CONFIG = {
-  LOCAL: {
-    SSP: "http://127.0.0.1:5000",
-    ELECTRS: "http://127.0.0.1:30000",
-    LRC20: "http://127.0.0.1:18530",
-    LRC20_NODE: "http://127.0.0.1:18332"
-  },
-  REGTEST: {
-    PROD: {
-      SSP: "https://api.lightspark.com",
-      ELECTRS: "https://regtest-mempool.us-west-2.sparkinfra.net/api",
-      LRC20: "https://regtest.lrc20.lightspark.com:443",
-      LRC20_NODE: "https://regtest.lrc20.lightspark.com"
-    }
-  },
-  MAINNET: {
-    PROD: {
-      SSP: "https://api.lightspark.com",
-      ELECTRS: "https://mempool.space/api",
-      LRC20: "https://mainnet.lrc20.lightspark.com:443",
-      LRC20_NODE: "https://mainnet.lrc20.lightspark.com"
-    }
-  }
-};
-var ELECTRS_CREDENTIALS = {
-  username: "spark-sdk",
-  password: "mCMk1JqlBNtetUNy"
-};
-function getElectrsUrl(network) {
-  switch (network) {
-    case "LOCAL":
-      return isHermeticTest() ? "http://mempool.minikube.local/api" : URL_CONFIG.LOCAL.ELECTRS;
-    case "REGTEST":
-      return URL_CONFIG.REGTEST.PROD.ELECTRS;
-    case "MAINNET":
-      return URL_CONFIG.MAINNET.PROD.ELECTRS;
-    default:
-      return URL_CONFIG.LOCAL.ELECTRS;
-  }
-}
-function getLrc20Url(network) {
-  switch (network) {
-    case "LOCAL":
-      return URL_CONFIG.LOCAL.LRC20;
-    case "REGTEST":
-      return URL_CONFIG.REGTEST.PROD.LRC20;
-    case "MAINNET":
-      return URL_CONFIG.MAINNET.PROD.LRC20;
-    default:
-      return URL_CONFIG.LOCAL.LRC20;
-  }
-}
-function getLrc20NodeUrl(network) {
-  switch (network) {
-    case "LOCAL":
-      return URL_CONFIG.LOCAL.LRC20_NODE;
-    case "REGTEST":
-      return URL_CONFIG.REGTEST.PROD.LRC20_NODE;
-    case "MAINNET":
-      return URL_CONFIG.MAINNET.PROD.LRC20_NODE;
-    default:
-      return URL_CONFIG.LOCAL.LRC20_NODE;
-  }
-}
-function getSspIdentityPublicKey(network) {
-  switch (network) {
-    case "LOCAL":
-      return SSP_IDENTITY_PUBLIC_KEYS.LOCAL;
-    case "REGTEST":
-      return SSP_IDENTITY_PUBLIC_KEYS.REGTEST.PROD;
-    case "MAINNET":
-      return SSP_IDENTITY_PUBLIC_KEYS.MAINNET.PROD;
-    default:
-      return SSP_IDENTITY_PUBLIC_KEYS.LOCAL;
-  }
-}
-function getSspUrl(network) {
-  switch (network) {
-    case "LOCAL":
-      return isHermeticTest() ? "http://app.minikube.local" : URL_CONFIG.LOCAL.SSP;
-    case "REGTEST":
-      return URL_CONFIG.REGTEST.PROD.SSP;
-    case "MAINNET":
-      return URL_CONFIG.MAINNET.PROD.SSP;
-    default:
-      return URL_CONFIG.LOCAL.SSP;
-  }
-}
-function getSspSchemaEndpoint(network) {
-  switch (network) {
-    case "LOCAL":
-      return "graphql/spark/rc";
-  }
-  return;
-}
-var PROD_PUBKEYS = [
-  "03dfbdff4b6332c220f8fa2ba8ed496c698ceada563fa01b67d9983bfc5c95e763",
-  "03e625e9768651c9be268e287245cc33f96a68ce9141b0b4769205db027ee8ed77",
-  "022eda13465a59205413086130a65dc0ed1b8f8e51937043161f8be0c369b1a410"
-];
-function getLocalFrostSignerAddress() {
-  return isHermeticTest() ? "localhost:9999" : "unix:///tmp/frost_0.sock";
-}
-var BASE_CONFIG = {
-  network: "LOCAL",
-  lrc20Address: getLrc20Url("LOCAL"),
-  coodinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
-  frostSignerAddress: getLocalFrostSignerAddress(),
-  threshold: 2,
-  signingOperators: getLocalSigningOperators(),
-  tokenSignatures: "SCHNORR",
-  tokenTransactionVersion: "V0",
-  tokenValidityDurationSeconds: 180,
-  electrsUrl: getElectrsUrl("LOCAL"),
-  expectedWithdrawBondSats: 1e4,
-  expectedWithdrawRelativeBlockLocktime: 1e3,
-  lrc20ApiConfig: {
-    electrsUrl: getElectrsUrl("LOCAL"),
-    lrc20NodeUrl: getLrc20NodeUrl("LOCAL"),
-    electrsCredentials: ELECTRS_CREDENTIALS
-  },
-  sspClientOptions: {
-    baseUrl: getSspUrl("LOCAL"),
-    identityPublicKey: getSspIdentityPublicKey("LOCAL"),
-    schemaEndpoint: getSspSchemaEndpoint("LOCAL")
-  }
-};
-var LOCAL_WALLET_CONFIG = {
-  ...BASE_CONFIG,
-  threshold: 3
-};
-var LOCAL_WALLET_CONFIG_SCHNORR = {
-  ...LOCAL_WALLET_CONFIG,
-  threshold: 3
-  // 3 for issuance tests.
-};
-var LOCAL_WALLET_CONFIG_ECDSA = {
-  ...LOCAL_WALLET_CONFIG,
-  tokenSignatures: "ECDSA",
-  threshold: 3
-  // 3 for issuance tests.
-};
-var REGTEST_WALLET_CONFIG = {
-  ...BASE_CONFIG,
-  network: "REGTEST",
-  lrc20Address: getLrc20Url("REGTEST"),
-  signingOperators: getSigningOperators(),
-  electrsUrl: getElectrsUrl("REGTEST"),
-  lrc20ApiConfig: {
-    electrsUrl: getElectrsUrl("REGTEST"),
-    lrc20NodeUrl: getLrc20NodeUrl("REGTEST"),
-    electrsCredentials: ELECTRS_CREDENTIALS
-  },
-  expectedWithdrawBondSats: 1e4,
-  expectedWithdrawRelativeBlockLocktime: 1e3,
-  sspClientOptions: {
-    baseUrl: getSspUrl("REGTEST"),
-    identityPublicKey: getSspIdentityPublicKey("REGTEST")
-  }
-};
-var MAINNET_WALLET_CONFIG = {
-  ...BASE_CONFIG,
-  network: "MAINNET",
-  lrc20Address: getLrc20Url("MAINNET"),
-  signingOperators: getSigningOperators(),
-  electrsUrl: getElectrsUrl("MAINNET"),
-  lrc20ApiConfig: {
-    electrsUrl: getElectrsUrl("MAINNET"),
-    lrc20NodeUrl: getLrc20NodeUrl("MAINNET")
-  },
-  expectedWithdrawBondSats: 1e4,
-  expectedWithdrawRelativeBlockLocktime: 1e3,
-  sspClientOptions: {
-    baseUrl: getSspUrl("MAINNET"),
-    identityPublicKey: getSspIdentityPublicKey("MAINNET")
-  }
-};
-function getSigningOperators() {
-  return {
-    "0000000000000000000000000000000000000000000000000000000000000001": {
-      id: 0,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000001",
-      address: "https://0.spark.lightspark.com",
-      identityPublicKey: PROD_PUBKEYS[0]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000002": {
-      id: 1,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000002",
-      address: "https://1.spark.lightspark.com",
-      identityPublicKey: PROD_PUBKEYS[1]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000003": {
-      id: 2,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000003",
-      address: "https://2.spark.flashnet.xyz",
-      identityPublicKey: PROD_PUBKEYS[2]
-    }
-  };
-}
-function getLocalSigningOperators() {
-  const pubkeys = [
-    "0322ca18fc489ae25418a0e768273c2c61cabb823edfb14feb891e9bec62016510",
-    "0341727a6c41b168f07eb50865ab8c397a53c7eef628ac1020956b705e43b6cb27",
-    "0305ab8d485cc752394de4981f8a5ae004f2becfea6f432c9a59d5022d8764f0a6",
-    "0352aef4d49439dedd798ac4aef1e7ebef95f569545b647a25338398c1247ffdea",
-    "02c05c88cc8fc181b1ba30006df6a4b0597de6490e24514fbdd0266d2b9cd3d0ba"
-  ];
-  return {
-    "0000000000000000000000000000000000000000000000000000000000000001": {
-      id: 0,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000001",
-      address: "https://localhost:8535",
-      identityPublicKey: pubkeys[0]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000002": {
-      id: 1,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000002",
-      address: "https://localhost:8536",
-      identityPublicKey: pubkeys[1]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000003": {
-      id: 2,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000003",
-      address: "https://localhost:8537",
-      identityPublicKey: pubkeys[2]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000004": {
-      id: 3,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000004",
-      address: "https://localhost:8538",
-      identityPublicKey: pubkeys[3]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000005": {
-      id: 4,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000005",
-      address: "https://localhost:8539",
-      identityPublicKey: pubkeys[4]
-    }
-  };
-}
-
-export {
-  ELECTRS_CREDENTIALS,
-  getElectrsUrl,
-  getLrc20Url,
-  getLrc20NodeUrl,
-  getSspIdentityPublicKey,
-  getSspUrl,
-  getSspSchemaEndpoint,
-  BASE_CONFIG,
-  LOCAL_WALLET_CONFIG,
-  LOCAL_WALLET_CONFIG_SCHNORR,
-  LOCAL_WALLET_CONFIG_ECDSA,
-  REGTEST_WALLET_CONFIG,
-  MAINNET_WALLET_CONFIG,
-  getLocalSigningOperators
-};