@buildonspark/spark-sdk 0.0.9 → 0.0.11

package/dist/signer/signer.cjs

@@ -1,894 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
-  mod2
-));
-var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
-
-// src/signer/signer.ts
-var signer_exports = {};
-__export(signer_exports, {
-  DefaultSparkSigner: () => DefaultSparkSigner
-});
-module.exports = __toCommonJS(signer_exports);
-var import_utils4 = require("@noble/curves/abstract/utils");
-var import_secp256k15 = require("@noble/curves/secp256k1");
-var import_bip32 = require("@scure/bip32");
-var bip39 = __toESM(require("@scure/bip39"), 1);
-var import_bip39 = require("@scure/bip39");
-var import_english = require("@scure/bip39/wordlists/english");
-var import_utils5 = require("@scure/btc-signer/utils");
-var import_buffer = require("buffer");
-var ecies = __toESM(require("eciesjs"), 1);
-
-// src/utils/adaptor-signature.ts
-var import_modular = require("@noble/curves/abstract/modular");
-var import_utils = require("@noble/curves/abstract/utils");
-var import_secp256k1 = require("@noble/curves/secp256k1");
-function generateAdaptorFromSignature(signature) {
-  const adaptorPrivateKey = import_secp256k1.secp256k1.utils.randomPrivateKey();
-  const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils.bytesToNumberBE)(s);
-  const tBigInt = (0, import_utils.bytesToNumberBE)(adaptorPrivateKey);
-  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k1.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils.numberToBytesBE)(newS, 32)]);
-  return {
-    adaptorSignature: newSignature,
-    adaptorPrivateKey
-  };
-}
-function parseSignature(signature) {
-  if (signature.length < 64) {
-    throw new Error(`malformed signature: too short: ${signature.length} < 64`);
-  }
-  if (signature.length > 64) {
-    throw new Error(`malformed signature: too long: ${signature.length} > 64`);
-  }
-  const r = signature.slice(0, 32);
-  const s = signature.slice(32, 64);
-  if ((0, import_utils.bytesToNumberBE)(r) >= import_secp256k1.secp256k1.CURVE.Fp.ORDER) {
-    throw new Error(`invalid signature: r >= field prime`);
-  }
-  if ((0, import_utils.bytesToNumberBE)(s) >= import_secp256k1.secp256k1.CURVE.n) {
-    throw new Error(`invalid signature: s >= group order`);
-  }
-  return { r, s };
-}
-
-// src/utils/keys.ts
-var import_secp256k12 = require("@noble/curves/secp256k1");
-var import_utils2 = require("@noble/curves/abstract/utils");
-function subtractPrivateKeys(a, b) {
-  if (a.length !== 32 || b.length !== 32) {
-    throw new Error("Private keys must be 32 bytes");
-  }
-  const privA = import_secp256k12.secp256k1.utils.normPrivateKeyToScalar(a);
-  const privB = import_secp256k12.secp256k1.utils.normPrivateKeyToScalar(b);
-  const sum = (import_secp256k12.secp256k1.CURVE.n - privB + privA) % import_secp256k12.secp256k1.CURVE.n;
-  return (0, import_utils2.numberToBytesBE)(sum, 32);
-}
-
-// src/utils/network.ts
-var btc = __toESM(require("@scure/btc-signer"), 1);
-var NetworkToProto = {
-  [0 /* MAINNET */]: 0 /* MAINNET */,
-  [1 /* TESTNET */]: 2 /* TESTNET */,
-  [2 /* SIGNET */]: 3 /* SIGNET */,
-  [3 /* REGTEST */]: 1 /* REGTEST */,
-  [4 /* LOCAL */]: 1 /* REGTEST */
-};
-var NetworkConfig = {
-  [0 /* MAINNET */]: btc.NETWORK,
-  [1 /* TESTNET */]: btc.TEST_NETWORK,
-  [2 /* SIGNET */]: btc.TEST_NETWORK,
-  [3 /* REGTEST */]: { ...btc.TEST_NETWORK, bech32: "bcrt" },
-  [4 /* LOCAL */]: { ...btc.TEST_NETWORK, bech32: "bcrt" }
-};
-
-// src/utils/secret-sharing.ts
-var import_utils3 = require("@noble/curves/abstract/utils");
-var import_secp256k13 = require("@noble/curves/secp256k1");
-
-// src/utils/crypto.ts
-var import_crypto = __toESM(require("crypto"), 1);
-var getCrypto = () => {
-  if (typeof window !== "undefined" && window.crypto) {
-    return window.crypto;
-  }
-  if (typeof global !== "undefined" && global.crypto) {
-    return global.crypto;
-  }
-  return import_crypto.default;
-};
-
-// src/utils/secret-sharing.ts
-var crypto2 = 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 = crypto2.getRandomValues(new Uint8Array(byteLength + 1));
-    const randValue = BigInt("0x" + (0, import_utils3.bytesToHex)(randBytes)) & mask;
-    if (randValue < maxBigInt) {
-      return randValue;
-    }
-  }
-}
-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 Error("Coefficient is undefined");
-    }
-    const xPow = x ** BigInt(i) % polynomial.fieldModulus;
-    result = (result + xPow * coeff) % polynomial.fieldModulus;
-  }
-  return result;
-}
-function generatePolynomialForSecretSharing(fieldModulus, secret, degree) {
-  const coefficients = new Array(degree);
-  const proofs = new Array(degree);
-  coefficients[0] = secret;
-  proofs[0] = import_secp256k13.secp256k1.ProjectivePoint.fromPrivateKey(secret).toRawBytes(true);
-  for (let i = 1; i < degree; i++) {
-    const coefficient = getRandomBigInt(fieldModulus);
-    coefficients[i] = coefficient;
-    proofs[i] = import_secp256k13.secp256k1.ProjectivePoint.fromPrivateKey(coefficient).toRawBytes(true);
-  }
-  return {
-    fieldModulus,
-    coefficients,
-    proofs
-  };
-}
-function splitSecretWithProofs(secret, fieldModulus, threshold, numberOfShares) {
-  const polynomial = generatePolynomialForSecretSharing(
-    fieldModulus,
-    secret,
-    threshold - 1
-  );
-  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;
-}
-
-// src/utils/signing.ts
-var import_secp256k14 = require("@noble/curves/secp256k1");
-
-// src/wasm/spark_bindings.js
-var wasm;
-var WASM_VECTOR_LEN = 0;
-var cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-  }
-  return cachedUint8ArrayMemory0;
-}
-var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
-  throw Error("TextEncoder not available");
-} };
-var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
-  return cachedTextEncoder.encodeInto(arg, view);
-} : function(arg, view) {
-  const buf = cachedTextEncoder.encode(arg);
-  view.set(buf);
-  return {
-    read: arg.length,
-    written: buf.length
-  };
-};
-var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
-  throw Error("TextDecoder not available");
-} };
-if (typeof TextDecoder !== "undefined") {
-  cachedTextDecoder.decode();
-}
-function isLikeNone(x) {
-  return x === void 0 || x === null;
-}
-function getArrayU8FromWasm0(ptr, len) {
-  ptr = ptr >>> 0;
-  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-function passArray8ToWasm0(arg, malloc) {
-  const ptr = malloc(arg.length * 1, 1) >>> 0;
-  getUint8ArrayMemory0().set(arg, ptr / 1);
-  WASM_VECTOR_LEN = arg.length;
-  return ptr;
-}
-function _assertClass(instance, klass) {
-  if (!(instance instanceof klass)) {
-    throw new Error(`expected instance of ${klass.name}`);
-  }
-}
-function takeFromExternrefTable0(idx) {
-  const value = wasm.__wbindgen_export_4.get(idx);
-  wasm.__externref_table_dealloc(idx);
-  return value;
-}
-function wasm_sign_frost(msg, key_package, nonce, self_commitment, statechain_commitments, adaptor_public_key) {
-  const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
-  const len0 = WASM_VECTOR_LEN;
-  _assertClass(key_package, KeyPackage);
-  var ptr1 = key_package.__destroy_into_raw();
-  _assertClass(nonce, SigningNonce);
-  var ptr2 = nonce.__destroy_into_raw();
-  _assertClass(self_commitment, SigningCommitment2);
-  var ptr3 = self_commitment.__destroy_into_raw();
-  var ptr4 = isLikeNone(adaptor_public_key) ? 0 : passArray8ToWasm0(adaptor_public_key, wasm.__wbindgen_malloc);
-  var len4 = WASM_VECTOR_LEN;
-  const ret = wasm.wasm_sign_frost(ptr0, len0, ptr1, ptr2, ptr3, statechain_commitments, ptr4, len4);
-  if (ret[3]) {
-    throw takeFromExternrefTable0(ret[2]);
-  }
-  var v6 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-  return v6;
-}
-function wasm_aggregate_frost(msg, statechain_commitments, self_commitment, statechain_signatures, self_signature, statechain_public_keys, self_public_key, verifying_key, adaptor_public_key) {
-  const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
-  const len0 = WASM_VECTOR_LEN;
-  _assertClass(self_commitment, SigningCommitment2);
-  var ptr1 = self_commitment.__destroy_into_raw();
-  const ptr2 = passArray8ToWasm0(self_signature, wasm.__wbindgen_malloc);
-  const len2 = WASM_VECTOR_LEN;
-  const ptr3 = passArray8ToWasm0(self_public_key, wasm.__wbindgen_malloc);
-  const len3 = WASM_VECTOR_LEN;
-  const ptr4 = passArray8ToWasm0(verifying_key, wasm.__wbindgen_malloc);
-  const len4 = WASM_VECTOR_LEN;
-  var ptr5 = isLikeNone(adaptor_public_key) ? 0 : passArray8ToWasm0(adaptor_public_key, wasm.__wbindgen_malloc);
-  var len5 = WASM_VECTOR_LEN;
-  const ret = wasm.wasm_aggregate_frost(ptr0, len0, statechain_commitments, ptr1, statechain_signatures, ptr2, len2, statechain_public_keys, ptr3, len3, ptr4, len4, ptr5, len5);
-  if (ret[3]) {
-    throw takeFromExternrefTable0(ret[2]);
-  }
-  var v7 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-  return v7;
-}
-var DummyTxFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-}, unregister: () => {
-} } : new FinalizationRegistry((ptr) => wasm.__wbg_dummytx_free(ptr >>> 0, 1));
-var KeyPackageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-}, unregister: () => {
-} } : new FinalizationRegistry((ptr) => wasm.__wbg_keypackage_free(ptr >>> 0, 1));
-var KeyPackage = class {
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    KeyPackageFinalization.unregister(this);
-    return ptr;
-  }
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_keypackage_free(ptr, 0);
-  }
-  /**
-   * @returns {Uint8Array}
-   */
-  get secret_key() {
-    const ret = wasm.__wbg_get_keypackage_secret_key(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
-  /**
-   * @param {Uint8Array} arg0
-   */
-  set secret_key(arg0) {
-    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_dummytx_tx(this.__wbg_ptr, ptr0, len0);
-  }
-  /**
-   * @returns {Uint8Array}
-   */
-  get public_key() {
-    const ret = wasm.__wbg_get_keypackage_public_key(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
-  /**
-   * @param {Uint8Array} arg0
-   */
-  set public_key(arg0) {
-    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_dummytx_txid(this.__wbg_ptr, ptr0, len0);
-  }
-  /**
-   * @returns {Uint8Array}
-   */
-  get verifying_key() {
-    const ret = wasm.__wbg_get_keypackage_verifying_key(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
-  /**
-   * @param {Uint8Array} arg0
-   */
-  set verifying_key(arg0) {
-    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_keypackage_verifying_key(this.__wbg_ptr, ptr0, len0);
-  }
-  /**
-   * @param {Uint8Array} secret_key
-   * @param {Uint8Array} public_key
-   * @param {Uint8Array} verifying_key
-   */
-  constructor(secret_key, public_key, verifying_key) {
-    const ptr0 = passArray8ToWasm0(secret_key, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(public_key, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passArray8ToWasm0(verifying_key, wasm.__wbindgen_malloc);
-    const len2 = WASM_VECTOR_LEN;
-    const ret = wasm.keypackage_new(ptr0, len0, ptr1, len1, ptr2, len2);
-    this.__wbg_ptr = ret >>> 0;
-    KeyPackageFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
-};
-var NonceResultFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-}, unregister: () => {
-} } : new FinalizationRegistry((ptr) => wasm.__wbg_nonceresult_free(ptr >>> 0, 1));
-var SigningCommitmentFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-}, unregister: () => {
-} } : new FinalizationRegistry((ptr) => wasm.__wbg_signingcommitment_free(ptr >>> 0, 1));
-var SigningCommitment2 = class _SigningCommitment {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(_SigningCommitment.prototype);
-    obj.__wbg_ptr = ptr;
-    SigningCommitmentFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    SigningCommitmentFinalization.unregister(this);
-    return ptr;
-  }
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_signingcommitment_free(ptr, 0);
-  }
-  /**
-   * @returns {Uint8Array}
-   */
-  get hiding() {
-    const ret = wasm.__wbg_get_signingcommitment_hiding(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
-  /**
-   * @param {Uint8Array} arg0
-   */
-  set hiding(arg0) {
-    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_dummytx_tx(this.__wbg_ptr, ptr0, len0);
-  }
-  /**
-   * @returns {Uint8Array}
-   */
-  get binding() {
-    const ret = wasm.__wbg_get_signingcommitment_binding(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
-  /**
-   * @param {Uint8Array} arg0
-   */
-  set binding(arg0) {
-    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_dummytx_txid(this.__wbg_ptr, ptr0, len0);
-  }
-  /**
-   * @param {Uint8Array} hiding
-   * @param {Uint8Array} binding
-   */
-  constructor(hiding, binding) {
-    const ptr0 = passArray8ToWasm0(hiding, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(binding, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.signingcommitment_new(ptr0, len0, ptr1, len1);
-    this.__wbg_ptr = ret >>> 0;
-    SigningCommitmentFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
-};
-var SigningNonceFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-}, unregister: () => {
-} } : new FinalizationRegistry((ptr) => wasm.__wbg_signingnonce_free(ptr >>> 0, 1));
-var SigningNonce = class _SigningNonce {
-  static __wrap(ptr) {
-    ptr = ptr >>> 0;
-    const obj = Object.create(_SigningNonce.prototype);
-    obj.__wbg_ptr = ptr;
-    SigningNonceFinalization.register(obj, obj.__wbg_ptr, obj);
-    return obj;
-  }
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    SigningNonceFinalization.unregister(this);
-    return ptr;
-  }
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_signingnonce_free(ptr, 0);
-  }
-  /**
-   * @returns {Uint8Array}
-   */
-  get hiding() {
-    const ret = wasm.__wbg_get_signingnonce_hiding(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
-  /**
-   * @param {Uint8Array} arg0
-   */
-  set hiding(arg0) {
-    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_dummytx_tx(this.__wbg_ptr, ptr0, len0);
-  }
-  /**
-   * @returns {Uint8Array}
-   */
-  get binding() {
-    const ret = wasm.__wbg_get_signingnonce_binding(this.__wbg_ptr);
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-  }
-  /**
-   * @param {Uint8Array} arg0
-   */
-  set binding(arg0) {
-    const ptr0 = passArray8ToWasm0(arg0, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    wasm.__wbg_set_dummytx_txid(this.__wbg_ptr, ptr0, len0);
-  }
-  /**
-   * @param {Uint8Array} hiding
-   * @param {Uint8Array} binding
-   */
-  constructor(hiding, binding) {
-    const ptr0 = passArray8ToWasm0(hiding, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(binding, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.signingcommitment_new(ptr0, len0, ptr1, len1);
-    this.__wbg_ptr = ret >>> 0;
-    SigningNonceFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
-};
-var TransactionResultFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
-}, unregister: () => {
-} } : new FinalizationRegistry((ptr) => wasm.__wbg_transactionresult_free(ptr >>> 0, 1));
-
-// src/utils/signing.ts
-function getRandomSigningNonce() {
-  const binding = import_secp256k14.secp256k1.utils.randomPrivateKey();
-  const hiding = import_secp256k14.secp256k1.utils.randomPrivateKey();
-  return createSigningNonce(binding, hiding);
-}
-function createSigningNonce(binding, hiding) {
-  if (binding.length !== 32 || hiding.length !== 32) {
-    throw new Error("Invalid nonce length");
-  }
-  return {
-    binding,
-    hiding
-  };
-}
-function getSigningCommitmentFromNonce(nonce) {
-  const bindingPubKey = import_secp256k14.secp256k1.getPublicKey(nonce.binding, true);
-  const hidingPubKey = import_secp256k14.secp256k1.getPublicKey(nonce.hiding, true);
-  return {
-    binding: bindingPubKey,
-    hiding: hidingPubKey
-  };
-}
-function createWasmSigningNonce(nonce) {
-  return new SigningNonce(nonce.hiding, nonce.binding);
-}
-function createWasmSigningCommitment(commitment) {
-  return new SigningCommitment2(commitment.hiding, commitment.binding);
-}
-
-// src/utils/wasm.ts
-function signFrost({
-  msg,
-  keyPackage,
-  nonce,
-  selfCommitment,
-  statechainCommitments,
-  adaptorPubKey
-}) {
-  return wasm_sign_frost(
-    msg,
-    keyPackage,
-    nonce,
-    selfCommitment,
-    statechainCommitments,
-    adaptorPubKey
-  );
-}
-function aggregateFrost({
-  msg,
-  statechainCommitments,
-  selfCommitment,
-  statechainSignatures,
-  selfSignature,
-  statechainPublicKeys,
-  selfPublicKey,
-  verifyingKey,
-  adaptorPubKey
-}) {
-  return wasm_aggregate_frost(
-    msg,
-    statechainCommitments,
-    selfCommitment,
-    statechainSignatures,
-    selfSignature,
-    statechainPublicKeys,
-    selfPublicKey,
-    verifyingKey,
-    adaptorPubKey
-  );
-}
-
-// src/signer/signer.ts
-globalThis.Buffer = import_buffer.Buffer;
-var DefaultSparkSigner = class {
-  identityPrivateKey = null;
-  // <hex, hex>
-  publicKeyToPrivateKeyMap = /* @__PURE__ */ new Map();
-  commitmentToNonceMap = /* @__PURE__ */ new Map();
-  deriveSigningKey(hash) {
-    if (!this.identityPrivateKey) {
-      throw new Error("Private key is not set");
-    }
-    let amount = 0;
-    for (let i = 0; i < 8; i++) {
-      const view = new DataView(hash.buffer, i * 4, 4);
-      amount += view.getUint32(0, false);
-      amount = amount % 2147483648;
-    }
-    const newPrivateKey = this.identityPrivateKey.deriveChild(
-      Number(amount) + 2147483648
-    ).privateKey;
-    if (!newPrivateKey) {
-      throw new Error("Failed to recover signing key");
-    }
-    return newPrivateKey;
-  }
-  async restoreSigningKeysFromLeafs(leafs) {
-    if (!this.identityPrivateKey) {
-      throw new Error("Private key is not set");
-    }
-    for (const leaf of leafs) {
-      const hash = (0, import_utils5.sha256)(leaf.id);
-      const privateKey = this.deriveSigningKey(hash);
-      const publicKey = import_secp256k15.secp256k1.getPublicKey(privateKey);
-      this.publicKeyToPrivateKeyMap.set(
-        (0, import_utils4.bytesToHex)(publicKey),
-        (0, import_utils4.bytesToHex)(privateKey)
-      );
-    }
-  }
-  async getSchnorrPublicKey(publicKey) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey));
-    if (!privateKey) {
-      throw new Error("Private key is not set");
-    }
-    return import_secp256k15.schnorr.getPublicKey((0, import_utils4.hexToBytes)(privateKey));
-  }
-  async signSchnorr(message, publicKey) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey));
-    if (!privateKey) {
-      throw new Error("Private key is not set");
-    }
-    return import_secp256k15.schnorr.sign(message, (0, import_utils4.hexToBytes)(privateKey));
-  }
-  async signSchnorrWithIdentityKey(message) {
-    if (!this.identityPrivateKey?.privateKey) {
-      throw new Error("Private key is not set");
-    }
-    const signature = import_secp256k15.schnorr.sign(
-      message,
-      this.identityPrivateKey.privateKey
-    );
-    return signature;
-  }
-  async getIdentityPublicKey() {
-    if (!this.identityPrivateKey?.privateKey) {
-      throw new Error("Private key is not set");
-    }
-    return import_secp256k15.secp256k1.getPublicKey(this.identityPrivateKey.privateKey);
-  }
-  async generateMnemonic() {
-    return (0, import_bip39.generateMnemonic)(import_english.wordlist);
-  }
-  async createSparkWalletFromMnemonic(mnemonic, network) {
-    const seed = await bip39.mnemonicToSeed(mnemonic);
-    return this.createSparkWalletFromSeed(seed, network);
-  }
-  async getTrackedPublicKeys() {
-    return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(import_utils4.hexToBytes);
-  }
-  async generatePublicKey(hash) {
-    if (!this.identityPrivateKey) {
-      throw new Error("Private key is not set");
-    }
-    let newPrivateKey = null;
-    if (hash) {
-      newPrivateKey = this.deriveSigningKey(hash);
-    } else {
-      newPrivateKey = import_secp256k15.secp256k1.utils.randomPrivateKey();
-    }
-    if (!newPrivateKey) {
-      throw new Error("Failed to generate new private key");
-    }
-    const publicKey = import_secp256k15.secp256k1.getPublicKey(newPrivateKey);
-    const pubKeyHex = (0, import_utils4.bytesToHex)(publicKey);
-    const privKeyHex = (0, import_utils4.bytesToHex)(newPrivateKey);
-    this.publicKeyToPrivateKeyMap.set(pubKeyHex, privKeyHex);
-    return publicKey;
-  }
-  async removePublicKey(publicKey) {
-    this.publicKeyToPrivateKeyMap.delete((0, import_utils4.bytesToHex)(publicKey));
-  }
-  async subtractPrivateKeysGivenPublicKeys(first, second) {
-    const firstPubKeyHex = (0, import_utils4.bytesToHex)(first);
-    const secondPubKeyHex = (0, import_utils4.bytesToHex)(second);
-    const firstPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(firstPubKeyHex);
-    const secondPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(secondPubKeyHex);
-    if (!firstPrivateKeyHex || !secondPrivateKeyHex) {
-      throw new Error("Private key is not set");
-    }
-    const firstPrivateKey = (0, import_utils4.hexToBytes)(firstPrivateKeyHex);
-    const secondPrivateKey = (0, import_utils4.hexToBytes)(secondPrivateKeyHex);
-    const resultPrivKey = subtractPrivateKeys(
-      firstPrivateKey,
-      secondPrivateKey
-    );
-    const resultPubKey = import_secp256k15.secp256k1.getPublicKey(resultPrivKey);
-    const resultPrivKeyHex = (0, import_utils4.bytesToHex)(resultPrivKey);
-    const resultPubKeyHex = (0, import_utils4.bytesToHex)(resultPubKey);
-    this.publicKeyToPrivateKeyMap.set(resultPubKeyHex, resultPrivKeyHex);
-    return resultPubKey;
-  }
-  async splitSecretWithProofs({
-    secret,
-    curveOrder,
-    threshold,
-    numShares,
-    isSecretPubkey = false
-  }) {
-    if (isSecretPubkey) {
-      const pubKeyHex = (0, import_utils4.bytesToHex)(secret);
-      const privateKey = this.publicKeyToPrivateKeyMap.get(pubKeyHex);
-      if (!privateKey) {
-        throw new Error("Private key is not set");
-      }
-      secret = (0, import_utils4.hexToBytes)(privateKey);
-    }
-    const secretAsInt = (0, import_utils4.bytesToNumberBE)(secret);
-    return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
-  }
-  async signFrost({
-    message,
-    privateAsPubKey,
-    publicKey,
-    verifyingKey,
-    selfCommitment,
-    statechainCommitments,
-    adaptorPubKey
-  }) {
-    const privateAsPubKeyHex = (0, import_utils4.bytesToHex)(privateAsPubKey);
-    const signingPrivateKey = this.publicKeyToPrivateKeyMap.get(privateAsPubKeyHex);
-    if (!signingPrivateKey) {
-      throw new Error("Private key is not set");
-    }
-    const nonce = this.commitmentToNonceMap.get(selfCommitment);
-    if (!nonce) {
-      throw new Error("Nonce is not set");
-    }
-    const keyPackage = new KeyPackage(
-      (0, import_utils4.hexToBytes)(signingPrivateKey),
-      publicKey,
-      verifyingKey
-    );
-    return signFrost({
-      msg: message,
-      keyPackage,
-      nonce: createWasmSigningNonce(nonce),
-      selfCommitment: createWasmSigningCommitment(selfCommitment),
-      statechainCommitments,
-      adaptorPubKey
-    });
-  }
-  async aggregateFrost({
-    message,
-    publicKey,
-    verifyingKey,
-    selfCommitment,
-    statechainCommitments,
-    adaptorPubKey,
-    selfSignature,
-    statechainSignatures,
-    statechainPublicKeys
-  }) {
-    return aggregateFrost({
-      msg: message,
-      statechainSignatures,
-      statechainPublicKeys,
-      verifyingKey,
-      statechainCommitments,
-      selfCommitment: createWasmSigningCommitment(selfCommitment),
-      selfPublicKey: publicKey,
-      selfSignature,
-      adaptorPubKey
-    });
-  }
-  async createSparkWalletFromSeed(seed, network) {
-    if (typeof seed === "string") {
-      seed = (0, import_utils4.hexToBytes)(seed);
-    }
-    const hdkey = import_bip32.HDKey.fromMasterSeed(seed).derive(
-      `m/${network === 3 /* REGTEST */ ? "0" : "1"}`
-    );
-    if (!hdkey.privateKey) {
-      throw new Error("Could not derive private key from seed");
-    }
-    this.identityPrivateKey = hdkey;
-    return (0, import_utils4.bytesToHex)(import_secp256k15.secp256k1.getPublicKey(hdkey.privateKey, true));
-  }
-  async signMessageWithPublicKey(message, publicKey, compact) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey));
-    if (!privateKey) {
-      throw new Error(
-        `No private key found for public key: ${(0, import_utils4.bytesToHex)(publicKey)}`
-      );
-    }
-    const signature = import_secp256k15.secp256k1.sign(message, (0, import_utils4.hexToBytes)(privateKey));
-    if (compact) {
-      return signature.toCompactRawBytes();
-    }
-    return signature.toDERRawBytes();
-  }
-  async signMessageWithIdentityKey(message, compact) {
-    if (!this.identityPrivateKey?.privateKey) {
-      throw new Error("Private key is not set");
-    }
-    const signature = import_secp256k15.secp256k1.sign(
-      message,
-      this.identityPrivateKey.privateKey
-    );
-    if (compact) {
-      return signature.toCompactRawBytes();
-    }
-    return signature.toDERRawBytes();
-  }
-  async encryptLeafPrivateKeyEcies(receiverPublicKey, publicKey) {
-    const publicKeyHex = (0, import_utils4.bytesToHex)(publicKey);
-    const privateKey = this.publicKeyToPrivateKeyMap.get(publicKeyHex);
-    if (!privateKey) {
-      throw new Error("Private key is not set");
-    }
-    return ecies.encrypt(receiverPublicKey, (0, import_utils4.hexToBytes)(privateKey));
-  }
-  async decryptEcies(ciphertext) {
-    if (!this.identityPrivateKey?.privateKey) {
-      throw new Error("Private key is not set");
-    }
-    const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils4.bytesToHex)(this.identityPrivateKey.privateKey)
-    );
-    const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
-    const publicKey = import_secp256k15.secp256k1.getPublicKey(privateKey);
-    const publicKeyHex = (0, import_utils4.bytesToHex)(publicKey);
-    const privateKeyHex = (0, import_utils4.bytesToHex)(privateKey);
-    this.publicKeyToPrivateKeyMap.set(publicKeyHex, privateKeyHex);
-    return publicKey;
-  }
-  async getRandomSigningCommitment() {
-    const nonce = getRandomSigningNonce();
-    const commitment = getSigningCommitmentFromNonce(nonce);
-    this.commitmentToNonceMap.set(commitment, nonce);
-    return commitment;
-  }
-  // Hardcode this for default ssp
-  async getSspIdentityPublicKey(network) {
-    if (network === 0 /* MAINNET */) {
-      return (0, import_utils4.hexToBytes)(
-        "02e0b8d42c5d3b5fe4c5beb6ea796ab3bc8aaf28a3d3195407482c67e0b58228a5"
-      );
-    } else {
-      return (0, import_utils4.hexToBytes)(
-        "028c094a432d46a0ac95349d792c2e3730bd60c29188db716f56a99e39b95338b4"
-      );
-    }
-  }
-  async hashRandomPrivateKey() {
-    return (0, import_utils5.sha256)(import_secp256k15.secp256k1.utils.randomPrivateKey());
-  }
-  async generateAdaptorFromSignature(signature) {
-    const adaptor = generateAdaptorFromSignature(signature);
-    const adaptorPublicKey = import_secp256k15.secp256k1.getPublicKey(adaptor.adaptorPrivateKey);
-    this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(adaptorPublicKey),
-      (0, import_utils4.bytesToHex)(adaptor.adaptorPrivateKey)
-    );
-    return {
-      adaptorSignature: signature,
-      adaptorPublicKey
-    };
-  }
-  async getDepositSigningKey() {
-    if (!this.identityPrivateKey?.privateKey) {
-      throw new Error("Private key is not set");
-    }
-    const depositSigningKey = this.identityPrivateKey.derive("M/8797555'/0'/2'");
-    if (!depositSigningKey.privateKey) {
-      throw new Error("Could not derive deposit signing key");
-    }
-    this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(import_secp256k15.secp256k1.getPublicKey(depositSigningKey.privateKey)),
-      (0, import_utils4.bytesToHex)(depositSigningKey.privateKey)
-    );
-    return import_secp256k15.secp256k1.getPublicKey(depositSigningKey.privateKey);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DefaultSparkSigner
-});