@buildonspark/spark-sdk 0.1.46 → 0.2.0

package/dist/chunk-NSJF5F5O.js

@@ -1,325 +0,0 @@
-import {
-  ValidationError
-} from "./chunk-GSI4OLXZ.js";
-
-// src/utils/adaptor-signature.ts
-import { mod } from "@noble/curves/abstract/modular";
-import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/abstract/utils";
-import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
-function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
-  const { r, s } = parseSignature(signature);
-  const sBigInt = bytesToNumberBE(s);
-  const tBigInt = bytesToNumberBE(adaptorPrivateKeyBytes);
-  const newS = mod(sBigInt - tBigInt, secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...numberToBytesBE(newS, 32)]);
-  return newSignature;
-}
-function generateAdaptorFromSignature(signature) {
-  const adaptorPrivateKey = secp256k1.utils.randomPrivateKey();
-  const { r, s } = parseSignature(signature);
-  const sBigInt = bytesToNumberBE(s);
-  const tBigInt = bytesToNumberBE(adaptorPrivateKey);
-  const newS = mod(sBigInt - tBigInt, secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...numberToBytesBE(newS, 32)]);
-  return {
-    adaptorSignature: newSignature,
-    adaptorPrivateKey
-  };
-}
-function validateOutboundAdaptorSignature(pubkey, hash, signature, adaptorPubkey) {
-  return schnorrVerifyWithAdaptor(
-    signature,
-    hash,
-    pubkey,
-    adaptorPubkey,
-    false
-  );
-}
-function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes) {
-  const { r, s } = parseSignature(signature);
-  const sBigInt = bytesToNumberBE(s);
-  const adaptorPrivateKey = bytesToNumberBE(adaptorPrivateKeyBytes);
-  const newS = mod(sBigInt + adaptorPrivateKey, secp256k1.CURVE.n);
-  const newSig = new Uint8Array([...r, ...numberToBytesBE(newS, 32)]);
-  if (schnorr.verify(newSig, hash, pubkey)) {
-    return newSig;
-  }
-  const altS = mod(sBigInt - adaptorPrivateKey, secp256k1.CURVE.n);
-  const altSig = new Uint8Array([...r, ...numberToBytesBE(altS, 32)]);
-  if (schnorr.verify(altSig, hash, pubkey)) {
-    return altSig;
-  }
-  throw new Error("Cannot apply adaptor to signature");
-}
-function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, inbound) {
-  if (hash.length !== 32) {
-    throw new Error(`wrong size for message (got ${hash.length}, want 32)`);
-  }
-  const pubKey = schnorr.utils.lift_x(bytesToNumberBE(pubKeyBytes));
-  pubKey.assertValidity();
-  const { r, s } = parseSignature(signature);
-  const commitmenet = schnorr.utils.taggedHash(
-    "BIP0340/challenge",
-    r,
-    pubKey.toRawBytes().slice(1),
-    hash
-  );
-  if (commitmenet.length > 32) {
-    throw new Error("hash of (r || P || m) too big");
-  }
-  const e = mod(bytesToNumberBE(commitmenet), secp256k1.CURVE.n);
-  const negE = mod(-e, secp256k1.CURVE.n);
-  const R = secp256k1.ProjectivePoint.BASE.multiplyAndAddUnsafe(
-    pubKey,
-    bytesToNumberBE(s),
-    negE
-  );
-  if (!R) {
-    throw new Error("R is undefined");
-  }
-  R.assertValidity();
-  const adaptorPoint = secp256k1.ProjectivePoint.fromHex(adaptorPubkey);
-  const newR = R.add(adaptorPoint);
-  if (!inbound && newR.equals(secp256k1.ProjectivePoint.ZERO)) {
-    throw new Error("calculated R point is the point at infinity");
-  }
-  newR.assertValidity();
-  if (!newR.hasEvenY()) {
-    throw new Error("calculated R y-value is odd");
-  }
-  const rNum = bytesToNumberBE(r);
-  if (newR.toAffine().x !== rNum) {
-    throw new Error("calculated R point was not given R");
-  }
-  return true;
-}
-function parseSignature(signature) {
-  if (signature.length < 64) {
-    throw new ValidationError("Signature too short", {
-      expectedLength: 64,
-      actualLength: signature.length
-    });
-  }
-  if (signature.length > 64) {
-    throw new ValidationError("Signature too long", {
-      expectedLength: 64,
-      actualLength: signature.length
-    });
-  }
-  const r = signature.slice(0, 32);
-  const s = signature.slice(32, 64);
-  if (bytesToNumberBE(r) >= secp256k1.CURVE.Fp.ORDER) {
-    throw new ValidationError("Invalid signature: r >= field prime", {
-      rValue: bytesToNumberBE(r),
-      fieldPrime: secp256k1.CURVE.Fp.ORDER
-    });
-  }
-  if (bytesToNumberBE(s) >= secp256k1.CURVE.n) {
-    throw new ValidationError("Invalid signature: s >= group order", {
-      sValue: bytesToNumberBE(s),
-      groupOrder: secp256k1.CURVE.n
-    });
-  }
-  return { r, s };
-}
-
-// src/utils/keys.ts
-import { numberToBytesBE as numberToBytesBE2 } from "@noble/curves/abstract/utils";
-import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
-function addPublicKeys(a, b) {
-  if (a.length !== 33 || b.length !== 33) {
-    throw new ValidationError("Public keys must be 33 bytes", {
-      field: "publicKeys",
-      value: `a: ${a.length}, b: ${b.length}`,
-      expected: 33
-    });
-  }
-  const pubkeyA = secp256k12.ProjectivePoint.fromHex(a);
-  const pubkeyB = secp256k12.ProjectivePoint.fromHex(b);
-  return pubkeyA.add(pubkeyB).toRawBytes(true);
-}
-function applyAdditiveTweakToPublicKey(pubkey, tweak) {
-  if (pubkey.length !== 33) {
-    throw new ValidationError("Public key must be 33 bytes", {
-      field: "pubkey",
-      value: pubkey.length,
-      expected: 33
-    });
-  }
-  if (tweak.length !== 32) {
-    throw new ValidationError("Tweak must be 32 bytes", {
-      field: "tweak",
-      value: tweak.length,
-      expected: 32
-    });
-  }
-  const pubkeyPoint = secp256k12.ProjectivePoint.fromHex(pubkey);
-  const privTweek = secp256k12.utils.normPrivateKeyToScalar(tweak);
-  const pubTweek = secp256k12.getPublicKey(privTweek, true);
-  const tweekPoint = secp256k12.ProjectivePoint.fromHex(pubTweek);
-  return pubkeyPoint.add(tweekPoint).toRawBytes(true);
-}
-function subtractPublicKeys(a, b) {
-  if (a.length !== 33 || b.length !== 33) {
-    throw new ValidationError("Public keys must be 33 bytes", {
-      field: "publicKeys",
-      value: `a: ${a.length}, b: ${b.length}`,
-      expected: 33
-    });
-  }
-  const pubkeyA = secp256k12.ProjectivePoint.fromHex(a);
-  const pubkeyB = secp256k12.ProjectivePoint.fromHex(b);
-  return pubkeyA.subtract(pubkeyB).toRawBytes(true);
-}
-function addPrivateKeys(a, b) {
-  if (a.length !== 32 || b.length !== 32) {
-    throw new ValidationError("Private keys must be 32 bytes", {
-      field: "privateKeys",
-      value: `a: ${a.length}, b: ${b.length}`,
-      expected: 32
-    });
-  }
-  const privA = secp256k12.utils.normPrivateKeyToScalar(a);
-  const privB = secp256k12.utils.normPrivateKeyToScalar(b);
-  const sum = (privA + privB) % secp256k12.CURVE.n;
-  return numberToBytesBE2(sum, 32);
-}
-function subtractPrivateKeys(a, b) {
-  if (a.length !== 32 || b.length !== 32) {
-    throw new ValidationError("Private keys must be 32 bytes", {
-      field: "privateKeys",
-      value: `a: ${a.length}, b: ${b.length}`,
-      expected: 32
-    });
-  }
-  const privA = secp256k12.utils.normPrivateKeyToScalar(a);
-  const privB = secp256k12.utils.normPrivateKeyToScalar(b);
-  const sum = (secp256k12.CURVE.n - privB + privA) % secp256k12.CURVE.n;
-  return numberToBytesBE2(sum, 32);
-}
-function sumOfPrivateKeys(keys) {
-  return keys.reduce((sum, key) => {
-    if (key.length !== 32) {
-      throw new ValidationError("Private keys must be 32 bytes", {
-        field: "privateKey",
-        value: key.length,
-        expected: 32
-      });
-    }
-    return addPrivateKeys(sum, key);
-  });
-}
-function lastKeyWithTarget(target, keys) {
-  if (target.length !== 32) {
-    throw new ValidationError("Target must be 32 bytes", {
-      field: "target",
-      value: target.length,
-      expected: 32
-    });
-  }
-  const sum = sumOfPrivateKeys(keys);
-  return subtractPrivateKeys(target, sum);
-}
-
-// src/utils/signing.ts
-import { secp256k1 as secp256k13 } from "@noble/curves/secp256k1";
-function getRandomSigningNonce() {
-  const binding = secp256k13.utils.randomPrivateKey();
-  const hiding = secp256k13.utils.randomPrivateKey();
-  return createSigningNonce(binding, hiding);
-}
-function createSigningNonce(binding, hiding) {
-  if (binding.length !== 32 || hiding.length !== 32) {
-    throw new ValidationError("Invalid nonce length", {
-      field: "nonce",
-      value: `binding: ${binding.length}, hiding: ${hiding.length}`,
-      expected: "Both binding and hiding should be 32 bytes"
-    });
-  }
-  return {
-    binding,
-    hiding
-  };
-}
-function getSigningCommitmentFromNonce(nonce) {
-  const bindingPubKey = secp256k13.getPublicKey(nonce.binding, true);
-  const hidingPubKey = secp256k13.getPublicKey(nonce.hiding, true);
-  return {
-    binding: bindingPubKey,
-    hiding: hidingPubKey
-  };
-}
-function encodeSigningNonceToBytes(nonce) {
-  return new Uint8Array([...nonce.binding, ...nonce.hiding]);
-}
-function decodeBytesToSigningNonce(bytes) {
-  if (bytes.length !== 64) {
-    throw new ValidationError("Invalid nonce length", {
-      field: "bytes",
-      value: bytes.length,
-      expected: "64 bytes (32 bytes for binding + 32 bytes for hiding)"
-    });
-  }
-  return {
-    binding: bytes.slice(32, 64),
-    hiding: bytes.slice(0, 32)
-  };
-}
-function createSigningCommitment(binding, hiding) {
-  if (binding.length !== 33 || hiding.length !== 33) {
-    throw new ValidationError("Invalid nonce commitment length", {
-      field: "commitment",
-      value: `binding: ${binding.length}, hiding: ${hiding.length}`,
-      expected: "Both binding and hiding should be 33 bytes (compressed public keys)"
-    });
-  }
-  return {
-    binding,
-    hiding
-  };
-}
-function encodeSigningCommitmentToBytes(commitment) {
-  if (commitment.binding.length !== 33 || commitment.hiding.length !== 33) {
-    throw new ValidationError("Invalid nonce commitment length", {
-      field: "commitment",
-      value: `binding: ${commitment.binding.length}, hiding: ${commitment.hiding.length}`,
-      expected: "Both binding and hiding should be 33 bytes (compressed public keys)"
-    });
-  }
-  return new Uint8Array([...commitment.binding, ...commitment.hiding]);
-}
-function decodeBytesToSigningCommitment(bytes) {
-  if (bytes.length !== 66) {
-    throw new ValidationError("Invalid nonce commitment length", {
-      field: "bytes",
-      value: bytes.length,
-      expected: "66 bytes (33 bytes for binding + 33 bytes for hiding)"
-    });
-  }
-  return {
-    binding: bytes.slice(33, 66),
-    hiding: bytes.slice(0, 33)
-  };
-}
-
-export {
-  generateSignatureFromExistingAdaptor,
-  generateAdaptorFromSignature,
-  validateOutboundAdaptorSignature,
-  applyAdaptorToSignature,
-  addPublicKeys,
-  applyAdditiveTweakToPublicKey,
-  subtractPublicKeys,
-  addPrivateKeys,
-  subtractPrivateKeys,
-  sumOfPrivateKeys,
-  lastKeyWithTarget,
-  getRandomSigningNonce,
-  createSigningNonce,
-  getSigningCommitmentFromNonce,
-  encodeSigningNonceToBytes,
-  decodeBytesToSigningNonce,
-  createSigningCommitment,
-  encodeSigningCommitmentToBytes,
-  decodeBytesToSigningCommitment
-};