@buildonspark/spark-sdk 0.3.6 → 0.3.7

package/dist/debug.cjs

@@ -1044,12 +1044,12 @@ var init_spark_bindings = __esm({
 });
 
 // src/utils/logging.ts
-var import_core11, LOGGER_NAMES, SparkSdkLogger;
+var import_core12, LOGGER_NAMES, SparkSdkLogger;
 var init_logging = __esm({
   "src/utils/logging.ts"() {
     "use strict";
     init_buffer();
-    import_core11 = require("@lightsparkdev/core");
+    import_core12 = require("@lightsparkdev/core");
     LOGGER_NAMES = {
       wasm: "wasm"
     };
@@ -1057,7 +1057,7 @@ var init_logging = __esm({
       static loggers = /* @__PURE__ */ new Map();
       static get(name) {
         if (!this.loggers.has(name)) {
-          this.loggers.set(name, new import_core11.Logger(name));
+          this.loggers.set(name, new import_core12.Logger(name));
         }
         return this.loggers.get(name);
       }
@@ -1111,30 +1111,30 @@ function signFrost({
   adaptorPubKey
 }) {
   const logMsg = JSON.stringify({
-    message: (0, import_utils4.bytesToHex)(message),
+    message: (0, import_utils17.bytesToHex)(message),
     keyPackage: {
-      secretKey: (0, import_utils4.bytesToHex)(keyPackage.secretKey),
-      publicKey: (0, import_utils4.bytesToHex)(keyPackage.publicKey),
-      verifyingKey: (0, import_utils4.bytesToHex)(keyPackage.verifyingKey)
+      secretKey: (0, import_utils17.bytesToHex)(keyPackage.secretKey),
+      publicKey: (0, import_utils17.bytesToHex)(keyPackage.publicKey),
+      verifyingKey: (0, import_utils17.bytesToHex)(keyPackage.verifyingKey)
     },
     nonce: {
-      hiding: (0, import_utils4.bytesToHex)(nonce.hiding),
-      binding: (0, import_utils4.bytesToHex)(nonce.binding)
+      hiding: (0, import_utils17.bytesToHex)(nonce.hiding),
+      binding: (0, import_utils17.bytesToHex)(nonce.binding)
     },
     selfCommitment: {
-      hiding: (0, import_utils4.bytesToHex)(selfCommitment.hiding),
-      binding: (0, import_utils4.bytesToHex)(selfCommitment.binding)
+      hiding: (0, import_utils17.bytesToHex)(selfCommitment.hiding),
+      binding: (0, import_utils17.bytesToHex)(selfCommitment.binding)
     },
     statechainCommitments: Object.fromEntries(
       Object.entries(statechainCommitments ?? {}).map(([k, v]) => [
         k,
         {
-          hiding: (0, import_utils4.bytesToHex)(v.hiding),
-          binding: (0, import_utils4.bytesToHex)(v.binding)
+          hiding: (0, import_utils17.bytesToHex)(v.hiding),
+          binding: (0, import_utils17.bytesToHex)(v.binding)
         }
       ])
     ),
-    adaptorPubKey: adaptorPubKey ? (0, import_utils4.bytesToHex)(adaptorPubKey) : void 0
+    adaptorPubKey: adaptorPubKey ? (0, import_utils17.bytesToHex)(adaptorPubKey) : void 0
   });
   SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", logMsg);
   const result = wasm_sign_frost(
@@ -1147,7 +1147,7 @@ function signFrost({
   );
   SparkSdkLogger.get(LOGGER_NAMES.wasm).trace(
     "signFrost result",
-    (0, import_utils4.bytesToHex)(result)
+    (0, import_utils17.bytesToHex)(result)
   );
   return result;
 }
@@ -1163,36 +1163,36 @@ function aggregateFrost({
   adaptorPubKey
 }) {
   const logMsg = JSON.stringify({
-    message: (0, import_utils4.bytesToHex)(message),
+    message: (0, import_utils17.bytesToHex)(message),
     statechainCommitments: Object.fromEntries(
       Object.entries(statechainCommitments ?? {}).map(([k, v]) => [
         k,
         {
-          hiding: (0, import_utils4.bytesToHex)(v.hiding),
-          binding: (0, import_utils4.bytesToHex)(v.binding)
+          hiding: (0, import_utils17.bytesToHex)(v.hiding),
+          binding: (0, import_utils17.bytesToHex)(v.binding)
         }
       ])
     ),
     selfCommitment: {
-      hiding: (0, import_utils4.bytesToHex)(selfCommitment.hiding),
-      binding: (0, import_utils4.bytesToHex)(selfCommitment.binding)
+      hiding: (0, import_utils17.bytesToHex)(selfCommitment.hiding),
+      binding: (0, import_utils17.bytesToHex)(selfCommitment.binding)
     },
     statechainSignatures: Object.fromEntries(
       Object.entries(statechainSignatures ?? {}).map(([k, v]) => [
         k,
-        (0, import_utils4.bytesToHex)(v)
+        (0, import_utils17.bytesToHex)(v)
       ])
     ),
-    selfSignature: (0, import_utils4.bytesToHex)(selfSignature),
+    selfSignature: (0, import_utils17.bytesToHex)(selfSignature),
     statechainPublicKeys: Object.fromEntries(
       Object.entries(statechainPublicKeys ?? {}).map(([k, v]) => [
         k,
-        (0, import_utils4.bytesToHex)(v)
+        (0, import_utils17.bytesToHex)(v)
       ])
     ),
-    selfPublicKey: (0, import_utils4.bytesToHex)(selfPublicKey),
-    verifyingKey: (0, import_utils4.bytesToHex)(verifyingKey),
-    adaptorPubKey: adaptorPubKey ? (0, import_utils4.bytesToHex)(adaptorPubKey) : void 0
+    selfPublicKey: (0, import_utils17.bytesToHex)(selfPublicKey),
+    verifyingKey: (0, import_utils17.bytesToHex)(verifyingKey),
+    adaptorPubKey: adaptorPubKey ? (0, import_utils17.bytesToHex)(adaptorPubKey) : void 0
   });
   SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", logMsg);
   const result = wasm_aggregate_frost(
@@ -1208,7 +1208,7 @@ function aggregateFrost({
   );
   SparkSdkLogger.get(LOGGER_NAMES.wasm).trace(
     "aggregateFrost result",
-    (0, import_utils4.bytesToHex)(result)
+    (0, import_utils17.bytesToHex)(result)
   );
   return result;
 }
@@ -1230,12 +1230,12 @@ function decryptEcies({
 }) {
   return decrypt_ecies(encryptedMsg, privateKey);
 }
-var import_utils4;
+var import_utils17;
 var init_wasm = __esm({
   "src/spark_bindings/wasm/index.ts"() {
     "use strict";
     init_buffer();
-    import_utils4 = require("@noble/curves/utils");
+    import_utils17 = require("@noble/curves/utils");
     init_spark_bindings();
     init_logging();
   }
@@ -1382,6 +1382,28 @@ var import_sha2 = require("@noble/hashes/sha2");
 // src/errors/index.ts
 init_buffer();
 
+// src/utils/fetch.ts
+init_buffer();
+var fetchImpl = typeof window !== "undefined" && window.fetch ? window.fetch.bind(window) : globalThis.fetch ? globalThis.fetch.bind(globalThis) : null;
+var Headers = globalThis.Headers ?? null;
+var getFetch = () => {
+  if (!fetchImpl) {
+    throw new Error(
+      "Fetch implementation is not set. Please set it using setFetch()."
+    );
+  }
+  if (!Headers) {
+    throw new Error(
+      "Headers implementation is not set. Please set it using setFetch()."
+    );
+  }
+  const val = {
+    fetch: fetchImpl,
+    Headers
+  };
+  return val;
+};
+
 // src/graphql/mutations/ClaimStaticDeposit.ts
 init_buffer();
 
@@ -1747,7 +1769,7 @@ fragment CoopExitRequestFragment on CoopExitRequest {
 var CompleteCoopExit = `
   mutation CompleteCoopExit(
     $user_outbound_transfer_external_id: UUID!
-    $coop_exit_request_id: ID!
+    $coop_exit_request_id: ID
   ) {
     complete_coop_exit(input: {
       user_outbound_transfer_external_id: $user_outbound_transfer_external_id
@@ -1962,11 +1984,12 @@ var RequestCoopExit = `
   mutation RequestCoopExit(
     $leaf_external_ids: [UUID!]!
     $withdrawal_address: String!
-    $idempotency_key: String!
+    $idempotency_key: String
     $exit_speed: ExitSpeed!
     $withdraw_all: Boolean
     $fee_leaf_external_ids: [UUID!]
     $fee_quote_id: ID
+    $user_outbound_transfer_external_id: UUID
   ) {
     request_coop_exit(
       input: {
@@ -1977,6 +2000,7 @@ var RequestCoopExit = `
         withdraw_all: $withdraw_all
         fee_leaf_external_ids: $fee_leaf_external_ids
         fee_quote_id: $fee_quote_id
+        user_outbound_transfer_external_id: $user_outbound_transfer_external_id
       }
     ) {
       request {
@@ -2195,13 +2219,15 @@ fragment LightningSendRequestFragment on LightningSendRequest {
 var RequestLightningSend = `
   mutation RequestLightningSend(
     $encoded_invoice: String!
-    $idempotency_key: String!
+    $idempotency_key: String
     $amount_sats: Long
+    $user_outbound_transfer_external_id: UUID
   ) {
     request_lightning_send(input: {
       encoded_invoice: $encoded_invoice
       idempotency_key: $idempotency_key
       amount_sats: $amount_sats
+      user_outbound_transfer_external_id: $user_outbound_transfer_external_id
     }) {
       request {
         ...LightningSendRequestFragment
@@ -2934,28 +2960,6 @@ var UserRequest2 = `
   ${FRAGMENT14}
 `;
 
-// src/utils/fetch.ts
-init_buffer();
-var fetchImpl = typeof window !== "undefined" && window.fetch ? window.fetch.bind(window) : globalThis.fetch ? globalThis.fetch.bind(globalThis) : null;
-var Headers = globalThis.Headers ?? null;
-var getFetch = () => {
-  if (!fetchImpl) {
-    throw new Error(
-      "Fetch implementation is not set. Please set it using setFetch()."
-    );
-  }
-  if (!Headers) {
-    throw new Error(
-      "Headers implementation is not set. Please set it using setFetch()."
-    );
-  }
-  const val = {
-    fetch: fetchImpl,
-    Headers
-  };
-  return val;
-};
-
 // src/graphql/client.ts
 var SspClient = class {
   requester;
@@ -3058,14 +3062,12 @@ var SspClient = class {
     throw new Error("Not implemented");
   }
   async completeCoopExit({
-    userOutboundTransferExternalId,
-    coopExitRequestId
+    userOutboundTransferExternalId
   }) {
     return await this.executeRawQuery({
       queryPayload: CompleteCoopExit,
       variables: {
-        user_outbound_transfer_external_id: userOutboundTransferExternalId,
-        coop_exit_request_id: coopExitRequestId
+        user_outbound_transfer_external_id: userOutboundTransferExternalId
       },
       constructObject: (response) => {
         return CoopExitRequestFromJson(response.complete_coop_exit.request);
@@ -3075,29 +3077,28 @@ var SspClient = class {
   async requestCoopExit({
     leafExternalIds,
     withdrawalAddress,
-    idempotencyKey,
     exitSpeed,
     feeLeafExternalIds,
     feeQuoteId,
-    withdrawAll
+    withdrawAll,
+    userOutboundTransferExternalId
   }) {
     return await this.executeRawQuery({
       queryPayload: RequestCoopExit,
       variables: {
         leaf_external_ids: leafExternalIds,
         withdrawal_address: withdrawalAddress,
-        idempotency_key: idempotencyKey,
         exit_speed: exitSpeed,
         fee_leaf_external_ids: feeLeafExternalIds,
         fee_quote_id: feeQuoteId,
-        withdraw_all: withdrawAll
+        withdraw_all: withdrawAll,
+        user_outbound_transfer_external_id: userOutboundTransferExternalId
       },
       constructObject: (response) => {
         return CoopExitRequestFromJson(response.request_coop_exit.request);
       }
     });
   }
-  // TODO: Lets name this better
   async requestLightningReceive({
     amountSats,
     network,
@@ -3129,15 +3130,15 @@ var SspClient = class {
   }
   async requestLightningSend({
     encodedInvoice,
-    idempotencyKey,
-    amountSats
+    amountSats,
+    userOutboundTransferExternalId
   }) {
     return await this.executeRawQuery({
       queryPayload: RequestLightningSend,
       variables: {
         encoded_invoice: encodedInvoice,
-        idempotency_key: idempotencyKey,
-        amount_sats: amountSats
+        amount_sats: amountSats,
+        user_outbound_transfer_external_id: userOutboundTransferExternalId
       },
       constructObject: (response) => {
         return LightningSendRequestFromJson(
@@ -19085,1247 +19086,426 @@ function isSet3(value) {
 // src/services/config.ts
 init_buffer();
 
-// src/signer/signer.ts
-init_buffer();
-var import_secp256k14 = require("@bitcoinerlab/secp256k1");
-var import_secp256k15 = require("@noble/curves/secp256k1");
-var import_utils5 = require("@noble/curves/utils");
-var import_sha22 = require("@noble/hashes/sha2");
-var import_bip32 = require("@scure/bip32");
-var import_bip39 = require("@scure/bip39");
-var import_english = require("@scure/bip39/wordlists/english");
-var import_utils6 = require("@scure/btc-signer/utils");
-var ecies = __toESM(require("eciesjs"), 1);
-
-// src/constants.ts
-init_buffer();
-var import_core10 = require("@lightsparkdev/core");
-var isReactNative = "navigator" in globalThis && navigator.product === "ReactNative";
-var isBun = "Bun" in globalThis;
-var isWebExtension = (
-  /* globalThis.chrome actually exists in extension contexts for all browsers for legacy reasons: */
-  "chrome" in globalThis && globalThis.chrome.runtime?.id
-);
-var userAgent = "navigator" in globalThis ? globalThis.navigator.userAgent || "unknown-user-agent" : void 0;
-var packageVersion = true ? "0.3.6" : "unknown";
-var baseEnvStr = "unknown";
-if (isBun) {
-  const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
-  baseEnvStr = `bun/${bunVersion}`;
-} else if (import_core10.isNode) {
-  baseEnvStr = `node/${globalThis.process.version}`;
-} else if (isReactNative) {
-  baseEnvStr = "react-native";
-} else if (import_core10.isBare) {
-  const bareVersion = Bare.version;
-  baseEnvStr = `bare/${bareVersion}`;
-} else if (isWebExtension) {
-  const protocol = "location" in globalThis ? globalThis.location.protocol : "";
-  const extScriptType = "window" in globalThis ? "content-script" : "background-script";
-  baseEnvStr = `web-extension/${protocol.replace(":", "")}/${extScriptType}/${userAgent}`;
-} else {
-  baseEnvStr = `browser/${userAgent}`;
-}
-var clientEnv = `js-spark-sdk/${packageVersion} ${baseEnvStr}`;
-
-// src/utils/keys.ts
+// src/utils/network.ts
 init_buffer();
-var import_secp256k1 = require("@noble/curves/secp256k1");
-var import_utils2 = require("@noble/curves/utils");
-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 = import_secp256k1.secp256k1.Point.fromHex(a);
-  const pubkeyB = import_secp256k1.secp256k1.Point.fromHex(b);
-  return pubkeyA.add(pubkeyB).toBytes(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 = import_secp256k1.secp256k1.Point.fromHex(pubkey);
-  const privTweek = import_secp256k1.secp256k1.utils.normPrivateKeyToScalar(tweak);
-  const pubTweek = import_secp256k1.secp256k1.getPublicKey(privTweek, true);
-  const tweekPoint = import_secp256k1.secp256k1.Point.fromHex(pubTweek);
-  return pubkeyPoint.add(tweekPoint).toBytes(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 = import_secp256k1.secp256k1.Point.fromHex(a);
-  const pubkeyB = import_secp256k1.secp256k1.Point.fromHex(b);
-  return pubkeyA.subtract(pubkeyB).toBytes(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 = import_secp256k1.secp256k1.utils.normPrivateKeyToScalar(a);
-  const privB = import_secp256k1.secp256k1.utils.normPrivateKeyToScalar(b);
-  const sum = (privA + privB) % import_secp256k1.secp256k1.CURVE.n;
-  return (0, import_utils2.numberToBytesBE)(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
-    });
+var btc = __toESM(require("@scure/btc-signer"), 1);
+var import_base2 = require("@scure/base");
+var Network2 = /* @__PURE__ */ ((Network5) => {
+  Network5[Network5["MAINNET"] = 0] = "MAINNET";
+  Network5[Network5["TESTNET"] = 1] = "TESTNET";
+  Network5[Network5["SIGNET"] = 2] = "SIGNET";
+  Network5[Network5["REGTEST"] = 3] = "REGTEST";
+  Network5[Network5["LOCAL"] = 4] = "LOCAL";
+  return Network5;
+})(Network2 || {});
+var NetworkToProto = {
+  [0 /* MAINNET */]: 1 /* MAINNET */,
+  [1 /* TESTNET */]: 3 /* TESTNET */,
+  [2 /* SIGNET */]: 4 /* SIGNET */,
+  [3 /* REGTEST */]: 2 /* REGTEST */,
+  [4 /* LOCAL */]: 2 /* REGTEST */
+};
+var protoToNetwork = (protoNetwork) => {
+  switch (protoNetwork) {
+    case 1 /* MAINNET */:
+      return 0 /* MAINNET */;
+    case 3 /* TESTNET */:
+      return 1 /* TESTNET */;
+    case 4 /* SIGNET */:
+      return 2 /* SIGNET */;
+    case 2 /* REGTEST */:
+      return 3 /* REGTEST */;
+    default:
+      return void 0;
   }
-  const privA = import_secp256k1.secp256k1.utils.normPrivateKeyToScalar(a);
-  const privB = import_secp256k1.secp256k1.utils.normPrivateKeyToScalar(b);
-  const sum = (import_secp256k1.secp256k1.CURVE.n - privB + privA) % import_secp256k1.secp256k1.CURVE.n;
-  return (0, import_utils2.numberToBytesBE)(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
-      });
+};
+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" }
+};
+var getNetwork = (network) => NetworkConfig[network];
+function getNetworkFromAddress(address) {
+  try {
+    const bechAddress = address;
+    const decoded = (() => {
+      try {
+        return import_base2.bech32.decode(bechAddress);
+      } catch (_) {
+        return import_base2.bech32m.decode(bechAddress);
+      }
+    })();
+    if (decoded.prefix === "bc") {
+      return "MAINNET" /* MAINNET */;
+    } else if (decoded.prefix === "bcrt") {
+      return "REGTEST" /* REGTEST */;
     }
-    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
-    });
+  } catch (err) {
+    throw new ValidationError(
+      "Invalid Bitcoin address",
+      {
+        field: "address",
+        value: address,
+        expected: "Valid Bech32 address with prefix 'bc' or 'bcrt'"
+      },
+      err instanceof Error ? err : void 0
+    );
   }
-  const sum = sumOfPrivateKeys(keys);
-  return subtractPrivateKeys(target, sum);
+  return null;
+}
+function getNetworkFromString(network) {
+  const net = (network ?? "REGTEST").toUpperCase();
+  if (net === "MAINNET") return 0 /* MAINNET */;
+  if (net === "TESTNET") return 1 /* TESTNET */;
+  if (net === "SIGNET") return 2 /* SIGNET */;
+  if (net === "LOCAL") return 4 /* LOCAL */;
+  return 3 /* REGTEST */;
 }
 
-// src/utils/secret-sharing.ts
+// src/services/wallet-config.ts
 init_buffer();
-var import_secp256k12 = require("@noble/curves/secp256k1");
-var import_utils3 = require("@noble/curves/utils");
 
-// src/utils/crypto.ts
+// src/tests/isHermeticTest.ts
 init_buffer();
-var cryptoImpl = globalThis.crypto ?? null;
-var getCrypto = () => {
-  if (!cryptoImpl) {
-    throw new Error(
-      "Crypto implementation is not set. Please set it using setCrypto()."
-    );
+var isHermeticTest = Boolean(
+  typeof process !== "undefined" && process?.env?.HERMETIC_TEST === "true"
+);
+
+// src/services/wallet-config.ts
+var SSP_IDENTITY_PUBLIC_KEYS = {
+  LOCAL: "028c094a432d46a0ac95349d792c2e3730bd60c29188db716f56a99e39b95338b4",
+  REGTEST: {
+    PROD: "022bf283544b16c0622daecb79422007d167eca6ce9f0c98c0c49833b1f7170bfe"
+  },
+  MAINNET: {
+    PROD: "023e33e2920326f64ea31058d44777442d97d7d5cbfcf54e3060bc1695e5261c93"
   }
-  return cryptoImpl;
 };
-
-// src/utils/secret-sharing.ts
-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 crypto = getCrypto();
-    const randBytes = crypto.getRandomValues(new Uint8Array(byteLength + 1));
-    const randValue = BigInt("0x" + (0, import_utils3.bytesToHex)(randBytes)) & mask;
-    if (randValue < maxBigInt) {
-      return randValue;
+var URL_CONFIG = {
+  LOCAL: {
+    SSP: "http://127.0.0.1:5000",
+    ELECTRS: "http://127.0.0.1:30000"
+  },
+  REGTEST: {
+    PROD: {
+      SSP: "https://api.lightspark.com",
+      ELECTRS: "https://regtest-mempool.us-west-2.sparkinfra.net/api"
+    }
+  },
+  MAINNET: {
+    PROD: {
+      SSP: "https://api.lightspark.com",
+      ELECTRS: "https://mempool.space/api"
     }
   }
-}
-function modInverse(a, m) {
-  a = (a % m + m) % m;
-  let [old_r, r] = [a, m];
-  let [old_s, s2] = [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, s2] = [s2, old_s - quotient * s2];
-    [old_t, t] = [t, old_t - quotient * t];
+};
+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;
   }
-  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"
-    });
+}
+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;
   }
-  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;
+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;
   }
-  return result;
 }
-function fieldDiv(numerator, denominator, fieldModulus) {
-  if (denominator === 0n) {
-    throw new ValidationError("Division by zero", {
-      field: "denominator",
-      value: "0",
-      expected: "Non-zero value"
-    });
+function getSspSchemaEndpoint(network) {
+  switch (network) {
+    case "LOCAL":
+      return "graphql/spark/rc";
   }
-  const inverse = modInverse(denominator, fieldModulus);
-  return numerator * inverse % fieldModulus;
+  return;
 }
-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"
-    });
+var PROD_PUBKEYS = [
+  "03dfbdff4b6332c220f8fa2ba8ed496c698ceada563fa01b67d9983bfc5c95e763",
+  "03e625e9768651c9be268e287245cc33f96a68ce9141b0b4769205db027ee8ed77",
+  "022eda13465a59205413086130a65dc0ed1b8f8e51937043161f8be0c369b1a410"
+];
+function getLocalFrostSignerAddress() {
+  return isHermeticTest ? "localhost:9999" : "unix:///tmp/frost_0.sock";
+}
+var BASE_CONFIG = {
+  network: "LOCAL",
+  coordinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
+  frostSignerAddress: getLocalFrostSignerAddress(),
+  threshold: 2,
+  signingOperators: getLocalSigningOperators(),
+  tokenSignatures: "SCHNORR",
+  tokenValidityDurationSeconds: 180,
+  electrsUrl: getElectrsUrl("LOCAL"),
+  expectedWithdrawBondSats: 1e4,
+  expectedWithdrawRelativeBlockLocktime: 1e3,
+  sspClientOptions: {
+    baseUrl: getSspUrl("LOCAL"),
+    identityPublicKey: getSspIdentityPublicKey("LOCAL"),
+    schemaEndpoint: getSspSchemaEndpoint("LOCAL")
+  },
+  signerWithPreExistingKeys: false,
+  console: {
+    otel: false
   }
-  for (const point of points) {
-    if (point.index === index) {
-      continue;
-    }
-    numerator = numerator * point.index;
-    const value = point.index - index;
-    denominator = denominator * value;
+};
+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",
+  signingOperators: getSigningOperators(),
+  electrsUrl: getElectrsUrl("REGTEST"),
+  expectedWithdrawBondSats: 1e4,
+  expectedWithdrawRelativeBlockLocktime: 1e3,
+  sspClientOptions: {
+    baseUrl: getSspUrl("REGTEST"),
+    identityPublicKey: getSspIdentityPublicKey("REGTEST")
   }
-  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] = import_secp256k12.secp256k1.Point.fromPrivateKey(secret).toBytes(true);
-  for (let i = 1; i < degree; i++) {
-    const coefficient = getRandomBigInt(fieldModulus);
-    coefficients[i] = coefficient;
-    proofs[i] = import_secp256k12.secp256k1.Point.fromPrivateKey(coefficient).toBytes(true);
+};
+var MAINNET_WALLET_CONFIG = {
+  ...BASE_CONFIG,
+  network: "MAINNET",
+  signingOperators: getSigningOperators(),
+  electrsUrl: getElectrsUrl("MAINNET"),
+  expectedWithdrawBondSats: 1e4,
+  expectedWithdrawRelativeBlockLocktime: 1e3,
+  sspClientOptions: {
+    baseUrl: getSspUrl("MAINNET"),
+    identityPublicKey: getSspIdentityPublicKey("MAINNET")
   }
+};
+var WalletConfig = {
+  LOCAL: LOCAL_WALLET_CONFIG,
+  LOCAL_SCHNORR: LOCAL_WALLET_CONFIG_SCHNORR,
+  LOCAL_ECDSA: LOCAL_WALLET_CONFIG_ECDSA,
+  REGTEST: REGTEST_WALLET_CONFIG,
+  MAINNET: MAINNET_WALLET_CONFIG
+};
+function getSigningOperators() {
   return {
-    fieldModulus,
-    coefficients,
-    proofs
+    "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 splitSecret(fieldModulus, secret, threshold, numberOfShares) {
-  const polynomial = generatePolynomialForSecretSharing(
-    fieldModulus,
-    secret,
-    threshold
+function getLocalSigningOperators() {
+  const addresses = Array.from(
+    { length: 5 },
+    (_, i) => isHermeticTest ? `https://${i}.spark.minikube.local` : `https://localhost:${i + 8535}`
   );
-  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 = import_secp256k12.secp256k1.Point.fromPrivateKey(share.share).toBytes(
-    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 = import_secp256k12.secp256k1.Point.fromHex(pubkey).multiply(value);
-    resultPubkey = import_secp256k12.secp256k1.Point.fromHex(resultPubkey).add(scaledPoint).toBytes(true);
-  }
-  if (!(0, import_utils3.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 bytes2 = new Uint8Array(32);
-  for (let i = 0; i < 32; i++) {
-    bytes2[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes2;
-}
-
-// src/utils/signing.ts
-init_buffer();
-var import_secp256k13 = require("@noble/curves/secp256k1");
-function getRandomSigningNonce() {
-  const binding = import_secp256k13.secp256k1.utils.randomPrivateKey();
-  const hiding = import_secp256k13.secp256k1.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 = import_secp256k13.secp256k1.getPublicKey(nonce.binding, true);
-  const hidingPubKey = import_secp256k13.secp256k1.getPublicKey(nonce.hiding, true);
-  return {
-    binding: bindingPubKey,
-    hiding: hidingPubKey
-  };
-}
-function encodeSigningNonceToBytes(nonce) {
-  return new Uint8Array([...nonce.binding, ...nonce.hiding]);
-}
-function decodeBytesToSigningNonce(bytes2) {
-  if (bytes2.length !== 64) {
-    throw new ValidationError("Invalid nonce length", {
-      field: "bytes",
-      value: bytes2.length,
-      expected: "64 bytes (32 bytes for binding + 32 bytes for hiding)"
-    });
-  }
-  return {
-    binding: bytes2.slice(32, 64),
-    hiding: bytes2.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(bytes2) {
-  if (bytes2.length !== 66) {
-    throw new ValidationError("Invalid nonce commitment length", {
-      field: "bytes",
-      value: bytes2.length,
-      expected: "66 bytes (33 bytes for binding + 33 bytes for hiding)"
-    });
-  }
+  const pubkeys = [
+    "0322ca18fc489ae25418a0e768273c2c61cabb823edfb14feb891e9bec62016510",
+    "0341727a6c41b168f07eb50865ab8c397a53c7eef628ac1020956b705e43b6cb27",
+    "0305ab8d485cc752394de4981f8a5ae004f2becfea6f432c9a59d5022d8764f0a6",
+    "0352aef4d49439dedd798ac4aef1e7ebef95f569545b647a25338398c1247ffdea",
+    "02c05c88cc8fc181b1ba30006df6a4b0597de6490e24514fbdd0266d2b9cd3d0ba"
+  ];
   return {
-    binding: bytes2.slice(33, 66),
-    hiding: bytes2.slice(0, 33)
+    "0000000000000000000000000000000000000000000000000000000000000001": {
+      id: 0,
+      identifier: "0000000000000000000000000000000000000000000000000000000000000001",
+      address: addresses[0],
+      identityPublicKey: pubkeys[0]
+    },
+    "0000000000000000000000000000000000000000000000000000000000000002": {
+      id: 1,
+      identifier: "0000000000000000000000000000000000000000000000000000000000000002",
+      address: addresses[1],
+      identityPublicKey: pubkeys[1]
+    },
+    "0000000000000000000000000000000000000000000000000000000000000003": {
+      id: 2,
+      identifier: "0000000000000000000000000000000000000000000000000000000000000003",
+      address: addresses[2],
+      identityPublicKey: pubkeys[2]
+    },
+    "0000000000000000000000000000000000000000000000000000000000000004": {
+      id: 3,
+      identifier: "0000000000000000000000000000000000000000000000000000000000000004",
+      address: addresses[3],
+      identityPublicKey: pubkeys[3]
+    },
+    "0000000000000000000000000000000000000000000000000000000000000005": {
+      id: 4,
+      identifier: "0000000000000000000000000000000000000000000000000000000000000005",
+      address: addresses[4],
+      identityPublicKey: pubkeys[4]
+    }
   };
 }
 
-// src/signer/types.ts
-init_buffer();
-
-// src/signer/signer.ts
-var sparkFrostModule = void 0;
-var getSparkFrostModule = async () => {
-  if (isReactNative) {
-    return void 0;
-  }
-  if (!sparkFrostModule) {
-    sparkFrostModule = await Promise.resolve().then(() => (init_wasm(), wasm_exports));
+// src/services/config.ts
+var WalletConfigService = class {
+  config;
+  signer;
+  sspClientOptions;
+  constructor(options = {}, signer) {
+    const network = options?.network ?? "REGTEST";
+    this.config = {
+      ...this.getDefaultConfig(Network2[network]),
+      ...options
+    };
+    this.signer = signer;
+    this.sspClientOptions = this.config.sspClientOptions;
   }
-  return sparkFrostModule;
-};
-var HARDENED_OFFSET = 2147483648;
-var DefaultSparkKeysGenerator = class {
-  async deriveKeysFromSeed(seed, accountNumber) {
-    const hdkey = import_bip32.HDKey.fromMasterSeed(seed);
-    if (!hdkey.privateKey || !hdkey.publicKey) {
-      throw new ValidationError("Failed to derive keys from seed", {
-        field: "hdkey",
-        value: seed
-      });
+  getDefaultConfig(network) {
+    switch (network) {
+      case 0 /* MAINNET */:
+        return WalletConfig.MAINNET;
+      case 3 /* REGTEST */:
+        return WalletConfig.REGTEST;
+      default:
+        return WalletConfig.LOCAL;
     }
-    const identityKey = hdkey.derive(`m/8797555'/${accountNumber}'/0'`);
-    const signingKey = hdkey.derive(`m/8797555'/${accountNumber}'/1'`);
-    const depositKey = hdkey.derive(`m/8797555'/${accountNumber}'/2'`);
-    const staticDepositKey = hdkey.derive(`m/8797555'/${accountNumber}'/3'`);
-    if (!identityKey.privateKey || !depositKey.privateKey || !signingKey.privateKey || !identityKey.publicKey || !depositKey.publicKey || !signingKey.publicKey || !staticDepositKey.privateKey || !staticDepositKey.publicKey) {
-      throw new ValidationError(
-        "Failed to derive all required keys from seed",
+  }
+  getCoordinatorAddress() {
+    const coordinator = this.config.signingOperators[this.config.coordinatorIdentifier];
+    if (!coordinator) {
+      throw new ConfigurationError(
+        "Coordinator not found in signing operators",
         {
-          field: "derivedKeys"
+          configKey: "signingOperators"
         }
       );
     }
-    return {
-      identityKey: {
-        privateKey: identityKey.privateKey,
-        publicKey: identityKey.publicKey
-      },
-      signingHDKey: {
-        hdKey: signingKey,
-        privateKey: signingKey.privateKey,
-        publicKey: signingKey.publicKey
-      },
-      depositKey: {
-        privateKey: depositKey.privateKey,
-        publicKey: depositKey.publicKey
-      },
-      staticDepositHDKey: {
-        hdKey: staticDepositKey,
-        privateKey: staticDepositKey.privateKey,
-        publicKey: staticDepositKey.publicKey
-      }
-    };
+    return coordinator.address;
   }
-};
-var DefaultSparkSigner = class {
-  identityKey = null;
-  signingKey = null;
-  depositKey = null;
-  staticDepositKey = null;
-  commitmentToNonceMap = /* @__PURE__ */ new Map();
-  keysGenerator;
-  constructor({
-    sparkKeysGenerator
-  } = {}) {
-    this.keysGenerator = sparkKeysGenerator ?? new DefaultSparkKeysGenerator();
+  getSigningOperators() {
+    return this.config.signingOperators;
   }
-  deriveSigningKey(hash) {
-    if (!this.signingKey) {
-      throw new ValidationError("Private key not initialized", {
-        field: "signingKey"
-      });
-    }
-    const view = new DataView(hash.buffer);
-    const amount = view.getUint32(0, false) % HARDENED_OFFSET + HARDENED_OFFSET;
-    const newPrivateKey = this.signingKey?.deriveChild(amount).privateKey;
-    if (!newPrivateKey) {
-      throw new ValidationError("Failed to recover signing key", {
-        field: "privateKey"
-      });
-    }
-    return newPrivateKey;
+  getThreshold() {
+    return this.config.threshold;
   }
-  async decryptEciesToPrivateKey(ciphertext) {
-    if (!this.identityKey?.privateKey) {
-      throw new ConfigurationError("Identity key not initialized", {
-        configKey: "identityKey"
-      });
-    }
-    const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils5.bytesToHex)(this.identityKey.privateKey)
-    );
-    const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
-    return privateKey;
+  getCoordinatorIdentifier() {
+    return this.config.coordinatorIdentifier;
   }
-  async getSigningPrivateKeyFromDerivation(keyDerivation) {
-    switch (keyDerivation.type) {
-      case "leaf" /* LEAF */:
-        return this.deriveSigningKey((0, import_sha22.sha256)(keyDerivation.path));
-      case "deposit" /* DEPOSIT */:
-        return this.depositKey?.privateKey ?? new Uint8Array();
-      case "static_deposit" /* STATIC_DEPOSIT */:
-        return this.getStaticDepositSecretKey(keyDerivation.path);
-      case "ecies" /* ECIES */:
-        return this.decryptEciesToPrivateKey(keyDerivation.path);
-      case "random" /* RANDOM */:
-        return import_secp256k15.secp256k1.utils.randomPrivateKey();
-    }
+  getExpectedWithdrawBondSats() {
+    return this.config.expectedWithdrawBondSats;
   }
-  async signSchnorrWithIdentityKey(message) {
-    if (!this.identityKey?.privateKey) {
-      throw new ValidationError("Private key not set", {
-        field: "identityKey"
-      });
-    }
-    const signature = import_secp256k15.schnorr.sign(message, this.identityKey.privateKey);
-    return signature;
+  getExpectedWithdrawRelativeBlockLocktime() {
+    return this.config.expectedWithdrawRelativeBlockLocktime;
   }
-  async getIdentityPublicKey() {
-    if (!this.identityKey?.publicKey) {
-      throw new ValidationError("Private key is not set", {
-        field: "identityKey"
-      });
+  getSspNetwork() {
+    if (this.config.network === "MAINNET") {
+      return "MAINNET" /* MAINNET */;
+    } else if (this.config.network === "REGTEST") {
+      return "REGTEST" /* REGTEST */;
+    } else if (this.config.network === "TESTNET") {
+      return "TESTNET" /* TESTNET */;
+    } else if (this.config.network === "SIGNET") {
+      return "SIGNET" /* SIGNET */;
     }
-    return this.identityKey.publicKey;
+    return "FUTURE_VALUE" /* FUTURE_VALUE */;
   }
-  async getDepositSigningKey() {
-    if (!this.depositKey?.publicKey) {
-      throw new ValidationError("Deposit key is not set", {
-        field: "depositKey"
-      });
-    }
-    return this.depositKey.publicKey;
+  getNetwork() {
+    return Network2[this.config.network];
   }
-  async getStaticDepositSigningKey(idx) {
-    const staticDepositKey = await this.getStaticDepositSecretKey(idx);
-    return import_secp256k15.secp256k1.getPublicKey(staticDepositKey);
+  getNetworkType() {
+    return this.config.network;
   }
-  async getStaticDepositSecretKey(idx) {
-    if (!this.staticDepositKey) {
-      throw new ValidationError("Static deposit key is not set", {
-        field: "staticDepositKey"
-      });
-    }
-    const staticDepositKey = this.staticDepositKey.deriveChild(
-      HARDENED_OFFSET + idx
-    );
-    if (!staticDepositKey?.privateKey) {
-      throw new ValidationError("Static deposit key is not set", {
-        field: "staticDepositKey"
-      });
-    }
-    return staticDepositKey.privateKey;
+  getNetworkProto() {
+    return NetworkToProto[Network2[this.config.network]];
   }
-  async generateMnemonic() {
-    return (0, import_bip39.generateMnemonic)(import_english.wordlist);
+  getTokenSignatures() {
+    return this.config.tokenSignatures;
   }
-  async mnemonicToSeed(mnemonic) {
-    return await (0, import_bip39.mnemonicToSeed)(mnemonic);
+  getTokenValidityDurationSeconds() {
+    return this.config.tokenValidityDurationSeconds;
   }
-  async getPublicKeyFromDerivation(keyDerivation) {
-    const privateKey = await this.getSigningPrivateKeyFromDerivation(keyDerivation);
-    return import_secp256k15.secp256k1.getPublicKey(privateKey);
+  getElectrsUrl() {
+    return this.config.electrsUrl;
   }
-  async subtractPrivateKeysGivenDerivationPaths(first, second) {
-    const firstPrivateKey = this.deriveSigningKey((0, import_sha22.sha256)(first));
-    const secondPrivateKey = this.deriveSigningKey((0, import_sha22.sha256)(second));
-    const resultPrivKey = subtractPrivateKeys(
-      firstPrivateKey,
-      secondPrivateKey
-    );
-    const resultPubKey = import_secp256k15.secp256k1.getPublicKey(resultPrivKey);
-    return resultPubKey;
+  getSspBaseUrl() {
+    return this.config.sspClientOptions.baseUrl;
   }
-  async subtractAndSplitSecretWithProofsGivenDerivations({
-    first,
-    second,
-    curveOrder,
-    threshold,
-    numShares
-  }) {
-    const firstPrivateKey = await this.getSigningPrivateKeyFromDerivation(first);
-    const secondPrivateKey = await this.getSigningPrivateKeyFromDerivation(second);
-    const resultPrivKey = subtractPrivateKeys(
-      firstPrivateKey,
-      secondPrivateKey
-    );
-    return await this.splitSecretWithProofs({
-      secret: resultPrivKey,
-      curveOrder,
-      threshold,
-      numShares
-    });
+  getSspIdentityPublicKey() {
+    return this.config.sspClientOptions.identityPublicKey;
   }
-  async subtractSplitAndEncrypt({
-    first,
-    second,
-    curveOrder,
-    threshold,
-    numShares,
-    receiverPublicKey
-  }) {
-    const firstPrivateKey = await this.getSigningPrivateKeyFromDerivation(first);
-    const secondPrivateKey = await this.getSigningPrivateKeyFromDerivation(second);
-    const resultPrivKey = subtractPrivateKeys(
-      firstPrivateKey,
-      secondPrivateKey
-    );
+  getConsoleOptions() {
     return {
-      shares: await this.splitSecretWithProofs({
-        secret: resultPrivKey,
-        curveOrder,
-        threshold,
-        numShares
-      }),
-      secretCipher: ecies.encrypt(receiverPublicKey, secondPrivateKey)
+      ...this.config.console
     };
   }
-  async splitSecretWithProofs({
-    secret,
-    curveOrder,
-    threshold,
-    numShares
-  }) {
-    const secretAsInt = (0, import_utils5.bytesToNumberBE)(secret);
-    return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
-  }
-  async signFrost({
-    message,
-    keyDerivation,
-    publicKey,
-    verifyingKey,
-    selfCommitment,
-    statechainCommitments,
-    adaptorPubKey
-  }) {
-    const SparkFrost = await getSparkFrostModule();
-    if (!SparkFrost) {
-      throw new ValidationError("SparkFrost module not found", {
-        field: "SparkFrost"
-      });
+};
+
+// src/services/connection/connection.ts
+init_buffer();
+var import_core10 = require("@lightsparkdev/core");
+var import_sha22 = require("@noble/hashes/sha2");
+
+// src/proto/spark_authn.ts
+init_buffer();
+var import_wire5 = require("@bufbuild/protobuf/wire");
+function createBaseChallenge() {
+  return { version: 0, timestamp: 0, nonce: new Uint8Array(0), publicKey: new Uint8Array(0) };
+}
+var Challenge = {
+  encode(message, writer = new import_wire5.BinaryWriter()) {
+    if (message.version !== 0) {
+      writer.uint32(8).int32(message.version);
     }
-    const signingPrivateKey = await this.getSigningPrivateKeyFromDerivation(keyDerivation);
-    if (!signingPrivateKey) {
-      throw new ValidationError("Private key not found for public key", {
-        field: "privateKey"
-      });
+    if (message.timestamp !== 0) {
+      writer.uint32(16).int64(message.timestamp);
     }
-    const commitment = selfCommitment.commitment;
-    const nonce = this.commitmentToNonceMap.get(commitment);
-    if (!nonce) {
-      throw new ValidationError("Nonce not found for commitment", {
-        field: "nonce"
-      });
-    }
-    const keyPackage = {
-      secretKey: signingPrivateKey,
-      publicKey,
-      verifyingKey
-    };
-    const logMessage = (0, import_utils5.bytesToHex)(message);
-    const result = await SparkFrost.signFrost({
-      message,
-      keyPackage,
-      nonce,
-      selfCommitment: commitment,
-      statechainCommitments,
-      adaptorPubKey
-    });
-    return result;
-  }
-  async aggregateFrost({
-    message,
-    publicKey,
-    verifyingKey,
-    selfCommitment,
-    statechainCommitments,
-    adaptorPubKey,
-    selfSignature,
-    statechainSignatures,
-    statechainPublicKeys
-  }) {
-    const SparkFrost = await getSparkFrostModule();
-    if (!SparkFrost) {
-      throw new ValidationError("SparkFrost module not found", {
-        field: "SparkFrost"
-      });
-    }
-    return SparkFrost.aggregateFrost({
-      message,
-      statechainSignatures,
-      statechainPublicKeys,
-      verifyingKey,
-      statechainCommitments,
-      selfCommitment: selfCommitment.commitment,
-      selfPublicKey: publicKey,
-      selfSignature,
-      adaptorPubKey
-    });
-  }
-  async createSparkWalletFromSeed(seed, accountNumber) {
-    if (typeof seed === "string") {
-      seed = (0, import_utils5.hexToBytes)(seed);
-    }
-    const {
-      identityKey,
-      signingHDKey: signingKey,
-      depositKey,
-      staticDepositHDKey: staticDepositKey
-    } = await this.keysGenerator.deriveKeysFromSeed(seed, accountNumber ?? 0);
-    this.identityKey = identityKey;
-    this.depositKey = depositKey;
-    this.signingKey = signingKey.hdKey;
-    this.staticDepositKey = staticDepositKey.hdKey;
-    return (0, import_utils5.bytesToHex)(identityKey.publicKey);
-  }
-  async signMessageWithIdentityKey(message, compact) {
-    if (!this.identityKey?.privateKey) {
-      throw new ConfigurationError("Identity key not initialized", {
-        configKey: "identityKey"
-      });
-    }
-    const signature = import_secp256k15.secp256k1.sign(message, this.identityKey.privateKey);
-    if (compact) {
-      return signature.toCompactRawBytes();
-    }
-    return signature.toDERRawBytes();
-  }
-  async decryptEcies(ciphertext) {
-    if (!this.identityKey?.privateKey) {
-      throw new ConfigurationError("Identity key not initialized", {
-        configKey: "identityKey"
-      });
-    }
-    const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils5.bytesToHex)(this.identityKey.privateKey)
-    );
-    const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
-    const publicKey = import_secp256k15.secp256k1.getPublicKey(privateKey);
-    return publicKey;
-  }
-  async getRandomSigningCommitment() {
-    const nonce = getRandomSigningNonce();
-    const commitment = getSigningCommitmentFromNonce(nonce);
-    this.commitmentToNonceMap.set(commitment, nonce);
-    return {
-      commitment
-    };
-  }
-  async validateMessageWithIdentityKey(message, signature) {
-    if (!this.identityKey?.publicKey) {
-      throw new ConfigurationError("Identity key not initialized", {
-        configKey: "identityKey"
-      });
-    }
-    return import_secp256k15.secp256k1.verify(signature, message, this.identityKey.publicKey);
-  }
-  signTransactionIndex(tx, index, publicKey) {
-    let privateKey;
-    if ((0, import_utils5.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
-      privateKey = this.identityKey?.privateKey;
-    } else if ((0, import_utils5.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
-      privateKey = this.depositKey?.privateKey;
-    }
-    if (!privateKey) {
-      throw new ValidationError("Private key not found for public key", {
-        field: "privateKey",
-        value: (0, import_utils5.bytesToHex)(publicKey)
-      });
-    }
-    tx.signIdx(privateKey, index);
-  }
-};
-
-// src/utils/network.ts
-init_buffer();
-var btc = __toESM(require("@scure/btc-signer"), 1);
-var import_base2 = require("@scure/base");
-var Network2 = /* @__PURE__ */ ((Network5) => {
-  Network5[Network5["MAINNET"] = 0] = "MAINNET";
-  Network5[Network5["TESTNET"] = 1] = "TESTNET";
-  Network5[Network5["SIGNET"] = 2] = "SIGNET";
-  Network5[Network5["REGTEST"] = 3] = "REGTEST";
-  Network5[Network5["LOCAL"] = 4] = "LOCAL";
-  return Network5;
-})(Network2 || {});
-var NetworkToProto = {
-  [0 /* MAINNET */]: 1 /* MAINNET */,
-  [1 /* TESTNET */]: 3 /* TESTNET */,
-  [2 /* SIGNET */]: 4 /* SIGNET */,
-  [3 /* REGTEST */]: 2 /* REGTEST */,
-  [4 /* LOCAL */]: 2 /* REGTEST */
-};
-var protoToNetwork = (protoNetwork) => {
-  switch (protoNetwork) {
-    case 1 /* MAINNET */:
-      return 0 /* MAINNET */;
-    case 3 /* TESTNET */:
-      return 1 /* TESTNET */;
-    case 4 /* SIGNET */:
-      return 2 /* SIGNET */;
-    case 2 /* REGTEST */:
-      return 3 /* REGTEST */;
-    default:
-      return void 0;
-  }
-};
-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" }
-};
-var getNetwork = (network) => NetworkConfig[network];
-function getNetworkFromAddress(address) {
-  try {
-    const bechAddress = address;
-    const decoded = (() => {
-      try {
-        return import_base2.bech32.decode(bechAddress);
-      } catch (_) {
-        return import_base2.bech32m.decode(bechAddress);
-      }
-    })();
-    if (decoded.prefix === "bc") {
-      return "MAINNET" /* MAINNET */;
-    } else if (decoded.prefix === "bcrt") {
-      return "REGTEST" /* REGTEST */;
-    }
-  } catch (err) {
-    throw new ValidationError(
-      "Invalid Bitcoin address",
-      {
-        field: "address",
-        value: address,
-        expected: "Valid Bech32 address with prefix 'bc' or 'bcrt'"
-      },
-      err instanceof Error ? err : void 0
-    );
-  }
-  return null;
-}
-function getNetworkFromString(network) {
-  const net = (network ?? "REGTEST").toUpperCase();
-  if (net === "MAINNET") return 0 /* MAINNET */;
-  if (net === "TESTNET") return 1 /* TESTNET */;
-  if (net === "SIGNET") return 2 /* SIGNET */;
-  if (net === "LOCAL") return 4 /* LOCAL */;
-  return 3 /* REGTEST */;
-}
-
-// src/services/wallet-config.ts
-init_buffer();
-
-// src/tests/isHermeticTest.ts
-init_buffer();
-var isHermeticTest = Boolean(
-  typeof process !== "undefined" && process?.env?.HERMETIC_TEST === "true"
-);
-
-// 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"
-  },
-  REGTEST: {
-    PROD: {
-      SSP: "https://api.lightspark.com",
-      ELECTRS: "https://regtest-mempool.us-west-2.sparkinfra.net/api"
-    }
-  },
-  MAINNET: {
-    PROD: {
-      SSP: "https://api.lightspark.com",
-      ELECTRS: "https://mempool.space/api"
-    }
-  }
-};
-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 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",
-  coordinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
-  frostSignerAddress: getLocalFrostSignerAddress(),
-  threshold: 2,
-  signingOperators: getLocalSigningOperators(),
-  tokenSignatures: "SCHNORR",
-  tokenValidityDurationSeconds: 180,
-  electrsUrl: getElectrsUrl("LOCAL"),
-  expectedWithdrawBondSats: 1e4,
-  expectedWithdrawRelativeBlockLocktime: 1e3,
-  sspClientOptions: {
-    baseUrl: getSspUrl("LOCAL"),
-    identityPublicKey: getSspIdentityPublicKey("LOCAL"),
-    schemaEndpoint: getSspSchemaEndpoint("LOCAL")
-  },
-  signerWithPreExistingKeys: false,
-  console: {
-    otel: false
-  }
-};
-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",
-  signingOperators: getSigningOperators(),
-  electrsUrl: getElectrsUrl("REGTEST"),
-  expectedWithdrawBondSats: 1e4,
-  expectedWithdrawRelativeBlockLocktime: 1e3,
-  sspClientOptions: {
-    baseUrl: getSspUrl("REGTEST"),
-    identityPublicKey: getSspIdentityPublicKey("REGTEST")
-  }
-};
-var MAINNET_WALLET_CONFIG = {
-  ...BASE_CONFIG,
-  network: "MAINNET",
-  signingOperators: getSigningOperators(),
-  electrsUrl: getElectrsUrl("MAINNET"),
-  expectedWithdrawBondSats: 1e4,
-  expectedWithdrawRelativeBlockLocktime: 1e3,
-  sspClientOptions: {
-    baseUrl: getSspUrl("MAINNET"),
-    identityPublicKey: getSspIdentityPublicKey("MAINNET")
-  }
-};
-var WalletConfig = {
-  LOCAL: LOCAL_WALLET_CONFIG,
-  LOCAL_SCHNORR: LOCAL_WALLET_CONFIG_SCHNORR,
-  LOCAL_ECDSA: LOCAL_WALLET_CONFIG_ECDSA,
-  REGTEST: REGTEST_WALLET_CONFIG,
-  MAINNET: MAINNET_WALLET_CONFIG
-};
-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 addresses = Array.from(
-    { length: 5 },
-    (_, i) => isHermeticTest ? `https://${i}.spark.minikube.local` : `https://localhost:${i + 8535}`
-  );
-  const pubkeys = [
-    "0322ca18fc489ae25418a0e768273c2c61cabb823edfb14feb891e9bec62016510",
-    "0341727a6c41b168f07eb50865ab8c397a53c7eef628ac1020956b705e43b6cb27",
-    "0305ab8d485cc752394de4981f8a5ae004f2becfea6f432c9a59d5022d8764f0a6",
-    "0352aef4d49439dedd798ac4aef1e7ebef95f569545b647a25338398c1247ffdea",
-    "02c05c88cc8fc181b1ba30006df6a4b0597de6490e24514fbdd0266d2b9cd3d0ba"
-  ];
-  return {
-    "0000000000000000000000000000000000000000000000000000000000000001": {
-      id: 0,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000001",
-      address: addresses[0],
-      identityPublicKey: pubkeys[0]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000002": {
-      id: 1,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000002",
-      address: addresses[1],
-      identityPublicKey: pubkeys[1]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000003": {
-      id: 2,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000003",
-      address: addresses[2],
-      identityPublicKey: pubkeys[2]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000004": {
-      id: 3,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000004",
-      address: addresses[3],
-      identityPublicKey: pubkeys[3]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000005": {
-      id: 4,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000005",
-      address: addresses[4],
-      identityPublicKey: pubkeys[4]
-    }
-  };
-}
-
-// src/services/config.ts
-var WalletConfigService = class {
-  config;
-  signer;
-  sspClientOptions;
-  constructor(options, signer) {
-    const network = options?.network ?? "REGTEST";
-    this.config = {
-      ...this.getDefaultConfig(Network2[network]),
-      ...options
-    };
-    this.signer = signer ?? new DefaultSparkSigner();
-    this.sspClientOptions = this.config.sspClientOptions;
-  }
-  getDefaultConfig(network) {
-    switch (network) {
-      case 0 /* MAINNET */:
-        return WalletConfig.MAINNET;
-      case 3 /* REGTEST */:
-        return WalletConfig.REGTEST;
-      default:
-        return WalletConfig.LOCAL;
-    }
-  }
-  getCoordinatorAddress() {
-    const coordinator = this.config.signingOperators[this.config.coordinatorIdentifier];
-    if (!coordinator) {
-      throw new ConfigurationError(
-        "Coordinator not found in signing operators",
-        {
-          configKey: "signingOperators"
-        }
-      );
-    }
-    return coordinator.address;
-  }
-  getSigningOperators() {
-    return this.config.signingOperators;
-  }
-  getThreshold() {
-    return this.config.threshold;
-  }
-  getCoordinatorIdentifier() {
-    return this.config.coordinatorIdentifier;
-  }
-  getExpectedWithdrawBondSats() {
-    return this.config.expectedWithdrawBondSats;
-  }
-  getExpectedWithdrawRelativeBlockLocktime() {
-    return this.config.expectedWithdrawRelativeBlockLocktime;
-  }
-  getSspNetwork() {
-    if (this.config.network === "MAINNET") {
-      return "MAINNET" /* MAINNET */;
-    } else if (this.config.network === "REGTEST") {
-      return "REGTEST" /* REGTEST */;
-    } else if (this.config.network === "TESTNET") {
-      return "TESTNET" /* TESTNET */;
-    } else if (this.config.network === "SIGNET") {
-      return "SIGNET" /* SIGNET */;
-    }
-    return "FUTURE_VALUE" /* FUTURE_VALUE */;
-  }
-  getNetwork() {
-    return Network2[this.config.network];
-  }
-  getNetworkType() {
-    return this.config.network;
-  }
-  getNetworkProto() {
-    return NetworkToProto[Network2[this.config.network]];
-  }
-  getTokenSignatures() {
-    return this.config.tokenSignatures;
-  }
-  getTokenValidityDurationSeconds() {
-    return this.config.tokenValidityDurationSeconds;
-  }
-  getElectrsUrl() {
-    return this.config.electrsUrl;
-  }
-  getSspBaseUrl() {
-    return this.config.sspClientOptions.baseUrl;
-  }
-  getSspIdentityPublicKey() {
-    return this.config.sspClientOptions.identityPublicKey;
-  }
-  getConsoleOptions() {
-    return {
-      ...this.config.console
-    };
-  }
-};
-
-// src/services/connection/connection.ts
-init_buffer();
-var import_core12 = require("@lightsparkdev/core");
-var import_sha23 = require("@noble/hashes/sha2");
-
-// src/proto/spark_authn.ts
-init_buffer();
-var import_wire5 = require("@bufbuild/protobuf/wire");
-function createBaseChallenge() {
-  return { version: 0, timestamp: 0, nonce: new Uint8Array(0), publicKey: new Uint8Array(0) };
-}
-var Challenge = {
-  encode(message, writer = new import_wire5.BinaryWriter()) {
-    if (message.version !== 0) {
-      writer.uint32(8).int32(message.version);
-    }
-    if (message.timestamp !== 0) {
-      writer.uint32(16).int64(message.timestamp);
-    }
-    if (message.nonce.length !== 0) {
-      writer.uint32(26).bytes(message.nonce);
+    if (message.nonce.length !== 0) {
+      writer.uint32(26).bytes(message.nonce);
     }
     if (message.publicKey.length !== 0) {
       writer.uint32(34).bytes(message.publicKey);
@@ -23751,7 +22931,7 @@ var ConnectionManager = class {
           const challengeBytes = Challenge.encode(
             challengeResp.protectedChallenge.challenge
           ).finish();
-          const hash = (0, import_sha23.sha256)(challengeBytes);
+          const hash = (0, import_sha22.sha256)(challengeBytes);
           const derSignatureBytes = await this.config.signer.signMessageWithIdentityKey(hash);
           const verifyResp = await sparkAuthnClient.verify_challenge({
             protectedChallenge: challengeResp.protectedChallenge,
@@ -23761,7 +22941,7 @@ var ConnectionManager = class {
           sparkAuthnClient.close?.();
           return verifyResp.sessionToken;
         } catch (error) {
-          if ((0, import_core12.isError)(error)) {
+          if ((0, import_core10.isError)(error)) {
             sparkAuthnClient?.close?.();
             if (error.message.includes("challenge expired")) {
               console.warn(
@@ -23770,6 +22950,13 @@ var ConnectionManager = class {
               lastError = error;
               continue;
             }
+            if (error.message.includes("UNAVAILABLE: No connection established.")) {
+              console.warn(
+                `Authentication attempt ${attempt + 1} failed due to unavailable status, retrying...`
+              );
+              lastError = error;
+              continue;
+            }
             throw new AuthenticationError(
               "Authentication failed",
               {
@@ -23820,7 +23007,7 @@ var ConnectionManager = class {
     return void 0;
   }
   async *handleMiddlewareError(error, address, call, metadata, options) {
-    if ((0, import_core12.isError)(error)) {
+    if ((0, import_core10.isError)(error)) {
       if (error.message.includes("token has expired")) {
         const newAuthToken = await this.authenticate(address);
         const clientData = this.clients.get(address);
@@ -23848,9 +23035,9 @@ var import_uuidv72 = require("uuidv7");
 
 // src/utils/bitcoin.ts
 init_buffer();
-var import_secp256k16 = require("@noble/curves/secp256k1");
-var import_utils7 = require("@noble/curves/utils");
-var import_sha24 = require("@noble/hashes/sha2");
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_utils2 = require("@noble/curves/utils");
+var import_sha23 = require("@noble/hashes/sha2");
 var btc2 = __toESM(require("@scure/btc-signer"), 1);
 function computeTaprootKeyNoScript(pubkey) {
   if (pubkey.length !== 32) {
@@ -23860,10 +23047,10 @@ function computeTaprootKeyNoScript(pubkey) {
       expected: 32
     });
   }
-  const taggedHash = import_secp256k16.schnorr.utils.taggedHash("TapTweak", pubkey);
-  const tweak = (0, import_utils7.bytesToNumberBE)(taggedHash);
-  const P = import_secp256k16.schnorr.utils.lift_x(import_secp256k16.schnorr.utils.bytesToNumberBE(pubkey));
-  const Q = P.add(import_secp256k16.secp256k1.Point.fromPrivateKey(tweak));
+  const taggedHash = import_secp256k1.schnorr.utils.taggedHash("TapTweak", pubkey);
+  const tweak = (0, import_utils2.bytesToNumberBE)(taggedHash);
+  const P = import_secp256k1.schnorr.utils.lift_x(import_secp256k1.schnorr.utils.bytesToNumberBE(pubkey));
+  const Q = P.add(import_secp256k1.secp256k1.Point.fromPrivateKey(tweak));
   return Q.toBytes();
 }
 function getP2TRScriptFromPublicKey(pubKey, network) {
@@ -23874,7 +23061,7 @@ function getP2TRScriptFromPublicKey(pubKey, network) {
       expected: 33
     });
   }
-  const internalKey = import_secp256k16.secp256k1.Point.fromHex(pubKey);
+  const internalKey = import_secp256k1.secp256k1.Point.fromHex(pubKey);
   const script = btc2.p2tr(
     internalKey.toBytes().slice(1, 33),
     void 0,
@@ -23896,7 +23083,7 @@ function getP2TRAddressFromPublicKey(pubKey, network) {
       expected: 33
     });
   }
-  const internalKey = import_secp256k16.secp256k1.Point.fromHex(pubKey);
+  const internalKey = import_secp256k1.secp256k1.Point.fromHex(pubKey);
   const address = btc2.p2tr(
     internalKey.toBytes().slice(1, 33),
     void 0,
@@ -23914,7 +23101,7 @@ function getP2TRAddressFromPkScript(pkScript, network) {
   if (pkScript.length !== 34 || pkScript[0] !== 81 || pkScript[1] !== 32) {
     throw new ValidationError("Invalid pkscript", {
       field: "pkScript",
-      value: (0, import_utils7.bytesToHex)(pkScript),
+      value: (0, import_utils2.bytesToHex)(pkScript),
       expected: "34 bytes starting with 0x51 0x20"
     });
   }
@@ -23939,7 +23126,7 @@ function getP2WPKHAddressFromPublicKey(pubKey, network) {
   return address;
 }
 function getTxFromRawTxHex(rawTxHex) {
-  const txBytes = (0, import_utils7.hexToBytes)(rawTxHex);
+  const txBytes = (0, import_utils2.hexToBytes)(rawTxHex);
   const tx = btc2.Transaction.fromRaw(txBytes, {
     allowUnknownOutputs: true
   });
@@ -23986,10 +23173,10 @@ function getSigHashFromTx(tx, inputIndex, prevOutput) {
   );
 }
 function getTxId(tx) {
-  return (0, import_utils7.bytesToHex)((0, import_sha24.sha256)((0, import_sha24.sha256)(tx.toBytes(true))).reverse());
+  return (0, import_utils2.bytesToHex)((0, import_sha23.sha256)((0, import_sha23.sha256)(tx.toBytes(true))).reverse());
 }
 function getTxIdNoReverse(tx) {
-  return (0, import_utils7.bytesToHex)((0, import_sha24.sha256)((0, import_sha24.sha256)(tx.toBytes(true))));
+  return (0, import_utils2.bytesToHex)((0, import_sha23.sha256)((0, import_sha23.sha256)(tx.toBytes(true))));
 }
 function getTxEstimatedVbytesSizeByNumberOfInputsOutputs(numInputs, numOutputs) {
   const TX_OVERHEAD = 10;
@@ -24337,17 +23524,20 @@ function getEphemeralAnchorOutput() {
 
 // src/services/transfer.ts
 init_buffer();
-var import_secp256k17 = require("@noble/curves/secp256k1");
-var import_utils9 = require("@noble/curves/utils");
-var import_sha26 = require("@noble/hashes/sha2");
+var import_secp256k12 = require("@noble/curves/secp256k1");
+var import_utils4 = require("@noble/curves/utils");
+var import_sha25 = require("@noble/hashes/sha2");
 var import_btc_signer2 = require("@scure/btc-signer");
-var ecies2 = __toESM(require("eciesjs"), 1);
+var ecies = __toESM(require("eciesjs"), 1);
 var import_uuidv7 = require("uuidv7");
 
+// src/signer/types.ts
+init_buffer();
+
 // src/utils/transfer_package.ts
 init_buffer();
-var import_utils8 = require("@noble/curves/utils");
-var import_sha25 = require("@noble/hashes/sha2");
+var import_utils3 = require("@noble/curves/utils");
+var import_sha24 = require("@noble/hashes/sha2");
 function getTransferPackageSigningPayload(transferID, transferPackage) {
   const encryptedPayload = transferPackage.keyTweakPackage;
   const pairs = Object.entries(
@@ -24355,7 +23545,7 @@ function getTransferPackageSigningPayload(transferID, transferPackage) {
   ).map(([key, value]) => ({ key, value }));
   pairs.sort((a, b) => a.key.localeCompare(b.key));
   const encoder = new TextEncoder();
-  let message = (0, import_utils8.hexToBytes)(transferID.replaceAll("-", ""));
+  let message = (0, import_utils3.hexToBytes)(transferID.replaceAll("-", ""));
   for (const pair of pairs) {
     const keyPart = encoder.encode(pair.key + ":");
     const separator = encoder.encode(";");
@@ -24366,7 +23556,7 @@ function getTransferPackageSigningPayload(transferID, transferPackage) {
       ...separator
     ]);
   }
-  return (0, import_sha25.sha256)(message);
+  return (0, import_sha24.sha256)(message);
 }
 
 // src/services/transfer.ts
@@ -24504,8 +23694,8 @@ var BaseTransferService = class {
       if (!operator) {
         throw new ValidationError("Operator not found");
       }
-      const soPublicKey = ecies2.PublicKey.fromHex(operator.identityPublicKey);
-      const encryptedProto = ecies2.encrypt(
+      const soPublicKey = ecies.PublicKey.fromHex(operator.identityPublicKey);
+      const encryptedProto = ecies.encrypt(
         soPublicKey.toBytes(),
         protoToEncryptBinary
       );
@@ -24636,8 +23826,8 @@ var BaseTransferService = class {
     return nodeSignatures;
   }
   async prepareSendTransferKeyTweaks(transferID, receiverIdentityPubkey, leaves, cpfpRefundSignatureMap, directRefundSignatureMap, directFromCpfpRefundSignatureMap) {
-    const receiverEciesPubKey = ecies2.PublicKey.fromHex(
-      (0, import_utils9.bytesToHex)(receiverIdentityPubkey)
+    const receiverEciesPubKey = ecies.PublicKey.fromHex(
+      (0, import_utils4.bytesToHex)(receiverIdentityPubkey)
     );
     const leavesTweaksMap = /* @__PURE__ */ new Map();
     for (const leaf of leaves) {
@@ -24667,7 +23857,7 @@ var BaseTransferService = class {
       first: leaf.keyDerivation,
       second: leaf.newKeyDerivation,
       receiverPublicKey: receiverEciesPubKey.toBytes(),
-      curveOrder: import_secp256k17.secp256k1.CURVE.n,
+      curveOrder: import_secp256k12.secp256k1.CURVE.n,
       threshold: this.config.getThreshold(),
       numShares: Object.keys(signingOperators).length
     });
@@ -24677,8 +23867,8 @@ var BaseTransferService = class {
       if (!share) {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
-      const pubkeyTweak = import_secp256k17.secp256k1.getPublicKey(
-        (0, import_utils9.numberToBytesBE)(share.share, 32),
+      const pubkeyTweak = import_secp256k12.secp256k1.getPublicKey(
+        (0, import_utils4.numberToBytesBE)(share.share, 32),
         true
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
@@ -24689,7 +23879,7 @@ var BaseTransferService = class {
       ...encoder.encode(transferID),
       ...secretCipher
     ]);
-    const payloadHash = (0, import_sha26.sha256)(payload);
+    const payloadHash = (0, import_sha25.sha256)(payload);
     const signature = await this.config.signer.signMessageWithIdentityKey(
       payloadHash,
       true
@@ -24703,7 +23893,7 @@ var BaseTransferService = class {
       leafTweaksMap.set(identifier, {
         leafId: leaf.leaf.id,
         secretShareTweak: {
-          secretShare: (0, import_utils9.numberToBytesBE)(share.share, 32),
+          secretShare: (0, import_utils4.numberToBytesBE)(share.share, 32),
           proofs: share.proofs
         },
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak),
@@ -24726,7 +23916,7 @@ var BaseTransferService = class {
     return void 0;
   }
   compareTransfers(transfer1, transfer2) {
-    return transfer1.id === transfer2.id && (0, import_utils9.equalBytes)(
+    return transfer1.id === transfer2.id && (0, import_utils4.equalBytes)(
       transfer1.senderIdentityPublicKey,
       transfer2.senderIdentityPublicKey
     ) && transfer1.status === transfer2.status && transfer1.totalValue === transfer2.totalValue && transfer1.expiryTime?.getTime() === transfer2.expiryTime?.getTime() && transfer1.leaves.length === transfer2.leaves.length;
@@ -24808,8 +23998,8 @@ var TransferService = class extends BaseTransferService {
         ...transferIdBytes,
         ...leaf.secretCipher
       ]);
-      const payloadHash = (0, import_sha26.sha256)(payload);
-      if (!import_secp256k17.secp256k1.verify(
+      const payloadHash = (0, import_sha25.sha256)(payload);
+      if (!import_secp256k12.secp256k1.verify(
         leaf.signature,
         payloadHash,
         transfer.senderIdentityPublicKey
@@ -24973,7 +24163,7 @@ var TransferService = class extends BaseTransferService {
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
       const cpfpNodeOutPoint = {
-        txid: (0, import_utils9.hexToBytes)(getTxId(nodeTx)),
+        txid: (0, import_utils4.hexToBytes)(getTxId(nodeTx)),
         index: 0
       };
       let directNodeTx;
@@ -24981,7 +24171,7 @@ var TransferService = class extends BaseTransferService {
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
         directNodeOutPoint = {
-          txid: (0, import_utils9.hexToBytes)(getTxId(directNodeTx)),
+          txid: (0, import_utils4.hexToBytes)(getTxId(directNodeTx)),
           index: 0
         };
       }
@@ -25103,7 +24293,7 @@ var TransferService = class extends BaseTransferService {
       {
         first: leaf.keyDerivation,
         second: leaf.newKeyDerivation,
-        curveOrder: import_secp256k17.secp256k1.CURVE.n,
+        curveOrder: import_secp256k12.secp256k1.CURVE.n,
         threshold: this.config.getThreshold(),
         numShares: Object.keys(signingOperators).length
       }
@@ -25114,8 +24304,8 @@ var TransferService = class extends BaseTransferService {
       if (!share) {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
-      const pubkeyTweak = import_secp256k17.secp256k1.getPublicKey(
-        (0, import_utils9.numberToBytesBE)(share.share, 32)
+      const pubkeyTweak = import_secp256k12.secp256k1.getPublicKey(
+        (0, import_utils4.numberToBytesBE)(share.share, 32)
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
     }
@@ -25128,7 +24318,7 @@ var TransferService = class extends BaseTransferService {
       leafTweaksMap.set(identifier, {
         leafId: leaf.leaf.id,
         secretShareTweak: {
-          secretShare: (0, import_utils9.numberToBytesBE)(share.share, 32),
+          secretShare: (0, import_utils4.numberToBytesBE)(share.share, 32),
           proofs: share.proofs
         },
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak)
@@ -25296,13 +24486,13 @@ var TransferService = class extends BaseTransferService {
       });
     }
     const newCpfpRefundOutPoint = {
-      txid: (0, import_utils9.hexToBytes)(getTxId(cpfpNodeTx)),
+      txid: (0, import_utils4.hexToBytes)(getTxId(cpfpNodeTx)),
       index: 0
     };
     let newDirectRefundOutPoint;
     if (newDirectNodeTx) {
       newDirectRefundOutPoint = {
-        txid: (0, import_utils9.hexToBytes)(getTxId(newDirectNodeTx)),
+        txid: (0, import_utils4.hexToBytes)(getTxId(newDirectNodeTx)),
         index: 0
       };
     }
@@ -25430,7 +24620,7 @@ var TransferService = class extends BaseTransferService {
     const refundTx = getTxFromRawTxBytes(node.refundTx);
     const refundSequence = refundTx.getInput(0).sequence || 0;
     const newNodeOutPoint = {
-      txid: (0, import_utils9.hexToBytes)(getTxId(nodeTx)),
+      txid: (0, import_utils4.hexToBytes)(getTxId(nodeTx)),
       index: 0
     };
     const {
@@ -25467,13 +24657,13 @@ var TransferService = class extends BaseTransferService {
       });
     }
     const newCpfpRefundOutPoint = {
-      txid: (0, import_utils9.hexToBytes)(getTxId(newNodeTx)),
+      txid: (0, import_utils4.hexToBytes)(getTxId(newNodeTx)),
       index: 0
     };
     let newDirectRefundOutPoint;
     if (newDirectNodeTx) {
       newDirectRefundOutPoint = {
-        txid: (0, import_utils9.hexToBytes)(getTxId(newDirectNodeTx)),
+        txid: (0, import_utils4.hexToBytes)(getTxId(newDirectNodeTx)),
         index: 0
       };
     }
@@ -25707,13 +24897,13 @@ var TransferService = class extends BaseTransferService {
     };
     const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
     const cpfpRefundOutPoint = {
-      txid: (0, import_utils9.hexToBytes)(getTxId(nodeTx)),
+      txid: (0, import_utils4.hexToBytes)(getTxId(nodeTx)),
       index: 0
     };
     let directRefundOutPoint;
     if (directNodeTx) {
       directRefundOutPoint = {
-        txid: (0, import_utils9.hexToBytes)(getTxId(directNodeTx)),
+        txid: (0, import_utils4.hexToBytes)(getTxId(directNodeTx)),
         index: 0
       };
     }
@@ -25835,7 +25025,8 @@ var CoopExitService = class extends BaseTransferService {
     leaves,
     exitTxId,
     connectorOutputs,
-    receiverPubKey
+    receiverPubKey,
+    transferId
   }) {
     const {
       transfer,
@@ -25846,7 +25037,8 @@ var CoopExitService = class extends BaseTransferService {
       leaves,
       exitTxId,
       connectorOutputs,
-      receiverPubKey
+      receiverPubKey,
+      transferId
     );
     const transferTweak = await this.deliverTransferPackage(
       transfer,
@@ -25927,7 +25119,7 @@ var CoopExitService = class extends BaseTransferService {
       directFromCpfpRefundTx
     };
   }
-  async signCoopExitRefunds(leaves, exitTxId, connectorOutputs, receiverPubKey) {
+  async signCoopExitRefunds(leaves, exitTxId, connectorOutputs, receiverPubKey, transferId) {
     if (leaves.length !== connectorOutputs.length) {
       throw new ValidationError(
         "Mismatch between leaves and connector outputs",
@@ -26031,7 +25223,7 @@ var CoopExitService = class extends BaseTransferService {
     try {
       response = await sparkClient.cooperative_exit_v2({
         transfer: {
-          transferId: (0, import_uuidv72.uuidv7)(),
+          transferId,
           leavesToSend: signingJobs,
           ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
           receiverIdentityPublicKey: receiverPubKey,
@@ -26087,15 +25279,114 @@ var CoopExitService = class extends BaseTransferService {
 
 // src/services/deposit.ts
 init_buffer();
-var import_secp256k18 = require("@noble/curves/secp256k1");
-var import_sha28 = require("@noble/hashes/sha2");
-var import_utils10 = require("@noble/hashes/utils");
+var import_secp256k14 = require("@noble/curves/secp256k1");
+var import_sha27 = require("@noble/hashes/sha2");
+var import_utils6 = require("@noble/hashes/utils");
 var import_btc_signer4 = require("@scure/btc-signer");
-var import_utils11 = require("@scure/btc-signer/utils");
+var import_utils7 = require("@scure/btc-signer/utils");
+
+// src/utils/keys.ts
+init_buffer();
+var import_secp256k13 = require("@noble/curves/secp256k1");
+var import_utils5 = require("@noble/curves/utils");
+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 = import_secp256k13.secp256k1.Point.fromHex(a);
+  const pubkeyB = import_secp256k13.secp256k1.Point.fromHex(b);
+  return pubkeyA.add(pubkeyB).toBytes(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 = import_secp256k13.secp256k1.Point.fromHex(pubkey);
+  const privTweek = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(tweak);
+  const pubTweek = import_secp256k13.secp256k1.getPublicKey(privTweek, true);
+  const tweekPoint = import_secp256k13.secp256k1.Point.fromHex(pubTweek);
+  return pubkeyPoint.add(tweekPoint).toBytes(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 = import_secp256k13.secp256k1.Point.fromHex(a);
+  const pubkeyB = import_secp256k13.secp256k1.Point.fromHex(b);
+  return pubkeyA.subtract(pubkeyB).toBytes(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 = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(a);
+  const privB = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(b);
+  const sum2 = (privA + privB) % import_secp256k13.secp256k1.CURVE.n;
+  return (0, import_utils5.numberToBytesBE)(sum2, 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 = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(a);
+  const privB = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(b);
+  const sum2 = (import_secp256k13.secp256k1.CURVE.n - privB + privA) % import_secp256k13.secp256k1.CURVE.n;
+  return (0, import_utils5.numberToBytesBE)(sum2, 32);
+}
+function sumOfPrivateKeys(keys) {
+  return keys.reduce((sum2, key) => {
+    if (key.length !== 32) {
+      throw new ValidationError("Private keys must be 32 bytes", {
+        field: "privateKey",
+        value: key.length,
+        expected: 32
+      });
+    }
+    return addPrivateKeys(sum2, 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 sum2 = sumOfPrivateKeys(keys);
+  return subtractPrivateKeys(target, sum2);
+}
 
 // src/utils/proof.ts
 init_buffer();
-var import_sha27 = require("@noble/hashes/sha2");
+var import_sha26 = require("@noble/hashes/sha2");
 function proofOfPossessionMessageHashForDepositAddress(userPubkey, operatorPubkey, depositAddress) {
   const encoder = new TextEncoder();
   const depositAddressBytes = encoder.encode(depositAddress);
@@ -26104,7 +25395,7 @@ function proofOfPossessionMessageHashForDepositAddress(userPubkey, operatorPubke
     ...operatorPubkey,
     ...depositAddressBytes
   ]);
-  return (0, import_sha27.sha256)(proofMsg);
+  return (0, import_sha26.sha256)(proofMsg);
 }
 
 // src/services/deposit.ts
@@ -26140,7 +25431,7 @@ var DepositService = class {
       void 0,
       getNetwork(this.config.getNetwork())
     ).tweakedPubkey;
-    const isVerified = import_secp256k18.schnorr.verify(
+    const isVerified = import_secp256k14.schnorr.verify(
       address.depositAddressProof.proofOfPossessionSignature,
       msg,
       taprootKey
@@ -26154,12 +25445,12 @@ var DepositService = class {
         }
       );
     }
-    const addrHash = (0, import_sha28.sha256)(address.address);
+    const addrHash = (0, import_sha27.sha256)(address.address);
     for (const operator of Object.values(this.config.getSigningOperators())) {
       if (operator.identifier === this.config.getCoordinatorIdentifier() && !verifyCoordinatorProof) {
         continue;
       }
-      const operatorPubkey2 = (0, import_utils10.hexToBytes)(operator.identityPublicKey);
+      const operatorPubkey2 = (0, import_utils6.hexToBytes)(operator.identityPublicKey);
       const operatorSig = address.depositAddressProof.addressSignatures[operator.identifier];
       if (!operatorSig) {
         throw new ValidationError("Operator signature not found", {
@@ -26167,8 +25458,8 @@ var DepositService = class {
           value: operator.identifier
         });
       }
-      const sig = import_secp256k18.secp256k1.Signature.fromDER(operatorSig);
-      const isVerified2 = import_secp256k18.secp256k1.verify(
+      const sig = import_secp256k14.secp256k1.Signature.fromDER(operatorSig);
+      const isVerified2 = import_secp256k14.secp256k1.verify(
         sig.toCompactRawBytes(),
         addrHash,
         operatorPubkey2
@@ -26288,7 +25579,7 @@ var DepositService = class {
       });
     }
     const depositOutPoint = {
-      txid: (0, import_utils10.hexToBytes)(getTxId(depositTx)),
+      txid: (0, import_utils6.hexToBytes)(getTxId(depositTx)),
       index: vout
     };
     const depositTxOut = {
@@ -26307,8 +25598,8 @@ var DepositService = class {
     const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
       sequence: INITIAL_SEQUENCE,
       directSequence: INITIAL_DIRECT_SEQUENCE,
-      input: { txid: (0, import_utils10.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
-      directInput: { txid: (0, import_utils10.hexToBytes)(getTxId(directRootTx)), index: 0 },
+      input: { txid: (0, import_utils6.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
+      directInput: { txid: (0, import_utils6.hexToBytes)(getTxId(directRootTx)), index: 0 },
       amountSats: amount,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
@@ -26438,7 +25729,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils11.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils7.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -26602,7 +25893,7 @@ var DepositService = class {
       });
     }
     const depositOutPoint = {
-      txid: (0, import_utils10.hexToBytes)(getTxId(depositTx)),
+      txid: (0, import_utils6.hexToBytes)(getTxId(depositTx)),
       index: vout
     };
     const depositTxOut = {
@@ -26615,7 +25906,7 @@ var DepositService = class {
     const signingPubKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
     const { cpfpRefundTx } = createRefundTxs({
       sequence: INITIAL_SEQUENCE,
-      input: { txid: (0, import_utils10.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
+      input: { txid: (0, import_utils6.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
       amountSats: amount,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
@@ -26685,7 +25976,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils11.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils7.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -26761,11 +26052,23 @@ var DepositService = class {
 
 // src/services/lightning.ts
 init_buffer();
-var import_secp256k19 = require("@noble/curves/secp256k1");
-var import_utils12 = require("@noble/curves/utils");
-var import_sha29 = require("@noble/hashes/sha2");
+var import_secp256k15 = require("@noble/curves/secp256k1");
+var import_utils8 = require("@noble/curves/utils");
+var import_sha28 = require("@noble/hashes/sha2");
 var import_uuidv73 = require("uuidv7");
 
+// src/utils/crypto.ts
+init_buffer();
+var cryptoImpl = globalThis.crypto ?? null;
+var getCrypto = () => {
+  if (!cryptoImpl) {
+    throw new Error(
+      "Crypto implementation is not set. Please set it using setCrypto()."
+    );
+  }
+  return cryptoImpl;
+};
+
 // src/services/bolt11-spark.ts
 init_buffer();
 var import_light_bolt11_decoder = require("light-bolt11-decoder");
@@ -26848,8 +26151,8 @@ var LightningService = class {
   }) {
     const crypto = getCrypto();
     const randBytes = crypto.getRandomValues(new Uint8Array(32));
-    const preimage = (0, import_utils12.numberToBytesBE)(
-      (0, import_utils12.bytesToNumberBE)(randBytes) % import_secp256k19.secp256k1.CURVE.n,
+    const preimage = (0, import_utils8.numberToBytesBE)(
+      (0, import_utils8.bytesToNumberBE)(randBytes) % import_secp256k15.secp256k1.CURVE.n,
       32
     );
     return await this.createLightningInvoiceWithPreImage({
@@ -26869,7 +26172,7 @@ var LightningService = class {
     receiverIdentityPubkey,
     descriptionHash
   }) {
-    const paymentHash = (0, import_sha29.sha256)(preimage);
+    const paymentHash = (0, import_sha28.sha256)(preimage);
     const invoice = await invoiceCreator(
       amountSats,
       paymentHash,
@@ -26886,7 +26189,7 @@ var LightningService = class {
     }
     const shares = await this.config.signer.splitSecretWithProofs({
       secret: preimage,
-      curveOrder: import_secp256k19.secp256k1.CURVE.n,
+      curveOrder: import_secp256k15.secp256k1.CURVE.n,
       threshold: this.config.getThreshold(),
       numShares: Object.keys(this.config.getSigningOperators()).length
     });
@@ -26904,12 +26207,12 @@ var LightningService = class {
         const sparkClient = await this.connectionManager.createSparkClient(
           operator.address
         );
-        const userIdentityPublicKey = receiverIdentityPubkey ? (0, import_utils12.hexToBytes)(receiverIdentityPubkey) : await this.config.signer.getIdentityPublicKey();
+        const userIdentityPublicKey = receiverIdentityPubkey ? (0, import_utils8.hexToBytes)(receiverIdentityPubkey) : await this.config.signer.getIdentityPublicKey();
         try {
           await sparkClient.store_preimage_share({
             paymentHash,
             preimageShare: {
-              secretShare: (0, import_utils12.numberToBytesBE)(share.share, 32),
+              secretShare: (0, import_utils8.numberToBytesBE)(share.share, 32),
               proofs: share.proofs
             },
             threshold: this.config.getThreshold(),
@@ -27078,7 +26381,7 @@ var LightningService = class {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const paymentHash = (0, import_sha29.sha256)(preimage);
+    const paymentHash = (0, import_sha28.sha256)(preimage);
     let response;
     try {
       response = await sparkClient.provide_preimage({
@@ -27110,21 +26413,21 @@ var LightningService = class {
 
 // src/services/token-transactions.ts
 init_buffer();
-var import_utils16 = require("@noble/curves/utils");
-var import_utils17 = require("@noble/hashes/utils");
+var import_utils12 = require("@noble/curves/utils");
+var import_utils13 = require("@noble/hashes/utils");
 
 // src/utils/address.ts
 init_buffer();
 var import_wire7 = require("@bufbuild/protobuf/wire");
-var import_secp256k110 = require("@noble/curves/secp256k1");
-var import_utils13 = require("@noble/curves/utils");
-var import_utils14 = require("@noble/hashes/utils");
+var import_secp256k16 = require("@noble/curves/secp256k1");
+var import_utils9 = require("@noble/curves/utils");
+var import_utils10 = require("@noble/hashes/utils");
 var import_base3 = require("@scure/base");
 var import_uuidv74 = require("uuidv7");
 
 // src/utils/invoice-hashing.ts
 init_buffer();
-var import_sha210 = require("@noble/hashes/sha2");
+var import_sha29 = require("@noble/hashes/sha2");
 function HashSparkInvoice(sparkInvoiceFields, receiverPublicKey, network) {
   if (!sparkInvoiceFields) {
     throw new Error("Missing sparkInvoiceFields");
@@ -27161,20 +26464,20 @@ function HashSparkInvoiceV1(sparkInvoiceFields, receiverPublicKey, network) {
   }
   const { version, id, paymentType, memo, senderPublicKey, expiryTime } = sparkInvoiceFields;
   const allHashes = [];
-  const versionHashObj = import_sha210.sha256.create();
+  const versionHashObj = import_sha29.sha256.create();
   const versionBytes = uint32be(version);
   versionHashObj.update(versionBytes);
   allHashes.push(versionHashObj.digest());
-  const idHashObj = import_sha210.sha256.create();
+  const idHashObj = import_sha29.sha256.create();
   if (!id || id.length !== 16) {
     throw new Error("invoice id must be exactly 16 bytes");
   }
   idHashObj.update(id);
   allHashes.push(idHashObj.digest());
-  const networkHashObj = import_sha210.sha256.create();
+  const networkHashObj = import_sha29.sha256.create();
   hashNetworkMagicInto(networkHashObj, network);
   allHashes.push(networkHashObj.digest());
-  const receiverPubKeyHashObj = import_sha210.sha256.create();
+  const receiverPubKeyHashObj = import_sha29.sha256.create();
   if (!receiverPublicKey || receiverPublicKey.length !== 33) {
     throw new Error("receiver public key must be exactly 33 bytes");
   }
@@ -27183,10 +26486,10 @@ function HashSparkInvoiceV1(sparkInvoiceFields, receiverPublicKey, network) {
   switch (paymentType?.$case) {
     case "tokensPayment": {
       const tp = paymentType.tokensPayment;
-      const discrHash = import_sha210.sha256.create();
+      const discrHash = import_sha29.sha256.create();
       discrHash.update(new Uint8Array([1]));
       allHashes.push(discrHash.digest());
-      const tokenIdHash = import_sha210.sha256.create();
+      const tokenIdHash = import_sha29.sha256.create();
       const tokenIdentifier = tp.tokenIdentifier;
       if (!tokenIdentifier || tokenIdentifier.length === 0) {
         tokenIdHash.update(new Uint8Array(32));
@@ -27197,7 +26500,7 @@ function HashSparkInvoiceV1(sparkInvoiceFields, receiverPublicKey, network) {
         tokenIdHash.update(tokenIdentifier);
       }
       allHashes.push(tokenIdHash.digest());
-      const amountHash = import_sha210.sha256.create();
+      const amountHash = import_sha29.sha256.create();
       const amount = tp.amount;
       if (amount && amount.length > 16) {
         throw new Error("token amount exceeds 16 bytes");
@@ -27210,10 +26513,10 @@ function HashSparkInvoiceV1(sparkInvoiceFields, receiverPublicKey, network) {
     }
     case "satsPayment": {
       const sp = paymentType.satsPayment;
-      const discrHash = import_sha210.sha256.create();
+      const discrHash = import_sha29.sha256.create();
       discrHash.update(new Uint8Array([2]));
       allHashes.push(discrHash.digest());
-      const satsHash = import_sha210.sha256.create();
+      const satsHash = import_sha29.sha256.create();
       let sats = 0n;
       if (sp && typeof sp.amount === "number" && sp.amount !== 0) {
         sats = BigInt(sp.amount);
@@ -27226,12 +26529,12 @@ function HashSparkInvoiceV1(sparkInvoiceFields, receiverPublicKey, network) {
       throw new Error("unsupported or missing payment type");
     }
   }
-  const memoHashObj = import_sha210.sha256.create();
+  const memoHashObj = import_sha29.sha256.create();
   if (memo != null) {
     memoHashObj.update(new TextEncoder().encode(memo));
   }
   allHashes.push(memoHashObj.digest());
-  const senderPubKeyHashObj = import_sha210.sha256.create();
+  const senderPubKeyHashObj = import_sha29.sha256.create();
   const spk = senderPublicKey;
   if (!spk || spk.length === 0) {
     senderPubKeyHashObj.update(new Uint8Array(33));
@@ -27242,7 +26545,7 @@ function HashSparkInvoiceV1(sparkInvoiceFields, receiverPublicKey, network) {
     senderPubKeyHashObj.update(spk);
   }
   allHashes.push(senderPubKeyHashObj.digest());
-  const expiryHashObj = import_sha210.sha256.create();
+  const expiryHashObj = import_sha29.sha256.create();
   let exp = 0n;
   if (expiryTime instanceof Date) {
     const seconds = Math.floor(expiryTime.getTime() / 1e3);
@@ -27252,7 +26555,7 @@ function HashSparkInvoiceV1(sparkInvoiceFields, receiverPublicKey, network) {
   }
   expiryHashObj.update(uint64be(exp));
   allHashes.push(expiryHashObj.digest());
-  const finalHash = import_sha210.sha256.create();
+  const finalHash = import_sha29.sha256.create();
   for (const hash of allHashes) {
     finalHash.update(hash);
   }
@@ -27276,7 +26579,7 @@ function bitcoinNetworkIdentifierFromNetwork(network) {
 function hashNetworkMagicInto(hasher, network) {
   const magic = bitcoinNetworkIdentifierFromNetwork(network);
   const magicBE = uint32be(magic);
-  hasher.update((0, import_sha210.sha256)(magicBE));
+  hasher.update((0, import_sha29.sha256)(magicBE));
 }
 function uint32be(n) {
   const b = new Uint8Array(4);
@@ -27311,7 +26614,7 @@ function encodeSparkAddress(payload) {
 function encodeSparkAddressWithSignature(payload, signature) {
   try {
     isValidPublicKey(payload.identityPublicKey);
-    const identityPublicKey = (0, import_utils14.hexToBytes)(payload.identityPublicKey);
+    const identityPublicKey = (0, import_utils10.hexToBytes)(payload.identityPublicKey);
     let sparkInvoiceFields;
     if (payload.sparkInvoiceFields) {
       validateSparkInvoiceFields(payload.sparkInvoiceFields);
@@ -27355,8 +26658,8 @@ function decodeSparkAddress(address, network) {
     const decoded = bech32mDecode(address);
     const payload = SparkAddress.decode(import_base3.bech32m.fromWords(decoded.words));
     const { identityPublicKey, sparkInvoiceFields, signature } = payload;
-    const identityPubkeyHex = (0, import_utils14.bytesToHex)(identityPublicKey);
-    const signatureHex = signature ? (0, import_utils14.bytesToHex)(signature) : void 0;
+    const identityPubkeyHex = (0, import_utils10.bytesToHex)(identityPublicKey);
+    const signatureHex = signature ? (0, import_utils10.bytesToHex)(signature) : void 0;
     isValidPublicKey(identityPubkeyHex);
     return {
       identityPublicKey: identityPubkeyHex,
@@ -27366,10 +26669,10 @@ function decodeSparkAddress(address, network) {
         id: import_uuidv74.UUID.ofInner(sparkInvoiceFields.id).toString(),
         paymentType: sparkInvoiceFields.paymentType ? sparkInvoiceFields.paymentType.$case === "tokensPayment" ? {
           type: "tokens",
-          tokenIdentifier: sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier ? (0, import_utils14.bytesToHex)(
+          tokenIdentifier: sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier ? (0, import_utils10.bytesToHex)(
             sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier
           ) : void 0,
-          amount: sparkInvoiceFields.paymentType.tokensPayment.amount ? (0, import_utils13.bytesToNumberBE)(
+          amount: sparkInvoiceFields.paymentType.tokensPayment.amount ? (0, import_utils9.bytesToNumberBE)(
             sparkInvoiceFields.paymentType.tokensPayment.amount
           ) : void 0
         } : sparkInvoiceFields.paymentType.$case === "satsPayment" ? {
@@ -27377,7 +26680,7 @@ function decodeSparkAddress(address, network) {
           amount: sparkInvoiceFields.paymentType.satsPayment.amount
         } : void 0 : void 0,
         memo: sparkInvoiceFields.memo,
-        senderPublicKey: sparkInvoiceFields.senderPublicKey ? (0, import_utils14.bytesToHex)(sparkInvoiceFields.senderPublicKey) : void 0,
+        senderPublicKey: sparkInvoiceFields.senderPublicKey ? (0, import_utils10.bytesToHex)(sparkInvoiceFields.senderPublicKey) : void 0,
         expiryTime: sparkInvoiceFields.expiryTime
       },
       signature: signatureHex
@@ -27443,7 +26746,7 @@ function isValidSparkAddress(address) {
 }
 function isValidPublicKey(publicKey) {
   try {
-    const point = import_secp256k110.secp256k1.Point.fromHex(publicKey);
+    const point = import_secp256k16.secp256k1.Point.fromHex(publicKey);
     point.assertValidity();
   } catch (error) {
     throw new ValidationError(
@@ -27478,7 +26781,7 @@ function validateSparkInvoiceFields(sparkInvoiceFields) {
   }
   if (senderPublicKey) {
     try {
-      isValidPublicKey((0, import_utils14.bytesToHex)(senderPublicKey));
+      isValidPublicKey((0, import_utils10.bytesToHex)(senderPublicKey));
     } catch (error) {
       throw new ValidationError(
         "Invalid sender public key",
@@ -27529,7 +26832,7 @@ function validateSparkInvoiceFields(sparkInvoiceFields) {
             value: tokensAmount
           });
         }
-        const tokensAmountBigInt = (0, import_utils13.bytesToNumberBE)(tokensAmount);
+        const tokensAmountBigInt = (0, import_utils9.bytesToNumberBE)(tokensAmount);
         if (tokensAmountBigInt < 0 || tokensAmountBigInt > MAX_UINT128) {
           throw new ValidationError(
             "Asset amount must be between 0 and MAX_UINT128",
@@ -27596,10 +26899,10 @@ function validateSparkInvoiceSignature(invoice) {
       identityPublicKey,
       network
     );
-    const sec256k1PublicKey = import_secp256k110.secp256k1.Point.fromHex(identityPublicKey);
+    const sec256k1PublicKey = import_secp256k16.secp256k1.Point.fromHex(identityPublicKey);
     const compressed = sec256k1PublicKey.toBytes(true);
     const xOnly = compressed.slice(1);
-    const isValid = import_secp256k110.schnorr.verify(signature, hash, xOnly);
+    const isValid = import_secp256k16.schnorr.verify(signature, hash, xOnly);
     if (!isValid) {
       throw new ValidationError("Invalid signature", {
         field: "signature",
@@ -27666,7 +26969,7 @@ function isSafeForNumber(bi) {
 
 // src/utils/token-hashing.ts
 init_buffer();
-var import_sha211 = require("@noble/hashes/sha2");
+var import_sha210 = require("@noble/hashes/sha2");
 var import_base4 = require("@scure/base");
 function hashTokenTransaction(tokenTransaction, partialHash = false) {
   switch (tokenTransaction.version) {
@@ -27688,7 +26991,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
     });
   }
   let allHashes = [];
-  const versionHashObj = import_sha211.sha256.create();
+  const versionHashObj = import_sha210.sha256.create();
   const versionBytes = new Uint8Array(4);
   new DataView(versionBytes.buffer).setUint32(
     0,
@@ -27698,7 +27001,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
   );
   versionHashObj.update(versionBytes);
   allHashes.push(versionHashObj.digest());
-  const typeHashObj = import_sha211.sha256.create();
+  const typeHashObj = import_sha210.sha256.create();
   const typeBytes = new Uint8Array(4);
   let transactionType = 0;
   if (tokenTransaction.tokenInputs?.$case === "mintInput") {
@@ -27729,7 +27032,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
         field: "tokenInputs.transferInput.outputsToSpend"
       });
     }
-    const outputsLenHashObj2 = import_sha211.sha256.create();
+    const outputsLenHashObj2 = import_sha210.sha256.create();
     const outputsLenBytes2 = new Uint8Array(4);
     new DataView(outputsLenBytes2.buffer).setUint32(
       0,
@@ -27748,7 +27051,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
           index: i
         });
       }
-      const hashObj2 = import_sha211.sha256.create();
+      const hashObj2 = import_sha210.sha256.create();
       if (output.prevTokenTransactionHash) {
         const prevHash = output.prevTokenTransactionHash;
         if (output.prevTokenTransactionHash.length !== 32) {
@@ -27775,7 +27078,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
       allHashes.push(hashObj2.digest());
     }
   } else if (tokenTransaction.tokenInputs?.$case === "mintInput") {
-    const hashObj2 = import_sha211.sha256.create();
+    const hashObj2 = import_sha210.sha256.create();
     if (tokenTransaction.tokenInputs.mintInput.issuerPublicKey) {
       const issuerPubKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
       if (issuerPubKey.length === 0) {
@@ -27788,7 +27091,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
       }
       hashObj2.update(issuerPubKey);
       allHashes.push(hashObj2.digest());
-      const tokenIdentifierHashObj = import_sha211.sha256.create();
+      const tokenIdentifierHashObj = import_sha210.sha256.create();
       if (tokenTransaction.tokenInputs.mintInput.tokenIdentifier) {
         tokenIdentifierHashObj.update(
           tokenTransaction.tokenInputs.mintInput.tokenIdentifier
@@ -27800,7 +27103,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
     }
   } else if (tokenTransaction.tokenInputs?.$case === "createInput") {
     const createInput = tokenTransaction.tokenInputs.createInput;
-    const issuerPubKeyHashObj = import_sha211.sha256.create();
+    const issuerPubKeyHashObj = import_sha210.sha256.create();
     if (!createInput.issuerPublicKey || createInput.issuerPublicKey.length === 0) {
       throw new ValidationError("issuer public key cannot be nil or empty", {
         field: "tokenInputs.createInput.issuerPublicKey"
@@ -27808,7 +27111,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
     }
     issuerPubKeyHashObj.update(createInput.issuerPublicKey);
     allHashes.push(issuerPubKeyHashObj.digest());
-    const tokenNameHashObj = import_sha211.sha256.create();
+    const tokenNameHashObj = import_sha210.sha256.create();
     if (!createInput.tokenName || createInput.tokenName.length === 0) {
       throw new ValidationError("token name cannot be empty", {
         field: "tokenInputs.createInput.tokenName"
@@ -27825,7 +27128,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
     const tokenNameEncoder = new TextEncoder();
     tokenNameHashObj.update(tokenNameEncoder.encode(createInput.tokenName));
     allHashes.push(tokenNameHashObj.digest());
-    const tokenTickerHashObj = import_sha211.sha256.create();
+    const tokenTickerHashObj = import_sha210.sha256.create();
     if (!createInput.tokenTicker || createInput.tokenTicker.length === 0) {
       throw new ValidationError("token ticker cannot be empty", {
         field: "tokenInputs.createInput.tokenTicker"
@@ -27844,7 +27147,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
       tokenTickerEncoder.encode(createInput.tokenTicker)
     );
     allHashes.push(tokenTickerHashObj.digest());
-    const decimalsHashObj = import_sha211.sha256.create();
+    const decimalsHashObj = import_sha210.sha256.create();
     const decimalsBytes = new Uint8Array(4);
     new DataView(decimalsBytes.buffer).setUint32(
       0,
@@ -27853,7 +27156,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
     );
     decimalsHashObj.update(decimalsBytes);
     allHashes.push(decimalsHashObj.digest());
-    const maxSupplyHashObj = import_sha211.sha256.create();
+    const maxSupplyHashObj = import_sha210.sha256.create();
     if (!createInput.maxSupply) {
       throw new ValidationError("max supply cannot be nil", {
         field: "tokenInputs.createInput.maxSupply"
@@ -27869,12 +27172,12 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
     }
     maxSupplyHashObj.update(createInput.maxSupply);
     allHashes.push(maxSupplyHashObj.digest());
-    const isFreezableHashObj = import_sha211.sha256.create();
+    const isFreezableHashObj = import_sha210.sha256.create();
     isFreezableHashObj.update(
       new Uint8Array([createInput.isFreezable ? 1 : 0])
     );
     allHashes.push(isFreezableHashObj.digest());
-    const creationEntityHashObj = import_sha211.sha256.create();
+    const creationEntityHashObj = import_sha210.sha256.create();
     if (!partialHash && createInput.creationEntityPublicKey) {
       creationEntityHashObj.update(createInput.creationEntityPublicKey);
     }
@@ -27885,7 +27188,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
       field: "tokenOutputs"
     });
   }
-  const outputsLenHashObj = import_sha211.sha256.create();
+  const outputsLenHashObj = import_sha210.sha256.create();
   const outputsLenBytes = new Uint8Array(4);
   new DataView(outputsLenBytes.buffer).setUint32(
     0,
@@ -27901,7 +27204,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
         index: i
       });
     }
-    const hashObj2 = import_sha211.sha256.create();
+    const hashObj2 = import_sha210.sha256.create();
     if (output.id && !partialHash) {
       if (output.id.length === 0) {
         throw new ValidationError(`output ID at index ${i} cannot be empty`, {
@@ -28002,7 +27305,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
     }
     return a.length - b.length;
   });
-  const operatorLenHashObj = import_sha211.sha256.create();
+  const operatorLenHashObj = import_sha210.sha256.create();
   const operatorLenBytes = new Uint8Array(4);
   new DataView(operatorLenBytes.buffer).setUint32(
     0,
@@ -28030,11 +27333,11 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
         }
       );
     }
-    const hashObj2 = import_sha211.sha256.create();
+    const hashObj2 = import_sha210.sha256.create();
     hashObj2.update(pubKey);
     allHashes.push(hashObj2.digest());
   }
-  const hashObj = import_sha211.sha256.create();
+  const hashObj = import_sha210.sha256.create();
   let networkBytes = new Uint8Array(4);
   new DataView(networkBytes.buffer).setUint32(
     0,
@@ -28044,7 +27347,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
   );
   hashObj.update(networkBytes);
   allHashes.push(hashObj.digest());
-  const clientTimestampHashObj = import_sha211.sha256.create();
+  const clientTimestampHashObj = import_sha210.sha256.create();
   const clientCreatedTs = tokenTransaction.clientCreatedTimestamp;
   if (!clientCreatedTs) {
     throw new ValidationError(
@@ -28064,7 +27367,7 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
   clientTimestampHashObj.update(clientTimestampBytes);
   allHashes.push(clientTimestampHashObj.digest());
   if (!partialHash) {
-    const expiryHashObj = import_sha211.sha256.create();
+    const expiryHashObj = import_sha210.sha256.create();
     const expiryTimeBytes = new Uint8Array(8);
     const expiryUnixTime = tokenTransaction.expiryTime ? Math.floor(tokenTransaction.expiryTime.getTime() / 1e3) : 0;
     new DataView(expiryTimeBytes.buffer).setBigUint64(
@@ -28076,9 +27379,9 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
     expiryHashObj.update(expiryTimeBytes);
     allHashes.push(expiryHashObj.digest());
   }
-  const finalHashObj = import_sha211.sha256.create();
+  const finalHashObj = import_sha210.sha256.create();
   const concatenatedHashes = new Uint8Array(
-    allHashes.reduce((sum, hash) => sum + hash.length, 0)
+    allHashes.reduce((sum2, hash) => sum2 + hash.length, 0)
   );
   let offset = 0;
   for (const hash of allHashes) {
@@ -28095,7 +27398,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
     });
   }
   let allHashes = [];
-  const versionHashObj = import_sha211.sha256.create();
+  const versionHashObj = import_sha210.sha256.create();
   const versionBytes = new Uint8Array(4);
   new DataView(versionBytes.buffer).setUint32(
     0,
@@ -28105,7 +27408,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
   );
   versionHashObj.update(versionBytes);
   allHashes.push(versionHashObj.digest());
-  const typeHashObj = import_sha211.sha256.create();
+  const typeHashObj = import_sha210.sha256.create();
   const typeBytes = new Uint8Array(4);
   let transactionType = 0;
   if (tokenTransaction.tokenInputs?.$case === "mintInput") {
@@ -28136,7 +27439,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
         field: "tokenInputs.transferInput.outputsToSpend"
       });
     }
-    const outputsLenHashObj2 = import_sha211.sha256.create();
+    const outputsLenHashObj2 = import_sha210.sha256.create();
     const outputsLenBytes2 = new Uint8Array(4);
     new DataView(outputsLenBytes2.buffer).setUint32(
       0,
@@ -28155,7 +27458,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
           index: i
         });
       }
-      const hashObj2 = import_sha211.sha256.create();
+      const hashObj2 = import_sha210.sha256.create();
       if (output.prevTokenTransactionHash) {
         const prevHash = output.prevTokenTransactionHash;
         if (output.prevTokenTransactionHash.length !== 32) {
@@ -28182,7 +27485,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
       allHashes.push(hashObj2.digest());
     }
   } else if (tokenTransaction.tokenInputs?.$case === "mintInput") {
-    const hashObj2 = import_sha211.sha256.create();
+    const hashObj2 = import_sha210.sha256.create();
     if (tokenTransaction.tokenInputs.mintInput.issuerPublicKey) {
       const issuerPubKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
       if (issuerPubKey.length === 0) {
@@ -28195,7 +27498,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
       }
       hashObj2.update(issuerPubKey);
       allHashes.push(hashObj2.digest());
-      const tokenIdentifierHashObj = import_sha211.sha256.create();
+      const tokenIdentifierHashObj = import_sha210.sha256.create();
       if (tokenTransaction.tokenInputs.mintInput.tokenIdentifier) {
         tokenIdentifierHashObj.update(
           tokenTransaction.tokenInputs.mintInput.tokenIdentifier
@@ -28207,7 +27510,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
     }
   } else if (tokenTransaction.tokenInputs?.$case === "createInput") {
     const createInput = tokenTransaction.tokenInputs.createInput;
-    const issuerPubKeyHashObj = import_sha211.sha256.create();
+    const issuerPubKeyHashObj = import_sha210.sha256.create();
     if (!createInput.issuerPublicKey || createInput.issuerPublicKey.length === 0) {
       throw new ValidationError("issuer public key cannot be nil or empty", {
         field: "tokenInputs.createInput.issuerPublicKey"
@@ -28215,7 +27518,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
     }
     issuerPubKeyHashObj.update(createInput.issuerPublicKey);
     allHashes.push(issuerPubKeyHashObj.digest());
-    const tokenNameHashObj = import_sha211.sha256.create();
+    const tokenNameHashObj = import_sha210.sha256.create();
     if (!createInput.tokenName || createInput.tokenName.length === 0) {
       throw new ValidationError("token name cannot be empty", {
         field: "tokenInputs.createInput.tokenName"
@@ -28232,7 +27535,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
     const tokenNameEncoder = new TextEncoder();
     tokenNameHashObj.update(tokenNameEncoder.encode(createInput.tokenName));
     allHashes.push(tokenNameHashObj.digest());
-    const tokenTickerHashObj = import_sha211.sha256.create();
+    const tokenTickerHashObj = import_sha210.sha256.create();
     if (!createInput.tokenTicker || createInput.tokenTicker.length === 0) {
       throw new ValidationError("token ticker cannot be empty", {
         field: "tokenInputs.createInput.tokenTicker"
@@ -28251,7 +27554,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
       tokenTickerEncoder.encode(createInput.tokenTicker)
     );
     allHashes.push(tokenTickerHashObj.digest());
-    const decimalsHashObj = import_sha211.sha256.create();
+    const decimalsHashObj = import_sha210.sha256.create();
     const decimalsBytes = new Uint8Array(4);
     new DataView(decimalsBytes.buffer).setUint32(
       0,
@@ -28260,7 +27563,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
     );
     decimalsHashObj.update(decimalsBytes);
     allHashes.push(decimalsHashObj.digest());
-    const maxSupplyHashObj = import_sha211.sha256.create();
+    const maxSupplyHashObj = import_sha210.sha256.create();
     if (!createInput.maxSupply) {
       throw new ValidationError("max supply cannot be nil", {
         field: "tokenInputs.createInput.maxSupply"
@@ -28276,12 +27579,12 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
     }
     maxSupplyHashObj.update(createInput.maxSupply);
     allHashes.push(maxSupplyHashObj.digest());
-    const isFreezableHashObj = import_sha211.sha256.create();
+    const isFreezableHashObj = import_sha210.sha256.create();
     isFreezableHashObj.update(
       new Uint8Array([createInput.isFreezable ? 1 : 0])
     );
     allHashes.push(isFreezableHashObj.digest());
-    const creationEntityHashObj = import_sha211.sha256.create();
+    const creationEntityHashObj = import_sha210.sha256.create();
     if (!partialHash && createInput.creationEntityPublicKey) {
       creationEntityHashObj.update(createInput.creationEntityPublicKey);
     }
@@ -28292,7 +27595,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
       field: "tokenOutputs"
     });
   }
-  const outputsLenHashObj = import_sha211.sha256.create();
+  const outputsLenHashObj = import_sha210.sha256.create();
   const outputsLenBytes = new Uint8Array(4);
   new DataView(outputsLenBytes.buffer).setUint32(
     0,
@@ -28308,7 +27611,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
         index: i
       });
     }
-    const hashObj2 = import_sha211.sha256.create();
+    const hashObj2 = import_sha210.sha256.create();
     if (output.id && !partialHash) {
       if (output.id.length === 0) {
         throw new ValidationError(`output ID at index ${i} cannot be empty`, {
@@ -28409,7 +27712,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
     }
     return a.length - b.length;
   });
-  const operatorLenHashObj = import_sha211.sha256.create();
+  const operatorLenHashObj = import_sha210.sha256.create();
   const operatorLenBytes = new Uint8Array(4);
   new DataView(operatorLenBytes.buffer).setUint32(
     0,
@@ -28437,11 +27740,11 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
         }
       );
     }
-    const hashObj2 = import_sha211.sha256.create();
+    const hashObj2 = import_sha210.sha256.create();
     hashObj2.update(pubKey);
     allHashes.push(hashObj2.digest());
   }
-  const hashObj = import_sha211.sha256.create();
+  const hashObj = import_sha210.sha256.create();
   let networkBytes = new Uint8Array(4);
   new DataView(networkBytes.buffer).setUint32(
     0,
@@ -28451,7 +27754,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
   );
   hashObj.update(networkBytes);
   allHashes.push(hashObj.digest());
-  const clientTimestampHashObj = import_sha211.sha256.create();
+  const clientTimestampHashObj = import_sha210.sha256.create();
   const clientCreatedTs = tokenTransaction.clientCreatedTimestamp;
   if (!clientCreatedTs) {
     throw new ValidationError(
@@ -28471,7 +27774,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
   clientTimestampHashObj.update(clientTimestampBytes);
   allHashes.push(clientTimestampHashObj.digest());
   if (!partialHash) {
-    const expiryHashObj = import_sha211.sha256.create();
+    const expiryHashObj = import_sha210.sha256.create();
     const expiryTimeBytes = new Uint8Array(8);
     const expiryUnixTime = tokenTransaction.expiryTime ? Math.floor(tokenTransaction.expiryTime.getTime() / 1e3) : 0;
     new DataView(expiryTimeBytes.buffer).setBigUint64(
@@ -28484,7 +27787,7 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
     allHashes.push(expiryHashObj.digest());
   }
   const attachments = tokenTransaction.invoiceAttachments;
-  const lenHash = import_sha211.sha256.create();
+  const lenHash = import_sha210.sha256.create();
   const lenBytes = new Uint8Array(4);
   new DataView(lenBytes.buffer).setUint32(
     0,
@@ -28545,13 +27848,13 @@ function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
   });
   const encoder = new TextEncoder();
   for (const k of sortedInvoices) {
-    const h = import_sha211.sha256.create();
+    const h = import_sha210.sha256.create();
     h.update(encoder.encode(k.raw));
     allHashes.push(h.digest());
   }
-  const finalHashObj = import_sha211.sha256.create();
+  const finalHashObj = import_sha210.sha256.create();
   const concatenatedHashes = new Uint8Array(
-    allHashes.reduce((sum, hash) => sum + hash.length, 0)
+    allHashes.reduce((sum2, hash) => sum2 + hash.length, 0)
   );
   let offset = 0;
   for (const hash of allHashes) {
@@ -28572,7 +27875,7 @@ function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
   }
   let allHashes = [];
   if (payload.finalTokenTransactionHash) {
-    const hashObj2 = import_sha211.sha256.create();
+    const hashObj2 = import_sha210.sha256.create();
     if (payload.finalTokenTransactionHash.length !== 32) {
       throw new ValidationError(`invalid final token transaction hash length`, {
         field: "finalTokenTransactionHash",
@@ -28594,12 +27897,12 @@ function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
       field: "operatorIdentityPublicKey"
     });
   }
-  const hashObj = import_sha211.sha256.create();
+  const hashObj = import_sha210.sha256.create();
   hashObj.update(payload.operatorIdentityPublicKey);
   allHashes.push(hashObj.digest());
-  const finalHashObj = import_sha211.sha256.create();
+  const finalHashObj = import_sha210.sha256.create();
   const concatenatedHashes = new Uint8Array(
-    allHashes.reduce((sum, hash) => sum + hash.length, 0)
+    allHashes.reduce((sum2, hash) => sum2 + hash.length, 0)
   );
   let offset = 0;
   for (const hash of allHashes) {
@@ -29002,11 +28305,11 @@ function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction
 
 // src/utils/token-transactions.ts
 init_buffer();
-var import_utils15 = require("@noble/curves/utils");
+var import_utils11 = require("@noble/curves/utils");
 function sumAvailableTokens(outputs) {
   try {
     return outputs.reduce(
-      (sum, output) => sum + BigInt((0, import_utils15.bytesToNumberBE)(output.output.tokenAmount)),
+      (sum2, output) => sum2 + BigInt((0, import_utils11.bytesToNumberBE)(output.output.tokenAmount)),
       BigInt(0)
     );
   } catch (error) {
@@ -29037,7 +28340,7 @@ function filterTokenBalanceForTokenIdentifier(tokenBalances, tokenIdentifier) {
   }
   const tokenIdentifierBytes = decodeBech32mTokenIdentifier(tokenIdentifier).tokenIdentifier;
   const tokenBalance = [...tokenBalances.entries()].find(
-    ([, info]) => (0, import_utils15.equalBytes)(info.tokenMetadata.rawTokenIdentifier, tokenIdentifierBytes)
+    ([, info]) => (0, import_utils11.equalBytes)(info.tokenMetadata.rawTokenIdentifier, tokenIdentifierBytes)
   );
   if (!tokenBalance) {
     return {
@@ -29073,7 +28376,7 @@ var TokenTransactionService = class {
       });
     }
     const totalTokenAmount = receiverOutputs.reduce(
-      (sum, transfer) => sum + transfer.tokenAmount,
+      (sum2, transfer) => sum2 + transfer.tokenAmount,
       0n
     );
     let outputsToUse;
@@ -29131,14 +28434,14 @@ var TokenTransactionService = class {
       }
       if (receiverAddress.sparkInvoiceFields) {
         return {
-          receiverPublicKey: (0, import_utils17.hexToBytes)(receiverAddress.identityPublicKey),
+          receiverPublicKey: (0, import_utils13.hexToBytes)(receiverAddress.identityPublicKey),
           rawTokenIdentifier,
           tokenAmount: transfer.tokenAmount,
           sparkInvoice: transfer.receiverSparkAddress
         };
       }
       return {
-        receiverPublicKey: (0, import_utils17.hexToBytes)(receiverAddress.identityPublicKey),
+        receiverPublicKey: (0, import_utils13.hexToBytes)(receiverAddress.identityPublicKey),
         rawTokenIdentifier,
         tokenAmount: transfer.tokenAmount
       };
@@ -29161,14 +28464,14 @@ var TokenTransactionService = class {
     );
     const availableTokenAmount = sumAvailableTokens(selectedOutputs);
     const totalRequestedAmount = tokenOutputData.reduce(
-      (sum, output) => sum + output.tokenAmount,
+      (sum2, output) => sum2 + output.tokenAmount,
       0n
     );
     const tokenOutputs = tokenOutputData.map(
       (output) => ({
         ownerPublicKey: output.receiverPublicKey,
         tokenIdentifier: output.rawTokenIdentifier,
-        tokenAmount: (0, import_utils16.numberToBytesBE)(output.tokenAmount, 16)
+        tokenAmount: (0, import_utils12.numberToBytesBE)(output.tokenAmount, 16)
       })
     );
     if (availableTokenAmount > totalRequestedAmount) {
@@ -29177,7 +28480,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenIdentifier: firstTokenIdentifierBytes,
-        tokenAmount: (0, import_utils16.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils12.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -29204,7 +28507,7 @@ var TokenTransactionService = class {
     for (const [_, operator] of Object.entries(
       this.config.getSigningOperators()
     )) {
-      operatorKeys.push((0, import_utils17.hexToBytes)(operator.identityPublicKey));
+      operatorKeys.push((0, import_utils13.hexToBytes)(operator.identityPublicKey));
     }
     return operatorKeys;
   }
@@ -29221,7 +28524,7 @@ var TokenTransactionService = class {
       finalTokenTransactionHash,
       signingOperators
     );
-    return (0, import_utils16.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils12.bytesToHex)(finalTokenTransactionHash);
   }
   async startTokenTransaction(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkTokenClient(
@@ -29396,10 +28699,10 @@ var TokenTransactionService = class {
       });
     }
     for (const ownerPublicKey of ownerPublicKeys) {
-      isValidPublicKey((0, import_utils16.bytesToHex)(ownerPublicKey));
+      isValidPublicKey((0, import_utils12.bytesToHex)(ownerPublicKey));
     }
     for (const issuerPublicKey of issuerPublicKeys) {
-      isValidPublicKey((0, import_utils16.bytesToHex)(issuerPublicKey));
+      isValidPublicKey((0, import_utils12.bytesToHex)(issuerPublicKey));
     }
     for (const tokenIdentifier of tokenIdentifiers) {
       if (tokenIdentifier.length !== 32) {
@@ -29467,8 +28770,8 @@ var TokenTransactionService = class {
       this.config.getCoordinatorAddress()
     );
     let queryParams = {
-      issuerPublicKeys: issuerPublicKeys?.map(import_utils17.hexToBytes),
-      ownerPublicKeys: ownerPublicKeys?.map(import_utils17.hexToBytes),
+      issuerPublicKeys: issuerPublicKeys?.map(import_utils13.hexToBytes),
+      ownerPublicKeys: ownerPublicKeys?.map(import_utils13.hexToBytes),
       tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
         const { tokenIdentifier } = decodeBech32mTokenIdentifier(
           identifier,
@@ -29476,7 +28779,7 @@ var TokenTransactionService = class {
         );
         return tokenIdentifier;
       }),
-      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils17.hexToBytes),
+      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils13.hexToBytes),
       outputIds: outputIds || [],
       limit: pageSize,
       offset
@@ -29511,7 +28814,7 @@ var TokenTransactionService = class {
       });
     }
     const exactMatch = tokenOutputs.find(
-      (item) => (0, import_utils16.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
+      (item) => (0, import_utils12.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
     );
     if (exactMatch) {
       return [exactMatch];
@@ -29522,7 +28825,7 @@ var TokenTransactionService = class {
     for (const outputWithPreviousTransactionData of tokenOutputs) {
       if (remainingAmount <= 0n) break;
       selectedOutputs.push(outputWithPreviousTransactionData);
-      remainingAmount -= (0, import_utils16.bytesToNumberBE)(
+      remainingAmount -= (0, import_utils12.bytesToNumberBE)(
         outputWithPreviousTransactionData.output.tokenAmount
       );
     }
@@ -29537,22 +28840,22 @@ var TokenTransactionService = class {
   sortTokenOutputsByStrategy(tokenOutputs, strategy) {
     if (strategy === "SMALL_FIRST") {
       tokenOutputs.sort((a, b) => {
-        return Number(
-          (0, import_utils16.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils16.bytesToNumberBE)(b.output.tokenAmount)
-        );
+        const amountA = (0, import_utils12.bytesToNumberBE)(a.output.tokenAmount);
+        const amountB = (0, import_utils12.bytesToNumberBE)(b.output.tokenAmount);
+        return amountA < amountB ? -1 : amountA > amountB ? 1 : 0;
       });
     } else {
       tokenOutputs.sort((a, b) => {
-        return Number(
-          (0, import_utils16.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils16.bytesToNumberBE)(a.output.tokenAmount)
-        );
+        const amountA = (0, import_utils12.bytesToNumberBE)(a.output.tokenAmount);
+        const amountB = (0, import_utils12.bytesToNumberBE)(b.output.tokenAmount);
+        return amountB < amountA ? -1 : amountB > amountA ? 1 : 0;
       });
     }
   }
   // Helper function for deciding if the signer public key is the identity public key
   async signMessageWithKey(message, publicKey) {
     const tokenSignatures = this.config.getTokenSignatures();
-    if ((0, import_utils16.bytesToHex)(publicKey) === (0, import_utils16.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
+    if ((0, import_utils12.bytesToHex)(publicKey) === (0, import_utils12.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
       if (tokenSignatures === "SCHNORR") {
         return await this.config.signer.signSchnorrWithIdentityKey(message);
       } else {
@@ -29561,8 +28864,8 @@ var TokenTransactionService = class {
     } else {
       throw new ValidationError("Invalid public key", {
         field: "publicKey",
-        value: (0, import_utils16.bytesToHex)(publicKey),
-        expected: (0, import_utils16.bytesToHex)(await this.config.signer.getIdentityPublicKey())
+        value: (0, import_utils12.bytesToHex)(publicKey),
+        expected: (0, import_utils12.bytesToHex)(await this.config.signer.getIdentityPublicKey())
       });
     }
   }
@@ -29581,7 +28884,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils13.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -29603,7 +28906,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils13.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -29619,7 +28922,7 @@ var TokenTransactionService = class {
         for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils13.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let ownerSignature;
@@ -29636,315 +28939,1020 @@ var TokenTransactionService = class {
       }
       inputTtxoSignaturesPerOperator.push({
         ttxoSignatures,
-        operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
+        operatorIdentityPublicKey: (0, import_utils13.hexToBytes)(operator.identityPublicKey)
+      });
+    }
+    return inputTtxoSignaturesPerOperator;
+  }
+};
+
+// src/utils/adaptor-signature.ts
+init_buffer();
+var import_modular = require("@noble/curves/abstract/modular");
+var import_secp256k17 = require("@noble/curves/secp256k1");
+var import_utils14 = require("@noble/curves/utils");
+function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
+  const { r, s: s2 } = parseSignature(signature);
+  const sBigInt = (0, import_utils14.bytesToNumberBE)(s2);
+  const tBigInt = (0, import_utils14.bytesToNumberBE)(adaptorPrivateKeyBytes);
+  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k17.secp256k1.CURVE.n);
+  const newSignature = new Uint8Array([...r, ...(0, import_utils14.numberToBytesBE)(newS, 32)]);
+  return newSignature;
+}
+function generateAdaptorFromSignature(signature) {
+  const adaptorPrivateKey = import_secp256k17.secp256k1.utils.randomPrivateKey();
+  const { r, s: s2 } = parseSignature(signature);
+  const sBigInt = (0, import_utils14.bytesToNumberBE)(s2);
+  const tBigInt = (0, import_utils14.bytesToNumberBE)(adaptorPrivateKey);
+  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k17.secp256k1.CURVE.n);
+  const newSignature = new Uint8Array([...r, ...(0, import_utils14.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: s2 } = parseSignature(signature);
+  const sBigInt = (0, import_utils14.bytesToNumberBE)(s2);
+  const adaptorPrivateKey = (0, import_utils14.bytesToNumberBE)(adaptorPrivateKeyBytes);
+  const newS = (0, import_modular.mod)(sBigInt + adaptorPrivateKey, import_secp256k17.secp256k1.CURVE.n);
+  const newSig = new Uint8Array([...r, ...(0, import_utils14.numberToBytesBE)(newS, 32)]);
+  try {
+    if (import_secp256k17.schnorr.verify(newSig, hash, pubkey)) {
+      return newSig;
+    }
+  } catch (e) {
+    console.error("[applyAdaptorToSignature] Addition verification failed:", e);
+  }
+  const altS = (0, import_modular.mod)(sBigInt - adaptorPrivateKey, import_secp256k17.secp256k1.CURVE.n);
+  const altSig = new Uint8Array([...r, ...(0, import_utils14.numberToBytesBE)(altS, 32)]);
+  try {
+    if (import_secp256k17.schnorr.verify(altSig, hash, pubkey)) {
+      return altSig;
+    }
+  } catch (e) {
+    console.error(
+      "[applyAdaptorToSignature] Subtraction verification failed:",
+      e
+    );
+  }
+  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 = import_secp256k17.schnorr.utils.lift_x((0, import_utils14.bytesToNumberBE)(pubKeyBytes));
+  pubKey.assertValidity();
+  const { r, s: s2 } = parseSignature(signature);
+  const commitmenet = import_secp256k17.schnorr.utils.taggedHash(
+    "BIP0340/challenge",
+    r,
+    pubKey.toBytes().slice(1),
+    hash
+  );
+  if (commitmenet.length > 32) {
+    throw new Error("hash of (r || P || m) too big");
+  }
+  const e = (0, import_modular.mod)((0, import_utils14.bytesToNumberBE)(commitmenet), import_secp256k17.secp256k1.CURVE.n);
+  const negE = (0, import_modular.mod)(-e, import_secp256k17.secp256k1.CURVE.n);
+  const sG = import_secp256k17.secp256k1.Point.BASE.multiplyUnsafe((0, import_utils14.bytesToNumberBE)(s2));
+  const eP = pubKey.multiplyUnsafe(negE);
+  const R = sG.add(eP);
+  if (R.is0()) {
+    throw new Error("R is zero");
+  }
+  R.assertValidity();
+  const adaptorPoint = import_secp256k17.secp256k1.Point.fromHex(adaptorPubkey);
+  const newR = R.add(adaptorPoint);
+  if (!inbound && newR.equals(import_secp256k17.secp256k1.Point.ZERO)) {
+    throw new Error("calculated R point is the point at infinity");
+  }
+  newR.assertValidity();
+  if (newR.y % 2n !== 0n) {
+    throw new Error("calculated R y-value is odd");
+  }
+  const rNum = (0, import_utils14.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 s2 = signature.slice(32, 64);
+  if ((0, import_utils14.bytesToNumberBE)(r) >= import_secp256k17.secp256k1.CURVE.Fp.ORDER) {
+    throw new ValidationError("Invalid signature: r >= field prime", {
+      rValue: (0, import_utils14.bytesToNumberBE)(r),
+      fieldPrime: import_secp256k17.secp256k1.CURVE.Fp.ORDER
+    });
+  }
+  if ((0, import_utils14.bytesToNumberBE)(s2) >= import_secp256k17.secp256k1.CURVE.n) {
+    throw new ValidationError("Invalid signature: s >= group order", {
+      sValue: (0, import_utils14.bytesToNumberBE)(s2),
+      groupOrder: import_secp256k17.secp256k1.CURVE.n
+    });
+  }
+  return { r, s: s2 };
+}
+
+// src/spark-wallet/spark-wallet.ts
+var import_sha212 = require("@noble/hashes/sha2");
+var import_api = require("@opentelemetry/api");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_eventemitter3 = require("eventemitter3");
+var import_nice_grpc_common = require("nice-grpc-common");
+
+// src/constants.ts
+init_buffer();
+var import_core11 = require("@lightsparkdev/core");
+var isReactNative = "navigator" in globalThis && navigator.product === "ReactNative";
+var isBun = "Bun" in globalThis;
+var isWebExtension = (
+  /* globalThis.chrome actually exists in extension contexts for all browsers for legacy reasons: */
+  "chrome" in globalThis && globalThis.chrome.runtime?.id
+);
+var userAgent = "navigator" in globalThis ? globalThis.navigator.userAgent || "unknown-user-agent" : void 0;
+var packageVersion = true ? "0.3.7" : "unknown";
+var baseEnvStr = "unknown";
+if (isBun) {
+  const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
+  baseEnvStr = `bun/${bunVersion}`;
+} else if (import_core11.isNode) {
+  baseEnvStr = `node/${globalThis.process.version}`;
+} else if (isReactNative) {
+  baseEnvStr = "react-native";
+} else if (import_core11.isBare) {
+  const bareVersion = Bare.version;
+  baseEnvStr = `bare/${bareVersion}`;
+} else if (isWebExtension) {
+  const protocol = "location" in globalThis ? globalThis.location.protocol : "";
+  const extScriptType = "window" in globalThis ? "content-script" : "background-script";
+  baseEnvStr = `web-extension/${protocol.replace(":", "")}/${extScriptType}/${userAgent}`;
+} else {
+  baseEnvStr = `browser/${userAgent}`;
+}
+var clientEnv = `js-spark-sdk/${packageVersion} ${baseEnvStr}`;
+
+// src/services/signing.ts
+init_buffer();
+var import_utils15 = require("@noble/curves/utils");
+var SigningService = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async signRefundsInternal(refundTx, sighash, leaf, signingCommitments) {
+    const leafSigningJobs = [];
+    const signingCommitment = await this.config.signer.getRandomSigningCommitment();
+    if (!signingCommitments) {
+      throw new ValidationError("Invalid signing commitments", {
+        field: "signingNonceCommitments",
+        value: signingCommitments,
+        expected: "Non-null signing commitments"
+      });
+    }
+    const signingResult = await this.config.signer.signFrost({
+      message: sighash,
+      keyDerivation: leaf.keyDerivation,
+      publicKey: await this.config.signer.getPublicKeyFromDerivation(
+        leaf.keyDerivation
+      ),
+      selfCommitment: signingCommitment,
+      statechainCommitments: signingCommitments,
+      adaptorPubKey: new Uint8Array(),
+      verifyingKey: leaf.leaf.verifyingPublicKey
+    });
+    leafSigningJobs.push({
+      leafId: leaf.leaf.id,
+      signingPublicKey: await this.config.signer.getPublicKeyFromDerivation(
+        leaf.keyDerivation
+      ),
+      rawTx: refundTx.toBytes(),
+      signingNonceCommitment: signingCommitment.commitment,
+      userSignature: signingResult,
+      signingCommitments: {
+        signingCommitments
+      }
+    });
+    return leafSigningJobs;
+  }
+  async signRefunds(leaves, receiverIdentityPubkey, cpfpSigningCommitments, directSigningCommitments, directFromCpfpSigningCommitments) {
+    const cpfpLeafSigningJobs = [];
+    const directLeafSigningJobs = [];
+    const directFromCpfpLeafSigningJobs = [];
+    for (let i = 0; i < leaves.length; i++) {
+      const leaf = leaves[i];
+      if (!leaf?.leaf) {
+        throw new ValidationError("Leaf not found in signRefunds", {
+          field: "leaf",
+          value: leaf,
+          expected: "Non-null leaf"
+        });
+      }
+      const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
+      const cpfpNodeOutPoint = {
+        txid: (0, import_utils15.hexToBytes)(getTxId(nodeTx)),
+        index: 0
+      };
+      const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
+      const sequence = currRefundTx.getInput(0).sequence;
+      if (!sequence) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "sequence",
+          value: currRefundTx.getInput(0),
+          expected: "Non-null sequence"
+        });
+      }
+      const { nextSequence, nextDirectSequence } = getNextTransactionSequence(sequence);
+      const amountSats = currRefundTx.getOutput(0).amount;
+      if (amountSats === void 0) {
+        throw new ValidationError("Invalid refund transaction", {
+          field: "amount",
+          value: currRefundTx.getOutput(0),
+          expected: "Non-null amount"
+        });
+      }
+      let directNodeTx;
+      let directNodeOutPoint;
+      if (leaf.leaf.directTx.length > 0) {
+        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
+        directNodeOutPoint = {
+          txid: (0, import_utils15.hexToBytes)(getTxId(directNodeTx)),
+          index: 0
+        };
+      }
+      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
+        sequence: nextSequence,
+        directSequence: nextDirectSequence,
+        input: cpfpNodeOutPoint,
+        directInput: directNodeOutPoint,
+        amountSats,
+        receivingPubkey: receiverIdentityPubkey,
+        network: this.config.getNetwork()
+      });
+      const refundSighash = getSigHashFromTx(
+        cpfpRefundTx,
+        0,
+        nodeTx.getOutput(0)
+      );
+      const signingJobs = await this.signRefundsInternal(
+        cpfpRefundTx,
+        refundSighash,
+        leaf,
+        cpfpSigningCommitments[i]?.signingNonceCommitments
+      );
+      cpfpLeafSigningJobs.push(...signingJobs);
+      if (directRefundTx) {
+        if (!directNodeTx) {
+          throw new ValidationError(
+            "Direct node transaction undefined while direct refund transaction is defined",
+            {
+              field: "directNodeTx",
+              value: directNodeTx,
+              expected: "Non-null direct node transaction"
+            }
+          );
+        }
+        const refundSighash2 = getSigHashFromTx(
+          directRefundTx,
+          0,
+          directNodeTx.getOutput(0)
+        );
+        const signingJobs2 = await this.signRefundsInternal(
+          directRefundTx,
+          refundSighash2,
+          leaf,
+          directSigningCommitments[i]?.signingNonceCommitments
+        );
+        directLeafSigningJobs.push(...signingJobs2);
+      }
+      if (directFromCpfpRefundTx) {
+        if (!directNodeTx) {
+          throw new ValidationError(
+            "Direct node transaction undefined while direct from CPFP refund transaction is defined",
+            {
+              field: "directNodeTx",
+              value: directNodeTx,
+              expected: "Non-null direct node transaction"
+            }
+          );
+        }
+        const refundSighash2 = getSigHashFromTx(
+          directFromCpfpRefundTx,
+          0,
+          nodeTx.getOutput(0)
+        );
+        const signingJobs2 = await this.signRefundsInternal(
+          directFromCpfpRefundTx,
+          refundSighash2,
+          leaf,
+          directFromCpfpSigningCommitments[i]?.signingNonceCommitments
+        );
+        directFromCpfpLeafSigningJobs.push(...signingJobs2);
+      }
+    }
+    return {
+      cpfpLeafSigningJobs,
+      directLeafSigningJobs,
+      directFromCpfpLeafSigningJobs
+    };
+  }
+};
+
+// src/signer/signer.ts
+init_buffer();
+var import_secp256k110 = require("@bitcoinerlab/secp256k1");
+var import_secp256k111 = require("@noble/curves/secp256k1");
+var import_utils18 = require("@noble/curves/utils");
+var import_sha211 = require("@noble/hashes/sha2");
+var import_bip32 = require("@scure/bip32");
+var import_bip39 = require("@scure/bip39");
+var import_english = require("@scure/bip39/wordlists/english");
+var import_utils19 = require("@scure/btc-signer/utils");
+var ecies2 = __toESM(require("eciesjs"), 1);
+
+// src/utils/secret-sharing.ts
+init_buffer();
+var import_secp256k18 = require("@noble/curves/secp256k1");
+var import_utils16 = require("@noble/curves/utils");
+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 crypto = getCrypto();
+    const randBytes = crypto.getRandomValues(new Uint8Array(byteLength + 1));
+    const randValue = BigInt("0x" + (0, import_utils16.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, s2] = [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, s2] = [s2, old_s - quotient * s2];
+    [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] = import_secp256k18.secp256k1.Point.fromPrivateKey(secret).toBytes(true);
+  for (let i = 1; i < degree; i++) {
+    const coefficient = getRandomBigInt(fieldModulus);
+    coefficients[i] = coefficient;
+    proofs[i] = import_secp256k18.secp256k1.Point.fromPrivateKey(coefficient).toBytes(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 = import_secp256k18.secp256k1.Point.fromPrivateKey(share.share).toBytes(
+    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 = import_secp256k18.secp256k1.Point.fromHex(pubkey).multiply(value);
+    resultPubkey = import_secp256k18.secp256k1.Point.fromHex(resultPubkey).add(scaledPoint).toBytes(true);
+  }
+  if (!(0, import_utils16.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 bytes2 = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) {
+    bytes2[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes2;
+}
+
+// src/utils/signing.ts
+init_buffer();
+var import_secp256k19 = require("@noble/curves/secp256k1");
+function getRandomSigningNonce() {
+  const binding = import_secp256k19.secp256k1.utils.randomPrivateKey();
+  const hiding = import_secp256k19.secp256k1.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 = import_secp256k19.secp256k1.getPublicKey(nonce.binding, true);
+  const hidingPubKey = import_secp256k19.secp256k1.getPublicKey(nonce.hiding, true);
+  return {
+    binding: bindingPubKey,
+    hiding: hidingPubKey
+  };
+}
+function encodeSigningNonceToBytes(nonce) {
+  return new Uint8Array([...nonce.binding, ...nonce.hiding]);
+}
+function decodeBytesToSigningNonce(bytes2) {
+  if (bytes2.length !== 64) {
+    throw new ValidationError("Invalid nonce length", {
+      field: "bytes",
+      value: bytes2.length,
+      expected: "64 bytes (32 bytes for binding + 32 bytes for hiding)"
+    });
+  }
+  return {
+    binding: bytes2.slice(32, 64),
+    hiding: bytes2.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(bytes2) {
+  if (bytes2.length !== 66) {
+    throw new ValidationError("Invalid nonce commitment length", {
+      field: "bytes",
+      value: bytes2.length,
+      expected: "66 bytes (33 bytes for binding + 33 bytes for hiding)"
+    });
+  }
+  return {
+    binding: bytes2.slice(33, 66),
+    hiding: bytes2.slice(0, 33)
+  };
+}
+
+// src/signer/signer.ts
+var sparkFrostModule = void 0;
+var getSparkFrostModule = async () => {
+  if (isReactNative) {
+    return void 0;
+  }
+  if (!sparkFrostModule) {
+    sparkFrostModule = await Promise.resolve().then(() => (init_wasm(), wasm_exports));
+  }
+  return sparkFrostModule;
+};
+var HARDENED_OFFSET = 2147483648;
+var DefaultSparkKeysGenerator = class {
+  async deriveKeysFromSeed(seed, accountNumber) {
+    const hdkey = import_bip32.HDKey.fromMasterSeed(seed);
+    if (!hdkey.privateKey || !hdkey.publicKey) {
+      throw new ValidationError("Failed to derive keys from seed", {
+        field: "hdkey",
+        value: seed
+      });
+    }
+    const identityKey = hdkey.derive(`m/8797555'/${accountNumber}'/0'`);
+    const signingKey = hdkey.derive(`m/8797555'/${accountNumber}'/1'`);
+    const depositKey = hdkey.derive(`m/8797555'/${accountNumber}'/2'`);
+    const staticDepositKey = hdkey.derive(`m/8797555'/${accountNumber}'/3'`);
+    if (!identityKey.privateKey || !depositKey.privateKey || !signingKey.privateKey || !identityKey.publicKey || !depositKey.publicKey || !signingKey.publicKey || !staticDepositKey.privateKey || !staticDepositKey.publicKey) {
+      throw new ValidationError(
+        "Failed to derive all required keys from seed",
+        {
+          field: "derivedKeys"
+        }
+      );
+    }
+    return {
+      identityKey: {
+        privateKey: identityKey.privateKey,
+        publicKey: identityKey.publicKey
+      },
+      signingHDKey: {
+        hdKey: signingKey,
+        privateKey: signingKey.privateKey,
+        publicKey: signingKey.publicKey
+      },
+      depositKey: {
+        privateKey: depositKey.privateKey,
+        publicKey: depositKey.publicKey
+      },
+      staticDepositHDKey: {
+        hdKey: staticDepositKey,
+        privateKey: staticDepositKey.privateKey,
+        publicKey: staticDepositKey.publicKey
+      }
+    };
+  }
+};
+var DefaultSparkSigner = class {
+  identityKey = null;
+  signingKey = null;
+  depositKey = null;
+  staticDepositKey = null;
+  commitmentToNonceMap = /* @__PURE__ */ new Map();
+  keysGenerator;
+  constructor({
+    sparkKeysGenerator
+  } = {}) {
+    this.keysGenerator = sparkKeysGenerator ?? new DefaultSparkKeysGenerator();
+  }
+  deriveSigningKey(hash) {
+    if (!this.signingKey) {
+      throw new ValidationError("Private key not initialized", {
+        field: "signingKey"
+      });
+    }
+    const view = new DataView(hash.buffer);
+    const amount = view.getUint32(0, false) % HARDENED_OFFSET + HARDENED_OFFSET;
+    const newPrivateKey = this.signingKey?.deriveChild(amount).privateKey;
+    if (!newPrivateKey) {
+      throw new ValidationError("Failed to recover signing key", {
+        field: "privateKey"
+      });
+    }
+    return newPrivateKey;
+  }
+  async decryptEciesToPrivateKey(ciphertext) {
+    if (!this.identityKey?.privateKey) {
+      throw new ConfigurationError("Identity key not initialized", {
+        configKey: "identityKey"
       });
     }
-    return inputTtxoSignaturesPerOperator;
+    const receiverEciesPrivKey = ecies2.PrivateKey.fromHex(
+      (0, import_utils18.bytesToHex)(this.identityKey.privateKey)
+    );
+    const privateKey = ecies2.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
+    return privateKey;
   }
-};
-
-// src/utils/adaptor-signature.ts
-init_buffer();
-var import_modular = require("@noble/curves/abstract/modular");
-var import_secp256k111 = require("@noble/curves/secp256k1");
-var import_utils18 = require("@noble/curves/utils");
-function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
-  const { r, s: s2 } = parseSignature(signature);
-  const sBigInt = (0, import_utils18.bytesToNumberBE)(s2);
-  const tBigInt = (0, import_utils18.bytesToNumberBE)(adaptorPrivateKeyBytes);
-  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k111.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(newS, 32)]);
-  return newSignature;
-}
-function generateAdaptorFromSignature(signature) {
-  const adaptorPrivateKey = import_secp256k111.secp256k1.utils.randomPrivateKey();
-  const { r, s: s2 } = parseSignature(signature);
-  const sBigInt = (0, import_utils18.bytesToNumberBE)(s2);
-  const tBigInt = (0, import_utils18.bytesToNumberBE)(adaptorPrivateKey);
-  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k111.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils18.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: s2 } = parseSignature(signature);
-  const sBigInt = (0, import_utils18.bytesToNumberBE)(s2);
-  const adaptorPrivateKey = (0, import_utils18.bytesToNumberBE)(adaptorPrivateKeyBytes);
-  const newS = (0, import_modular.mod)(sBigInt + adaptorPrivateKey, import_secp256k111.secp256k1.CURVE.n);
-  const newSig = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(newS, 32)]);
-  try {
-    if (import_secp256k111.schnorr.verify(newSig, hash, pubkey)) {
-      return newSig;
+  async getSigningPrivateKeyFromDerivation(keyDerivation) {
+    switch (keyDerivation.type) {
+      case "leaf" /* LEAF */:
+        return this.deriveSigningKey((0, import_sha211.sha256)(keyDerivation.path));
+      case "deposit" /* DEPOSIT */:
+        return this.depositKey?.privateKey ?? new Uint8Array();
+      case "static_deposit" /* STATIC_DEPOSIT */:
+        return this.getStaticDepositSecretKey(keyDerivation.path);
+      case "ecies" /* ECIES */:
+        return this.decryptEciesToPrivateKey(keyDerivation.path);
+      case "random" /* RANDOM */:
+        return import_secp256k111.secp256k1.utils.randomPrivateKey();
     }
-  } catch (e) {
-    console.error("[applyAdaptorToSignature] Addition verification failed:", e);
   }
-  const altS = (0, import_modular.mod)(sBigInt - adaptorPrivateKey, import_secp256k111.secp256k1.CURVE.n);
-  const altSig = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(altS, 32)]);
-  try {
-    if (import_secp256k111.schnorr.verify(altSig, hash, pubkey)) {
-      return altSig;
+  async signSchnorrWithIdentityKey(message) {
+    if (!this.identityKey?.privateKey) {
+      throw new ValidationError("Private key not set", {
+        field: "identityKey"
+      });
     }
-  } catch (e) {
-    console.error(
-      "[applyAdaptorToSignature] Subtraction verification failed:",
-      e
-    );
+    const signature = import_secp256k111.schnorr.sign(message, this.identityKey.privateKey);
+    return signature;
   }
-  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)`);
+  async getIdentityPublicKey() {
+    if (!this.identityKey?.publicKey) {
+      throw new ValidationError("Private key is not set", {
+        field: "identityKey"
+      });
+    }
+    return this.identityKey.publicKey;
   }
-  const pubKey = import_secp256k111.schnorr.utils.lift_x((0, import_utils18.bytesToNumberBE)(pubKeyBytes));
-  pubKey.assertValidity();
-  const { r, s: s2 } = parseSignature(signature);
-  const commitmenet = import_secp256k111.schnorr.utils.taggedHash(
-    "BIP0340/challenge",
-    r,
-    pubKey.toBytes().slice(1),
-    hash
-  );
-  if (commitmenet.length > 32) {
-    throw new Error("hash of (r || P || m) too big");
+  async getDepositSigningKey() {
+    if (!this.depositKey?.publicKey) {
+      throw new ValidationError("Deposit key is not set", {
+        field: "depositKey"
+      });
+    }
+    return this.depositKey.publicKey;
   }
-  const e = (0, import_modular.mod)((0, import_utils18.bytesToNumberBE)(commitmenet), import_secp256k111.secp256k1.CURVE.n);
-  const negE = (0, import_modular.mod)(-e, import_secp256k111.secp256k1.CURVE.n);
-  const sG = import_secp256k111.secp256k1.Point.BASE.multiplyUnsafe((0, import_utils18.bytesToNumberBE)(s2));
-  const eP = pubKey.multiplyUnsafe(negE);
-  const R = sG.add(eP);
-  if (R.is0()) {
-    throw new Error("R is zero");
+  async getStaticDepositSigningKey(idx) {
+    const staticDepositKey = await this.getStaticDepositSecretKey(idx);
+    return import_secp256k111.secp256k1.getPublicKey(staticDepositKey);
   }
-  R.assertValidity();
-  const adaptorPoint = import_secp256k111.secp256k1.Point.fromHex(adaptorPubkey);
-  const newR = R.add(adaptorPoint);
-  if (!inbound && newR.equals(import_secp256k111.secp256k1.Point.ZERO)) {
-    throw new Error("calculated R point is the point at infinity");
+  async getStaticDepositSecretKey(idx) {
+    if (!this.staticDepositKey) {
+      throw new ValidationError("Static deposit key is not set", {
+        field: "staticDepositKey"
+      });
+    }
+    const staticDepositKey = this.staticDepositKey.deriveChild(
+      HARDENED_OFFSET + idx
+    );
+    if (!staticDepositKey?.privateKey) {
+      throw new ValidationError("Static deposit key is not set", {
+        field: "staticDepositKey"
+      });
+    }
+    return staticDepositKey.privateKey;
   }
-  newR.assertValidity();
-  if (newR.y % 2n !== 0n) {
-    throw new Error("calculated R y-value is odd");
+  async generateMnemonic() {
+    return (0, import_bip39.generateMnemonic)(import_english.wordlist);
   }
-  const rNum = (0, import_utils18.bytesToNumberBE)(r);
-  if (newR.toAffine().x !== rNum) {
-    throw new Error("calculated R point was not given R");
+  async mnemonicToSeed(mnemonic) {
+    return await (0, import_bip39.mnemonicToSeed)(mnemonic);
   }
-  return true;
-}
-function parseSignature(signature) {
-  if (signature.length < 64) {
-    throw new ValidationError("Signature too short", {
-      expectedLength: 64,
-      actualLength: signature.length
-    });
+  async getPublicKeyFromDerivation(keyDerivation) {
+    const privateKey = await this.getSigningPrivateKeyFromDerivation(keyDerivation);
+    return import_secp256k111.secp256k1.getPublicKey(privateKey);
   }
-  if (signature.length > 64) {
-    throw new ValidationError("Signature too long", {
-      expectedLength: 64,
-      actualLength: signature.length
-    });
+  async subtractPrivateKeysGivenDerivationPaths(first, second) {
+    const firstPrivateKey = this.deriveSigningKey((0, import_sha211.sha256)(first));
+    const secondPrivateKey = this.deriveSigningKey((0, import_sha211.sha256)(second));
+    const resultPrivKey = subtractPrivateKeys(
+      firstPrivateKey,
+      secondPrivateKey
+    );
+    const resultPubKey = import_secp256k111.secp256k1.getPublicKey(resultPrivKey);
+    return resultPubKey;
   }
-  const r = signature.slice(0, 32);
-  const s2 = signature.slice(32, 64);
-  if ((0, import_utils18.bytesToNumberBE)(r) >= import_secp256k111.secp256k1.CURVE.Fp.ORDER) {
-    throw new ValidationError("Invalid signature: r >= field prime", {
-      rValue: (0, import_utils18.bytesToNumberBE)(r),
-      fieldPrime: import_secp256k111.secp256k1.CURVE.Fp.ORDER
+  async subtractAndSplitSecretWithProofsGivenDerivations({
+    first,
+    second,
+    curveOrder,
+    threshold,
+    numShares
+  }) {
+    const firstPrivateKey = await this.getSigningPrivateKeyFromDerivation(first);
+    const secondPrivateKey = await this.getSigningPrivateKeyFromDerivation(second);
+    const resultPrivKey = subtractPrivateKeys(
+      firstPrivateKey,
+      secondPrivateKey
+    );
+    return await this.splitSecretWithProofs({
+      secret: resultPrivKey,
+      curveOrder,
+      threshold,
+      numShares
     });
   }
-  if ((0, import_utils18.bytesToNumberBE)(s2) >= import_secp256k111.secp256k1.CURVE.n) {
-    throw new ValidationError("Invalid signature: s >= group order", {
-      sValue: (0, import_utils18.bytesToNumberBE)(s2),
-      groupOrder: import_secp256k111.secp256k1.CURVE.n
-    });
+  async subtractSplitAndEncrypt({
+    first,
+    second,
+    curveOrder,
+    threshold,
+    numShares,
+    receiverPublicKey
+  }) {
+    const firstPrivateKey = await this.getSigningPrivateKeyFromDerivation(first);
+    const secondPrivateKey = await this.getSigningPrivateKeyFromDerivation(second);
+    const resultPrivKey = subtractPrivateKeys(
+      firstPrivateKey,
+      secondPrivateKey
+    );
+    return {
+      shares: await this.splitSecretWithProofs({
+        secret: resultPrivKey,
+        curveOrder,
+        threshold,
+        numShares
+      }),
+      secretCipher: ecies2.encrypt(receiverPublicKey, secondPrivateKey)
+    };
   }
-  return { r, s: s2 };
-}
-
-// src/spark-wallet/spark-wallet.ts
-var import_sha212 = require("@noble/hashes/sha2");
-var import_api = require("@opentelemetry/api");
-var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
-var import_eventemitter3 = require("eventemitter3");
-var import_nice_grpc_common = require("nice-grpc-common");
-
-// src/services/signing.ts
-init_buffer();
-var import_utils19 = require("@noble/curves/utils");
-var SigningService = class {
-  config;
-  constructor(config) {
-    this.config = config;
+  async splitSecretWithProofs({
+    secret,
+    curveOrder,
+    threshold,
+    numShares
+  }) {
+    const secretAsInt = (0, import_utils18.bytesToNumberBE)(secret);
+    return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
   }
-  async signRefundsInternal(refundTx, sighash, leaf, signingCommitments) {
-    const leafSigningJobs = [];
-    const signingCommitment = await this.config.signer.getRandomSigningCommitment();
-    if (!signingCommitments) {
-      throw new ValidationError("Invalid signing commitments", {
-        field: "signingNonceCommitments",
-        value: signingCommitments,
-        expected: "Non-null signing commitments"
+  async signFrost({
+    message,
+    keyDerivation,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey
+  }) {
+    const SparkFrost = await getSparkFrostModule();
+    if (!SparkFrost) {
+      throw new ValidationError("SparkFrost module not found", {
+        field: "SparkFrost"
       });
     }
-    const signingResult = await this.config.signer.signFrost({
-      message: sighash,
-      keyDerivation: leaf.keyDerivation,
-      publicKey: await this.config.signer.getPublicKeyFromDerivation(
-        leaf.keyDerivation
-      ),
-      selfCommitment: signingCommitment,
-      statechainCommitments: signingCommitments,
-      adaptorPubKey: new Uint8Array(),
-      verifyingKey: leaf.leaf.verifyingPublicKey
+    const signingPrivateKey = await this.getSigningPrivateKeyFromDerivation(keyDerivation);
+    if (!signingPrivateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey"
+      });
+    }
+    const commitment = selfCommitment.commitment;
+    const nonce = this.commitmentToNonceMap.get(commitment);
+    if (!nonce) {
+      throw new ValidationError("Nonce not found for commitment", {
+        field: "nonce"
+      });
+    }
+    const keyPackage = {
+      secretKey: signingPrivateKey,
+      publicKey,
+      verifyingKey
+    };
+    const logMessage = (0, import_utils18.bytesToHex)(message);
+    const result = await SparkFrost.signFrost({
+      message,
+      keyPackage,
+      nonce,
+      selfCommitment: commitment,
+      statechainCommitments,
+      adaptorPubKey
     });
-    leafSigningJobs.push({
-      leafId: leaf.leaf.id,
-      signingPublicKey: await this.config.signer.getPublicKeyFromDerivation(
-        leaf.keyDerivation
-      ),
-      rawTx: refundTx.toBytes(),
-      signingNonceCommitment: signingCommitment.commitment,
-      userSignature: signingResult,
-      signingCommitments: {
-        signingCommitments
-      }
+    return result;
+  }
+  async aggregateFrost({
+    message,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey,
+    selfSignature,
+    statechainSignatures,
+    statechainPublicKeys
+  }) {
+    const SparkFrost = await getSparkFrostModule();
+    if (!SparkFrost) {
+      throw new ValidationError("SparkFrost module not found", {
+        field: "SparkFrost"
+      });
+    }
+    return SparkFrost.aggregateFrost({
+      message,
+      statechainSignatures,
+      statechainPublicKeys,
+      verifyingKey,
+      statechainCommitments,
+      selfCommitment: selfCommitment.commitment,
+      selfPublicKey: publicKey,
+      selfSignature,
+      adaptorPubKey
     });
-    return leafSigningJobs;
   }
-  async signRefunds(leaves, receiverIdentityPubkey, cpfpSigningCommitments, directSigningCommitments, directFromCpfpSigningCommitments) {
-    const cpfpLeafSigningJobs = [];
-    const directLeafSigningJobs = [];
-    const directFromCpfpLeafSigningJobs = [];
-    for (let i = 0; i < leaves.length; i++) {
-      const leaf = leaves[i];
-      if (!leaf?.leaf) {
-        throw new ValidationError("Leaf not found in signRefunds", {
-          field: "leaf",
-          value: leaf,
-          expected: "Non-null leaf"
-        });
-      }
-      const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
-      const cpfpNodeOutPoint = {
-        txid: (0, import_utils19.hexToBytes)(getTxId(nodeTx)),
-        index: 0
-      };
-      const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
-      const sequence = currRefundTx.getInput(0).sequence;
-      if (!sequence) {
-        throw new ValidationError("Invalid refund transaction", {
-          field: "sequence",
-          value: currRefundTx.getInput(0),
-          expected: "Non-null sequence"
-        });
-      }
-      const { nextSequence, nextDirectSequence } = getNextTransactionSequence(sequence);
-      const amountSats = currRefundTx.getOutput(0).amount;
-      if (amountSats === void 0) {
-        throw new ValidationError("Invalid refund transaction", {
-          field: "amount",
-          value: currRefundTx.getOutput(0),
-          expected: "Non-null amount"
-        });
-      }
-      let directNodeTx;
-      let directNodeOutPoint;
-      if (leaf.leaf.directTx.length > 0) {
-        directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
-        directNodeOutPoint = {
-          txid: (0, import_utils19.hexToBytes)(getTxId(directNodeTx)),
-          index: 0
-        };
-      }
-      const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
-        sequence: nextSequence,
-        directSequence: nextDirectSequence,
-        input: cpfpNodeOutPoint,
-        directInput: directNodeOutPoint,
-        amountSats,
-        receivingPubkey: receiverIdentityPubkey,
-        network: this.config.getNetwork()
+  async createSparkWalletFromSeed(seed, accountNumber) {
+    if (typeof seed === "string") {
+      seed = (0, import_utils18.hexToBytes)(seed);
+    }
+    const {
+      identityKey,
+      signingHDKey: signingKey,
+      depositKey,
+      staticDepositHDKey: staticDepositKey
+    } = await this.keysGenerator.deriveKeysFromSeed(seed, accountNumber ?? 0);
+    this.identityKey = identityKey;
+    this.depositKey = depositKey;
+    this.signingKey = signingKey.hdKey;
+    this.staticDepositKey = staticDepositKey.hdKey;
+    return (0, import_utils18.bytesToHex)(identityKey.publicKey);
+  }
+  async signMessageWithIdentityKey(message, compact) {
+    if (!this.identityKey?.privateKey) {
+      throw new ConfigurationError("Identity key not initialized", {
+        configKey: "identityKey"
+      });
+    }
+    const signature = import_secp256k111.secp256k1.sign(message, this.identityKey.privateKey);
+    if (compact) {
+      return signature.toCompactRawBytes();
+    }
+    return signature.toDERRawBytes();
+  }
+  async decryptEcies(ciphertext) {
+    if (!this.identityKey?.privateKey) {
+      throw new ConfigurationError("Identity key not initialized", {
+        configKey: "identityKey"
       });
-      const refundSighash = getSigHashFromTx(
-        cpfpRefundTx,
-        0,
-        nodeTx.getOutput(0)
-      );
-      const signingJobs = await this.signRefundsInternal(
-        cpfpRefundTx,
-        refundSighash,
-        leaf,
-        cpfpSigningCommitments[i]?.signingNonceCommitments
-      );
-      cpfpLeafSigningJobs.push(...signingJobs);
-      if (directRefundTx) {
-        if (!directNodeTx) {
-          throw new ValidationError(
-            "Direct node transaction undefined while direct refund transaction is defined",
-            {
-              field: "directNodeTx",
-              value: directNodeTx,
-              expected: "Non-null direct node transaction"
-            }
-          );
-        }
-        const refundSighash2 = getSigHashFromTx(
-          directRefundTx,
-          0,
-          directNodeTx.getOutput(0)
-        );
-        const signingJobs2 = await this.signRefundsInternal(
-          directRefundTx,
-          refundSighash2,
-          leaf,
-          directSigningCommitments[i]?.signingNonceCommitments
-        );
-        directLeafSigningJobs.push(...signingJobs2);
-      }
-      if (directFromCpfpRefundTx) {
-        if (!directNodeTx) {
-          throw new ValidationError(
-            "Direct node transaction undefined while direct from CPFP refund transaction is defined",
-            {
-              field: "directNodeTx",
-              value: directNodeTx,
-              expected: "Non-null direct node transaction"
-            }
-          );
-        }
-        const refundSighash2 = getSigHashFromTx(
-          directFromCpfpRefundTx,
-          0,
-          nodeTx.getOutput(0)
-        );
-        const signingJobs2 = await this.signRefundsInternal(
-          directFromCpfpRefundTx,
-          refundSighash2,
-          leaf,
-          directFromCpfpSigningCommitments[i]?.signingNonceCommitments
-        );
-        directFromCpfpLeafSigningJobs.push(...signingJobs2);
-      }
     }
+    const receiverEciesPrivKey = ecies2.PrivateKey.fromHex(
+      (0, import_utils18.bytesToHex)(this.identityKey.privateKey)
+    );
+    const privateKey = ecies2.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
+    const publicKey = import_secp256k111.secp256k1.getPublicKey(privateKey);
+    return publicKey;
+  }
+  async getRandomSigningCommitment() {
+    const nonce = getRandomSigningNonce();
+    const commitment = getSigningCommitmentFromNonce(nonce);
+    this.commitmentToNonceMap.set(commitment, nonce);
     return {
-      cpfpLeafSigningJobs,
-      directLeafSigningJobs,
-      directFromCpfpLeafSigningJobs
+      commitment
     };
   }
+  async validateMessageWithIdentityKey(message, signature) {
+    if (!this.identityKey?.publicKey) {
+      throw new ConfigurationError("Identity key not initialized", {
+        configKey: "identityKey"
+      });
+    }
+    return import_secp256k111.secp256k1.verify(signature, message, this.identityKey.publicKey);
+  }
+  signTransactionIndex(tx, index, publicKey) {
+    let privateKey;
+    if ((0, import_utils18.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.identityKey?.privateKey;
+    } else if ((0, import_utils18.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.depositKey?.privateKey;
+    }
+    if (!privateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey",
+        value: (0, import_utils18.bytesToHex)(publicKey)
+      });
+    }
+    tx.signIdx(privateKey, index);
+  }
 };
 
 // src/tests/utils/test-faucet.ts
@@ -29965,7 +29973,7 @@ var COIN_AMOUNT = 10000000n;
 var FEE_AMOUNT = 1000n;
 var TARGET_NUM_COINS = 20;
 var BitcoinFaucet = class _BitcoinFaucet {
-  constructor(url = "http://127.0.0.1:8332", username = "testutil", password = "testutilpassword") {
+  constructor(url, username, password) {
     this.url = url;
     this.username = username;
     this.password = password;
@@ -29978,8 +29986,11 @@ var BitcoinFaucet = class _BitcoinFaucet {
   static instance = null;
   miningAddress;
   lock = Promise.resolve();
-  static getInstance(url = "http://127.0.0.1:8332", username = "testutil", password = "testutilpassword") {
+  static getInstance() {
     if (!_BitcoinFaucet.instance) {
+      const url = process.env.BITCOIN_RPC_URL || (process.env.MINIKUBE_IP ? `http://${process.env.MINIKUBE_IP}:8332` : "http://127.0.0.1:8332");
+      const username = process.env.BITCOIN_RPC_USER || "testutil";
+      const password = process.env.BITCOIN_RPC_PASSWORD || "testutilpassword";
       _BitcoinFaucet.instance = new _BitcoinFaucet(url, username, password);
     }
     return _BitcoinFaucet.instance;
@@ -30308,6 +30319,76 @@ function chunkArray(arr, size) {
   return chunks;
 }
 
+// src/utils/optimize.ts
+init_buffer();
+var DENOMINATIONS = Array.from({ length: 28 }, (_, i) => 2 ** i);
+function assert(condition, message) {
+  if (!condition) {
+    throw new InternalValidationError(message || "Assertion failed");
+  }
+}
+function sum(arr) {
+  return arr.reduce((a, b) => a + b, 0);
+}
+function sorted(arr) {
+  return [...arr].sort((a, b) => a - b);
+}
+function equals(a, b) {
+  return a.length === b.length && a.every((val, index) => val === b[index]);
+}
+function greedyLeaves(amount) {
+  const leaves = [];
+  let remaining = amount;
+  for (let i = DENOMINATIONS.length - 1; i >= 0; i--) {
+    const leaf = DENOMINATIONS[i];
+    if (typeof leaf === "number" && leaf > 0) {
+      while (remaining >= leaf) {
+        remaining -= leaf;
+        leaves.push(leaf);
+      }
+    }
+  }
+  assert(sum(leaves) === amount, "greedy_leaves: sum mismatch");
+  return sorted(leaves);
+}
+var Swap = class {
+  inLeaves;
+  outLeaves;
+  constructor(inLeaves, outLeaves) {
+    this.inLeaves = [...inLeaves];
+    this.outLeaves = [...outLeaves];
+    assert(
+      sum(this.inLeaves) === sum(this.outLeaves),
+      "Swap in/out leaves must sum to same value for swap: " + this.toString()
+    );
+  }
+  toString() {
+    return `Swap(in=${JSON.stringify(this.inLeaves)}, out=${JSON.stringify(this.outLeaves)})`;
+  }
+};
+function maximizeUnilateralExit(inputLeaves, maxLeavesPerSwap = 64) {
+  const swaps = [];
+  let batch = [];
+  let leaves = sorted(inputLeaves);
+  while (leaves.length > 0) {
+    batch.push(leaves.shift());
+    const target = greedyLeaves(sum(batch));
+    if (batch.length >= maxLeavesPerSwap || target.length >= maxLeavesPerSwap) {
+      if (!equals(target, batch)) {
+        swaps.push(new Swap([...batch], target));
+      }
+      batch = [];
+    }
+  }
+  if (batch.length > 0) {
+    const target = greedyLeaves(sum(batch));
+    if (!equals(target, batch)) {
+      swaps.push(new Swap([...batch], target));
+    }
+  }
+  return swaps;
+}
+
 // src/utils/retry.ts
 init_buffer();
 var DEFAULT_RETRY_CONFIG = {
@@ -30411,8 +30492,9 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
   // Add this property near the top of the class with other private properties
   claimTransfersInterval = null;
   tracer = null;
-  constructor(options, signer) {
+  constructor(options, signerArg) {
     super();
+    const signer = signerArg || this.buildSigner();
     this.config = new WalletConfigService(options, signer);
     this.connectionManager = this.buildConnectionManager(this.config);
     this.signingService = new SigningService(this.config);
@@ -30470,6 +30552,9 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
     }
     return this.sspClient;
   }
+  buildSigner() {
+    return new DefaultSparkSigner();
+  }
   buildConnectionManager(config) {
     return new ConnectionManager(config);
   }
@@ -30831,8 +30916,34 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
     await this.withLeaves(async () => {
       this.optimizationInProgress = true;
       try {
-        if (this.leaves.length > 0) {
-          await this.requestLeavesSwap({ leaves: this.leaves });
+        this.leaves = await this.getLeaves();
+        const swaps = maximizeUnilateralExit(
+          this.leaves.map((leaf) => leaf.value)
+        );
+        const valueToNodes = /* @__PURE__ */ new Map();
+        this.leaves.forEach((leaf) => {
+          if (!valueToNodes.has(leaf.value)) {
+            valueToNodes.set(leaf.value, []);
+          }
+          valueToNodes.get(leaf.value).push(leaf);
+        });
+        for (const swap of swaps) {
+          const leavesToSend = [];
+          for (const leafValue of swap.inLeaves) {
+            const nodes = valueToNodes.get(leafValue);
+            if (nodes && nodes.length > 0) {
+              const node = nodes.shift();
+              leavesToSend.push(node);
+            } else {
+              throw new InternalValidationError(
+                `No unused leaf with value ${leafValue} found in leaves`
+              );
+            }
+          }
+          await this.requestLeavesSwap({
+            leaves: leavesToSend,
+            targetAmounts: swap.outLeaves
+          });
         }
         this.leaves = await this.getLeaves();
       } finally {
@@ -31403,6 +31514,10 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
         directSignatureMap,
         directFromCpfpSignatureMap
       );
+      const leavesToRemove = new Set(leavesBatch.map((leaf) => leaf.id));
+      this.leaves = [
+        ...this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id))
+      ];
       const completeResponse = await sspClient.completeLeaveSwap({
         adaptorSecretKey: (0, import_utils23.bytesToHex)(cpfpAdaptorPrivateKey),
         directAdaptorSecretKey: (0, import_utils23.bytesToHex)(directAdaptorPrivateKey),
@@ -31991,7 +32106,7 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
     creditAmountView.setUint32(4, upperHalf, true);
     parts.push(new Uint8Array(creditAmountBuffer));
     parts.push((0, import_utils23.hexToBytes)(sspSignature));
-    const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
+    const totalLength = parts.reduce((sum2, part) => sum2 + part.length, 0);
     const payload = new Uint8Array(totalLength);
     let offset = 0;
     for (const part of parts) {
@@ -33087,8 +33202,8 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
       );
       const sspResponse = await sspClient.requestLightningSend({
         encodedInvoice: invoice,
-        idempotencyKey: (0, import_uuidv75.uuidv7)(),
-        amountSats: isZeroAmountInvoice ? amountSatsToSend : void 0
+        amountSats: isZeroAmountInvoice ? amountSatsToSend : void 0,
+        userOutboundTransferExternalId: swapResponse.transfer.id
       });
       if (!sspResponse) {
         throw new Error("Failed to contact SSP");
@@ -33394,12 +33509,13 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
         }
       }))
     );
+    const transferId = (0, import_uuidv75.uuidv7)();
     const requestCoopExitParams = {
       leafExternalIds: leavesToSendToSsp.map((leaf) => leaf.id),
       withdrawalAddress: onchainAddress,
-      idempotencyKey: (0, import_uuidv75.uuidv7)(),
       exitSpeed,
-      withdrawAll: deductFeeFromWithdrawalAmount
+      withdrawAll: deductFeeFromWithdrawalAmount,
+      userOutboundTransferExternalId: transferId
     };
     if (!deductFeeFromWithdrawalAmount) {
       requestCoopExitParams.feeQuoteId = feeEstimate.id;
@@ -33434,11 +33550,11 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
       leaves: leafKeyTweaks,
       exitTxId: coopExitTxId,
       connectorOutputs,
-      receiverPubKey: sspPubIdentityKey
+      receiverPubKey: sspPubIdentityKey,
+      transferId
     });
     const completeResponse = await sspClient.completeCoopExit({
-      userOutboundTransferExternalId: transfer.transfer.id,
-      coopExitRequestId: coopExitRequest.id
+      userOutboundTransferExternalId: transfer.transfer.id
     });
     return completeResponse;
   }
@@ -34160,7 +34276,6 @@ var SparkWallet = class extends import_eventemitter3.EventEmitter {
     const consoleOptions = wallet.config.getConsoleOptions();
     const spanProcessors = [];
     if (consoleOptions.otel) {
-      console.log("OpenTelemetry client logging enabled.");
       spanProcessors.push(new import_sdk_trace_base.SimpleSpanProcessor(new import_sdk_trace_base.ConsoleSpanExporter()));
     }
     const traceUrls = this.getOtelTraceUrls();
@@ -34353,7 +34468,6 @@ var SparkWalletBrowser = class extends SparkWallet {
     spanProcessors,
     traceUrls
   }) {
-    console.log("initializeTracerEnvBrowser");
     initializeTracerEnvBrowser({ spanProcessors, traceUrls });
   }
 };