@buildonspark/spark-sdk 0.2.10 → 0.2.11

package/dist/debug.cjs

@@ -1043,6 +1043,43 @@ var init_spark_bindings = __esm({
   }
 });
 
+// src/utils/logging.ts
+var import_core11, LOGGER_NAMES, SparkSdkLogger;
+var init_logging = __esm({
+  "src/utils/logging.ts"() {
+    "use strict";
+    init_buffer();
+    import_core11 = require("@lightsparkdev/core");
+    LOGGER_NAMES = {
+      wasm: "wasm"
+    };
+    SparkSdkLogger = class {
+      static loggers = /* @__PURE__ */ new Map();
+      static get(name) {
+        if (!this.loggers.has(name)) {
+          this.loggers.set(name, new import_core11.Logger(name));
+        }
+        return this.loggers.get(name);
+      }
+      static setLevel(name, level) {
+        this.get(name).setLevel(level);
+      }
+      static setAllLevels(level) {
+        this.loggers.forEach((logger) => logger.setLevel(level));
+      }
+      static setEnabled(name, enabled) {
+        this.get(name).setEnabled(enabled);
+      }
+      static setAllEnabled(enabled) {
+        this.loggers.forEach((logger) => logger.setEnabled(enabled));
+      }
+      static {
+        Object.values(LOGGER_NAMES).forEach((name) => this.get(name));
+      }
+    };
+  }
+});
+
 // src/spark_bindings/wasm/index.ts
 var wasm_exports = {};
 __export(wasm_exports, {
@@ -1073,6 +1110,13 @@ function signFrost({
   statechainCommitments,
   adaptorPubKey
 }) {
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", {
+    message: (0, import_utils4.bytesToHex)(message),
+    keyPackage,
+    nonce,
+    selfCommitment,
+    statechainCommitments
+  });
   return wasm_sign_frost(
     message,
     createKeyPackage(keyPackage),
@@ -1093,6 +1137,17 @@ function aggregateFrost({
   verifyingKey,
   adaptorPubKey
 }) {
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("aggregateFrost", {
+    message: (0, import_utils4.bytesToHex)(message),
+    statechainCommitments,
+    selfCommitment,
+    statechainSignatures,
+    selfSignature: (0, import_utils4.bytesToHex)(selfSignature),
+    statechainPublicKeys,
+    selfPublicKey: (0, import_utils4.bytesToHex)(selfPublicKey),
+    verifyingKey: (0, import_utils4.bytesToHex)(verifyingKey),
+    adaptorPubKey: adaptorPubKey ? (0, import_utils4.bytesToHex)(adaptorPubKey) : void 0
+  });
   return wasm_aggregate_frost(
     message,
     statechainCommitments,
@@ -1123,11 +1178,14 @@ function decryptEcies({
 }) {
   return decrypt_ecies(encryptedMsg, privateKey);
 }
+var import_utils4;
 var init_wasm = __esm({
   "src/spark_bindings/wasm/index.ts"() {
     "use strict";
     init_buffer();
+    import_utils4 = require("@noble/curves/utils");
     init_spark_bindings();
+    init_logging();
   }
 });
 
@@ -1201,7 +1259,7 @@ function XHRTransport(config) {
         bodyBuffer = chunk;
         break;
       }
-      requestBody = bodyBuffer;
+      requestBody = bodyBuffer.slice();
     } else {
       let iterator;
       requestBody = new ReadableStream({
@@ -1215,7 +1273,7 @@ function XHRTransport(config) {
           if (done) {
             controller.close();
           } else {
-            controller.enqueue(value);
+            controller.enqueue(value.slice());
           }
         },
         async cancel() {
@@ -1315,8 +1373,8 @@ init_buffer();
 
 // src/spark-wallet/spark-wallet.ts
 init_buffer();
-var import_core12 = require("@lightsparkdev/core");
-var import_utils23 = require("@noble/curves/abstract/utils");
+var import_core13 = require("@lightsparkdev/core");
+var import_utils24 = require("@noble/curves/abstract/utils");
 var import_secp256k115 = require("@noble/curves/secp256k1");
 var import_bip392 = require("@scure/bip39");
 var import_english2 = require("@scure/bip39/wordlists/english");
@@ -17670,13 +17728,13 @@ init_buffer();
 // src/signer/signer.ts
 init_buffer();
 var import_secp256k14 = require("@bitcoinerlab/secp256k1");
-var import_utils4 = require("@noble/curves/abstract/utils");
+var import_utils5 = require("@noble/curves/abstract/utils");
 var import_secp256k15 = require("@noble/curves/secp256k1");
 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_utils5 = require("@scure/btc-signer/utils");
+var import_utils6 = require("@scure/btc-signer/utils");
 var ecies = __toESM(require("eciesjs"), 1);
 
 // src/constants.ts
@@ -17684,7 +17742,7 @@ init_buffer();
 var import_core10 = require("@lightsparkdev/core");
 var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 var isBun = globalThis.Bun !== void 0;
-var packageVersion = true ? "0.2.10" : "unknown";
+var packageVersion = true ? "0.2.11" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -17714,9 +17772,9 @@ function addPublicKeys(a, b) {
       expected: 33
     });
   }
-  const pubkeyA = import_secp256k1.secp256k1.ProjectivePoint.fromHex(a);
-  const pubkeyB = import_secp256k1.secp256k1.ProjectivePoint.fromHex(b);
-  return pubkeyA.add(pubkeyB).toRawBytes(true);
+  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) {
@@ -17733,11 +17791,11 @@ function applyAdditiveTweakToPublicKey(pubkey, tweak) {
       expected: 32
     });
   }
-  const pubkeyPoint = import_secp256k1.secp256k1.ProjectivePoint.fromHex(pubkey);
+  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.ProjectivePoint.fromHex(pubTweek);
-  return pubkeyPoint.add(tweekPoint).toRawBytes(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) {
@@ -17747,9 +17805,9 @@ function subtractPublicKeys(a, b) {
       expected: 33
     });
   }
-  const pubkeyA = import_secp256k1.secp256k1.ProjectivePoint.fromHex(a);
-  const pubkeyB = import_secp256k1.secp256k1.ProjectivePoint.fromHex(b);
-  return pubkeyA.subtract(pubkeyB).toRawBytes(true);
+  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) {
@@ -17904,11 +17962,11 @@ function generatePolynomialForSecretSharing(fieldModulus, secret, degree) {
   const coefficients = new Array(degree);
   const proofs = new Array(degree);
   coefficients[0] = secret;
-  proofs[0] = import_secp256k12.secp256k1.ProjectivePoint.fromPrivateKey(secret).toRawBytes(true);
+  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.ProjectivePoint.fromPrivateKey(coefficient).toRawBytes(true);
+    proofs[i] = import_secp256k12.secp256k1.Point.fromPrivateKey(coefficient).toBytes(true);
   }
   return {
     fieldModulus,
@@ -17980,9 +18038,9 @@ function recoverSecret(shares) {
   return result;
 }
 function validateShare(share) {
-  const targetPubkey = import_secp256k12.secp256k1.ProjectivePoint.fromPrivateKey(
-    share.share
-  ).toRawBytes(true);
+  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", {
@@ -18001,8 +18059,8 @@ function validateShare(share) {
       });
     }
     const value = share.index ** BigInt(i) % share.fieldModulus;
-    const scaledPoint = import_secp256k12.secp256k1.ProjectivePoint.fromHex(pubkey).multiply(value);
-    resultPubkey = import_secp256k12.secp256k1.ProjectivePoint.fromHex(resultPubkey).add(scaledPoint).toRawBytes(true);
+    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", {
@@ -18196,7 +18254,7 @@ var DefaultSparkSigner = class {
       });
     }
     const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils4.bytesToHex)(this.identityKey.privateKey)
+      (0, import_utils5.bytesToHex)(this.identityKey.privateKey)
     );
     const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
     return privateKey;
@@ -18330,7 +18388,7 @@ var DefaultSparkSigner = class {
     threshold,
     numShares
   }) {
-    const secretAsInt = (0, import_utils4.bytesToNumberBE)(secret);
+    const secretAsInt = (0, import_utils5.bytesToNumberBE)(secret);
     return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
   }
   async signFrost({
@@ -18366,7 +18424,7 @@ var DefaultSparkSigner = class {
       publicKey,
       verifyingKey
     };
-    const logMessage = (0, import_utils4.bytesToHex)(message);
+    const logMessage = (0, import_utils5.bytesToHex)(message);
     const result = await SparkFrost.signFrost({
       message,
       keyPackage,
@@ -18408,7 +18466,7 @@ var DefaultSparkSigner = class {
   }
   async createSparkWalletFromSeed(seed, accountNumber) {
     if (typeof seed === "string") {
-      seed = (0, import_utils4.hexToBytes)(seed);
+      seed = (0, import_utils5.hexToBytes)(seed);
     }
     const {
       identityKey,
@@ -18420,7 +18478,7 @@ var DefaultSparkSigner = class {
     this.depositKey = depositKey;
     this.signingKey = signingKey.hdKey;
     this.staticDepositKey = staticDepositKey.hdKey;
-    return (0, import_utils4.bytesToHex)(identityKey.publicKey);
+    return (0, import_utils5.bytesToHex)(identityKey.publicKey);
   }
   async signMessageWithIdentityKey(message, compact) {
     if (!this.identityKey?.privateKey) {
@@ -18441,7 +18499,7 @@ var DefaultSparkSigner = class {
       });
     }
     const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils4.bytesToHex)(this.identityKey.privateKey)
+      (0, import_utils5.bytesToHex)(this.identityKey.privateKey)
     );
     const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
     const publicKey = import_secp256k15.secp256k1.getPublicKey(privateKey);
@@ -18465,15 +18523,15 @@ var DefaultSparkSigner = class {
   }
   signTransactionIndex(tx, index, publicKey) {
     let privateKey;
-    if ((0, import_utils4.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+    if ((0, import_utils5.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
       privateKey = this.identityKey?.privateKey;
-    } else if ((0, import_utils4.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+    } 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_utils4.bytesToHex)(publicKey)
+        value: (0, import_utils5.bytesToHex)(publicKey)
       });
     }
     tx.signIdx(privateKey, index);
@@ -18885,7 +18943,7 @@ var WalletConfigService = class {
 
 // src/services/connection.ts
 init_buffer();
-var import_core11 = require("@lightsparkdev/core");
+var import_core12 = require("@lightsparkdev/core");
 var import_sha23 = require("@noble/hashes/sha2");
 var import_nice_grpc_client_middleware_retry = require("nice-grpc-client-middleware-retry");
 var import_nice_grpc_common2 = require("nice-grpc-common");
@@ -22643,7 +22701,7 @@ var ConnectionManager = class {
   async createMockClient(address2) {
     const channel = await this.createChannelWithTLS(address2);
     const isNodeChannel = "close" in channel;
-    if (import_core11.isNode && isNodeChannel && !isBun) {
+    if (import_core12.isNode && isNodeChannel && !isBun) {
       const grpcModule = await import("nice-grpc");
       const { createClient } = "default" in grpcModule ? grpcModule.default : grpcModule;
       const client = createClient(MockServiceDefinition, channel);
@@ -22660,7 +22718,7 @@ var ConnectionManager = class {
   }
   async createChannelWithTLS(address2, certPath) {
     try {
-      if (import_core11.isNode && !isBun) {
+      if (import_core12.isNode && !isBun) {
         const grpcModule = await import("nice-grpc");
         const { ChannelCredentials, createChannel } = "default" in grpcModule ? grpcModule.default : grpcModule;
         if (certPath) {
@@ -22691,7 +22749,7 @@ var ConnectionManager = class {
         const { XHRTransport: XHRTransport2 } = await Promise.resolve().then(() => (init_xhr_transport(), xhr_transport_exports));
         return createChannel(
           address2,
-          import_core11.isBare ? (0, import_nice_grpc_web.NodeHttpTransport)() : isReactNative ? XHRTransport2() : FetchTransport()
+          import_core12.isBare ? (0, import_nice_grpc_web.NodeHttpTransport)() : isReactNative ? XHRTransport2() : FetchTransport()
         );
       }
     } catch (error) {
@@ -22797,7 +22855,7 @@ var ConnectionManager = class {
           sparkAuthnClient.close?.();
           return verifyResp.sessionToken;
         } catch (error) {
-          if ((0, import_core11.isError)(error)) {
+          if ((0, import_core12.isError)(error)) {
             sparkAuthnClient?.close?.();
             if (error.message.includes("challenge expired")) {
               console.warn(
@@ -22848,7 +22906,7 @@ var ConnectionManager = class {
     );
   }
   createAuthnMiddleware() {
-    if (import_core11.isNode) {
+    if (import_core12.isNode) {
       return async function* (call, options) {
         const metadata = (0, import_nice_grpc_common2.Metadata)(options.metadata).set(
           "X-Client-Env",
@@ -22870,14 +22928,14 @@ var ConnectionManager = class {
     }
   }
   createMiddleware(address2, authToken) {
-    if (import_core11.isNode) {
+    if (import_core12.isNode) {
       return this.createNodeMiddleware(address2, authToken);
     } else {
       return this.createBrowserMiddleware(address2, authToken);
     }
   }
   async *handleMiddlewareError(error, address2, call, metadata, options) {
-    if ((0, import_core11.isError)(error)) {
+    if ((0, import_core12.isError)(error)) {
       if (error.message.includes("token has expired")) {
         const newAuthToken = await this.authenticate(address2);
         const clientData = this.clients.get(address2);
@@ -22948,7 +23006,7 @@ var ConnectionManager = class {
     };
     let options = {};
     const isNodeChannel = "close" in channel;
-    if (import_core11.isNode && isNodeChannel && !isBun) {
+    if (import_core12.isNode && isNodeChannel && !isBun) {
       const grpcModule = await import("nice-grpc");
       const { openTelemetryClientMiddleware } = await import("nice-grpc-opentelemetry");
       const { createClientFactory } = "default" in grpcModule ? grpcModule.default : grpcModule;
@@ -22998,7 +23056,7 @@ var import_uuidv72 = require("uuidv7");
 
 // src/utils/bitcoin.ts
 init_buffer();
-var import_utils6 = require("@noble/curves/abstract/utils");
+var import_utils7 = require("@noble/curves/abstract/utils");
 var import_secp256k16 = require("@noble/curves/secp256k1");
 var import_sha24 = require("@noble/hashes/sha2");
 var btc2 = __toESM(require("@scure/btc-signer"), 1);
@@ -23011,10 +23069,10 @@ function computeTaprootKeyNoScript(pubkey) {
     });
   }
   const taggedHash = import_secp256k16.schnorr.utils.taggedHash("TapTweak", pubkey);
-  const tweak = (0, import_utils6.bytesToNumberBE)(taggedHash);
+  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.ProjectivePoint.fromPrivateKey(tweak));
-  return Q.toRawBytes();
+  const Q = P.add(import_secp256k16.secp256k1.Point.fromPrivateKey(tweak));
+  return Q.toBytes();
 }
 function getP2TRScriptFromPublicKey(pubKey, network) {
   if (pubKey.length !== 33) {
@@ -23024,9 +23082,9 @@ function getP2TRScriptFromPublicKey(pubKey, network) {
       expected: 33
     });
   }
-  const internalKey = import_secp256k16.secp256k1.ProjectivePoint.fromHex(pubKey);
+  const internalKey = import_secp256k16.secp256k1.Point.fromHex(pubKey);
   const script = btc2.p2tr(
-    internalKey.toRawBytes().slice(1, 33),
+    internalKey.toBytes().slice(1, 33),
     void 0,
     getNetwork(network)
   ).script;
@@ -23046,9 +23104,9 @@ function getP2TRAddressFromPublicKey(pubKey, network) {
       expected: 33
     });
   }
-  const internalKey = import_secp256k16.secp256k1.ProjectivePoint.fromHex(pubKey);
+  const internalKey = import_secp256k16.secp256k1.Point.fromHex(pubKey);
   const address2 = btc2.p2tr(
-    internalKey.toRawBytes().slice(1, 33),
+    internalKey.toBytes().slice(1, 33),
     void 0,
     getNetwork(network)
   ).address;
@@ -23064,7 +23122,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_utils6.bytesToHex)(pkScript),
+      value: (0, import_utils7.bytesToHex)(pkScript),
       expected: "34 bytes starting with 0x51 0x20"
     });
   }
@@ -23089,7 +23147,7 @@ function getP2WPKHAddressFromPublicKey(pubKey, network) {
   return address2;
 }
 function getTxFromRawTxHex(rawTxHex) {
-  const txBytes = (0, import_utils6.hexToBytes)(rawTxHex);
+  const txBytes = (0, import_utils7.hexToBytes)(rawTxHex);
   const tx = btc2.Transaction.fromRaw(txBytes, {
     allowUnknownOutputs: true
   });
@@ -23136,10 +23194,10 @@ function getSigHashFromTx(tx, inputIndex, prevOutput) {
   );
 }
 function getTxId(tx) {
-  return (0, import_utils6.bytesToHex)((0, import_sha24.sha256)((0, import_sha24.sha256)(tx.toBytes(true))).reverse());
+  return (0, import_utils7.bytesToHex)((0, import_sha24.sha256)((0, import_sha24.sha256)(tx.toBytes(true))).reverse());
 }
 function getTxIdNoReverse(tx) {
-  return (0, import_utils6.bytesToHex)((0, import_sha24.sha256)((0, import_sha24.sha256)(tx.toBytes(true))));
+  return (0, import_utils7.bytesToHex)((0, import_sha24.sha256)((0, import_sha24.sha256)(tx.toBytes(true))));
 }
 function getTxEstimatedVbytesSizeByNumberOfInputsOutputs(numInputs, numOutputs) {
   const TX_OVERHEAD = 10;
@@ -23487,7 +23545,7 @@ function getEphemeralAnchorOutput() {
 
 // src/services/transfer.ts
 init_buffer();
-var import_utils8 = require("@noble/curves/abstract/utils");
+var import_utils9 = require("@noble/curves/abstract/utils");
 var import_secp256k17 = require("@noble/curves/secp256k1");
 var import_sha26 = require("@noble/hashes/sha2");
 var import_btc_signer2 = require("@scure/btc-signer");
@@ -23496,7 +23554,7 @@ var import_uuidv7 = require("uuidv7");
 
 // src/utils/transfer_package.ts
 init_buffer();
-var import_utils7 = require("@noble/curves/abstract/utils");
+var import_utils8 = require("@noble/curves/abstract/utils");
 var import_sha25 = require("@noble/hashes/sha2");
 function getTransferPackageSigningPayload(transferID, transferPackage) {
   const encryptedPayload = transferPackage.keyTweakPackage;
@@ -23505,7 +23563,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_utils7.hexToBytes)(transferID.replaceAll("-", ""));
+  let message = (0, import_utils8.hexToBytes)(transferID.replaceAll("-", ""));
   for (const pair of pairs) {
     const keyPart = encoder.encode(pair.key + ":");
     const separator = encoder.encode(";");
@@ -23885,7 +23943,7 @@ var BaseTransferService = class {
   }
   async prepareSendTransferKeyTweaks(transferID, receiverIdentityPubkey, leaves, cpfpRefundSignatureMap, directRefundSignatureMap, directFromCpfpRefundSignatureMap) {
     const receiverEciesPubKey = ecies2.PublicKey.fromHex(
-      (0, import_utils8.bytesToHex)(receiverIdentityPubkey)
+      (0, import_utils9.bytesToHex)(receiverIdentityPubkey)
     );
     const leavesTweaksMap = /* @__PURE__ */ new Map();
     for (const leaf of leaves) {
@@ -23926,7 +23984,7 @@ var BaseTransferService = class {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
       const pubkeyTweak = import_secp256k17.secp256k1.getPublicKey(
-        (0, import_utils8.numberToBytesBE)(share.share, 32),
+        (0, import_utils9.numberToBytesBE)(share.share, 32),
         true
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
@@ -23951,7 +24009,7 @@ var BaseTransferService = class {
       leafTweaksMap.set(identifier, {
         leafId: leaf.leaf.id,
         secretShareTweak: {
-          secretShare: (0, import_utils8.numberToBytesBE)(share.share, 32),
+          secretShare: (0, import_utils9.numberToBytesBE)(share.share, 32),
           proofs: share.proofs
         },
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak),
@@ -23974,7 +24032,7 @@ var BaseTransferService = class {
     return void 0;
   }
   compareTransfers(transfer1, transfer2) {
-    return transfer1.id === transfer2.id && (0, import_utils8.equalBytes)(
+    return transfer1.id === transfer2.id && (0, import_utils9.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;
@@ -24273,7 +24331,7 @@ var TransferService = class extends BaseTransferService {
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
       const cpfpNodeOutPoint = {
-        txid: (0, import_utils8.hexToBytes)(getTxId(nodeTx)),
+        txid: (0, import_utils9.hexToBytes)(getTxId(nodeTx)),
         index: 0
       };
       let directNodeTx;
@@ -24281,7 +24339,7 @@ var TransferService = class extends BaseTransferService {
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
         directNodeOutPoint = {
-          txid: (0, import_utils8.hexToBytes)(getTxId(directNodeTx)),
+          txid: (0, import_utils9.hexToBytes)(getTxId(directNodeTx)),
           index: 0
         };
       }
@@ -24415,7 +24473,7 @@ var TransferService = class extends BaseTransferService {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
       const pubkeyTweak = import_secp256k17.secp256k1.getPublicKey(
-        (0, import_utils8.numberToBytesBE)(share.share, 32)
+        (0, import_utils9.numberToBytesBE)(share.share, 32)
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
     }
@@ -24428,7 +24486,7 @@ var TransferService = class extends BaseTransferService {
       leafTweaksMap.set(identifier, {
         leafId: leaf.leaf.id,
         secretShareTweak: {
-          secretShare: (0, import_utils8.numberToBytesBE)(share.share, 32),
+          secretShare: (0, import_utils9.numberToBytesBE)(share.share, 32),
           proofs: share.proofs
         },
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak)
@@ -24614,13 +24672,13 @@ var TransferService = class extends BaseTransferService {
       });
     }
     const newCpfpRefundOutPoint = {
-      txid: (0, import_utils8.hexToBytes)(getTxId(cpfpNodeTx)),
+      txid: (0, import_utils9.hexToBytes)(getTxId(cpfpNodeTx)),
       index: 0
     };
     let newDirectRefundOutPoint;
     if (newDirectNodeTx) {
       newDirectRefundOutPoint = {
-        txid: (0, import_utils8.hexToBytes)(getTxId(newDirectNodeTx)),
+        txid: (0, import_utils9.hexToBytes)(getTxId(newDirectNodeTx)),
         index: 0
       };
     }
@@ -24748,7 +24806,7 @@ var TransferService = class extends BaseTransferService {
     const refundTx = getTxFromRawTxBytes(node.refundTx);
     const refundSequence = refundTx.getInput(0).sequence || 0;
     const newNodeOutPoint = {
-      txid: (0, import_utils8.hexToBytes)(getTxId(nodeTx)),
+      txid: (0, import_utils9.hexToBytes)(getTxId(nodeTx)),
       index: 0
     };
     const {
@@ -24785,13 +24843,13 @@ var TransferService = class extends BaseTransferService {
       });
     }
     const newCpfpRefundOutPoint = {
-      txid: (0, import_utils8.hexToBytes)(getTxId(newNodeTx)),
+      txid: (0, import_utils9.hexToBytes)(getTxId(newNodeTx)),
       index: 0
     };
     let newDirectRefundOutPoint;
     if (newDirectNodeTx) {
       newDirectRefundOutPoint = {
-        txid: (0, import_utils8.hexToBytes)(getTxId(newDirectNodeTx)),
+        txid: (0, import_utils9.hexToBytes)(getTxId(newDirectNodeTx)),
         index: 0
       };
     }
@@ -25025,13 +25083,13 @@ var TransferService = class extends BaseTransferService {
     };
     const signingPublicKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
     const cpfpRefundOutPoint = {
-      txid: (0, import_utils8.hexToBytes)(getTxId(nodeTx)),
+      txid: (0, import_utils9.hexToBytes)(getTxId(nodeTx)),
       index: 0
     };
     let directRefundOutPoint;
     if (directNodeTx) {
       directRefundOutPoint = {
-        txid: (0, import_utils8.hexToBytes)(getTxId(directNodeTx)),
+        txid: (0, import_utils9.hexToBytes)(getTxId(directNodeTx)),
         index: 0
       };
     }
@@ -25407,9 +25465,9 @@ var CoopExitService = class extends BaseTransferService {
 init_buffer();
 var import_secp256k18 = require("@noble/curves/secp256k1");
 var import_sha28 = require("@noble/hashes/sha2");
-var import_utils9 = require("@noble/hashes/utils");
+var import_utils10 = require("@noble/hashes/utils");
 var import_btc_signer4 = require("@scure/btc-signer");
-var import_utils10 = require("@scure/btc-signer/utils");
+var import_utils11 = require("@scure/btc-signer/utils");
 
 // src/utils/proof.ts
 init_buffer();
@@ -25476,7 +25534,7 @@ var DepositService = class {
       if (operator.identifier === this.config.getCoordinatorIdentifier()) {
         continue;
       }
-      const operatorPubkey2 = (0, import_utils9.hexToBytes)(operator.identityPublicKey);
+      const operatorPubkey2 = (0, import_utils10.hexToBytes)(operator.identityPublicKey);
       const operatorSig = address2.depositAddressProof.addressSignatures[operator.identifier];
       if (!operatorSig) {
         throw new ValidationError("Operator signature not found", {
@@ -25485,7 +25543,11 @@ var DepositService = class {
         });
       }
       const sig = import_secp256k18.secp256k1.Signature.fromDER(operatorSig);
-      const isVerified2 = import_secp256k18.secp256k1.verify(sig, addrHash, operatorPubkey2);
+      const isVerified2 = import_secp256k18.secp256k1.verify(
+        sig.toCompactRawBytes(),
+        addrHash,
+        operatorPubkey2
+      );
       if (!isVerified2) {
         throw new ValidationError("Operator signature verification failed", {
           field: "operatorSignature",
@@ -25561,7 +25623,7 @@ var DepositService = class {
       });
     }
     const depositOutPoint = {
-      txid: (0, import_utils9.hexToBytes)(getTxId(depositTx)),
+      txid: (0, import_utils10.hexToBytes)(getTxId(depositTx)),
       index: vout
     };
     const depositTxOut = {
@@ -25580,8 +25642,8 @@ var DepositService = class {
     const { cpfpRefundTx, directRefundTx, directFromCpfpRefundTx } = createRefundTxs({
       sequence: INITIAL_SEQUENCE,
       directSequence: INITIAL_DIRECT_SEQUENCE,
-      input: { txid: (0, import_utils9.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
-      directInput: { txid: (0, import_utils9.hexToBytes)(getTxId(directRootTx)), index: 0 },
+      input: { txid: (0, import_utils10.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
+      directInput: { txid: (0, import_utils10.hexToBytes)(getTxId(directRootTx)), index: 0 },
       amountSats: amount,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
@@ -25711,7 +25773,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils10.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils11.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -25875,7 +25937,7 @@ var DepositService = class {
       });
     }
     const depositOutPoint = {
-      txid: (0, import_utils9.hexToBytes)(getTxId(depositTx)),
+      txid: (0, import_utils10.hexToBytes)(getTxId(depositTx)),
       index: vout
     };
     const depositTxOut = {
@@ -25888,7 +25950,7 @@ var DepositService = class {
     const signingPubKey = await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
     const { cpfpRefundTx } = createRefundTxs({
       sequence: INITIAL_SEQUENCE,
-      input: { txid: (0, import_utils9.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
+      input: { txid: (0, import_utils10.hexToBytes)(getTxId(cpfpRootTx)), index: 0 },
       amountSats: amount,
       receivingPubkey: signingPubKey,
       network: this.config.getNetwork()
@@ -25958,7 +26020,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils10.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils11.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -26034,7 +26096,7 @@ var DepositService = class {
 
 // src/services/lightning.ts
 init_buffer();
-var import_utils11 = require("@noble/curves/abstract/utils");
+var import_utils12 = require("@noble/curves/abstract/utils");
 var import_secp256k19 = require("@noble/curves/secp256k1");
 var import_sha29 = require("@noble/hashes/sha2");
 var import_uuidv73 = require("uuidv7");
@@ -26121,8 +26183,8 @@ var LightningService = class {
   }) {
     const crypto = getCrypto();
     const randBytes = crypto.getRandomValues(new Uint8Array(32));
-    const preimage = (0, import_utils11.numberToBytesBE)(
-      (0, import_utils11.bytesToNumberBE)(randBytes) % import_secp256k19.secp256k1.CURVE.n,
+    const preimage = (0, import_utils12.numberToBytesBE)(
+      (0, import_utils12.bytesToNumberBE)(randBytes) % import_secp256k19.secp256k1.CURVE.n,
       32
     );
     return await this.createLightningInvoiceWithPreImage({
@@ -26177,12 +26239,12 @@ var LightningService = class {
         const sparkClient = await this.connectionManager.createSparkClient(
           operator.address
         );
-        const userIdentityPublicKey = receiverIdentityPubkey ? (0, import_utils11.hexToBytes)(receiverIdentityPubkey) : await this.config.signer.getIdentityPublicKey();
+        const userIdentityPublicKey = receiverIdentityPubkey ? (0, import_utils12.hexToBytes)(receiverIdentityPubkey) : await this.config.signer.getIdentityPublicKey();
         try {
           await sparkClient.store_preimage_share({
             paymentHash,
             preimageShare: {
-              secretShare: (0, import_utils11.numberToBytesBE)(share.share, 32),
+              secretShare: (0, import_utils12.numberToBytesBE)(share.share, 32),
               proofs: share.proofs
             },
             threshold: this.config.getThreshold(),
@@ -26383,15 +26445,18 @@ var LightningService = class {
 
 // src/services/token-transactions.ts
 init_buffer();
-var import_utils16 = require("@noble/curves/abstract/utils");
+var import_utils17 = require("@noble/curves/abstract/utils");
 var import_secp256k112 = require("@noble/curves/secp256k1");
-var import_utils17 = require("@noble/hashes/utils");
+var import_utils18 = require("@noble/hashes/utils");
 
 // src/utils/address.ts
 init_buffer();
+var import_wire8 = require("@bufbuild/protobuf/wire");
+var import_utils13 = require("@noble/curves/abstract/utils");
 var import_secp256k110 = require("@noble/curves/secp256k1");
-var import_utils12 = require("@noble/hashes/utils");
+var import_utils14 = require("@noble/hashes/utils");
 var import_base2 = require("@scure/base");
+var import_uuidv74 = require("uuidv7");
 
 // src/utils/invoice-hashing.ts
 init_buffer();
@@ -26561,9 +26626,6 @@ function uint64be(value) {
 }
 
 // src/utils/address.ts
-var import_uuidv74 = require("uuidv7");
-var import_utils13 = require("@noble/curves/abstract/utils");
-var import_wire8 = require("@bufbuild/protobuf/wire");
 var BECH32M_LIMIT = 1024;
 var AddressNetwork = {
   MAINNET: "sp",
@@ -26578,7 +26640,7 @@ function encodeSparkAddress(payload) {
 function encodeSparkAddressWithSignature(payload, signature) {
   try {
     isValidPublicKey(payload.identityPublicKey);
-    const identityPublicKey = (0, import_utils12.hexToBytes)(payload.identityPublicKey);
+    const identityPublicKey = (0, import_utils14.hexToBytes)(payload.identityPublicKey);
     let sparkInvoiceFields;
     if (payload.sparkInvoiceFields) {
       validateSparkInvoiceFields(payload.sparkInvoiceFields);
@@ -26622,8 +26684,8 @@ function decodeSparkAddress(address2, network) {
     }
     const payload = SparkAddress.decode(import_base2.bech32m.fromWords(decoded.words));
     const { identityPublicKey, sparkInvoiceFields, signature } = payload;
-    const identityPubkeyHex = (0, import_utils12.bytesToHex)(identityPublicKey);
-    const signatureHex = signature ? (0, import_utils12.bytesToHex)(signature) : void 0;
+    const identityPubkeyHex = (0, import_utils14.bytesToHex)(identityPublicKey);
+    const signatureHex = signature ? (0, import_utils14.bytesToHex)(signature) : void 0;
     isValidPublicKey(identityPubkeyHex);
     return {
       identityPublicKey: identityPubkeyHex,
@@ -26633,7 +26695,7 @@ function decodeSparkAddress(address2, 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_utils12.bytesToHex)(
+          tokenIdentifier: sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier ? (0, import_utils14.bytesToHex)(
             sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier
           ) : void 0,
           amount: sparkInvoiceFields.paymentType.tokensPayment.amount ? (0, import_utils13.bytesToNumberBE)(
@@ -26644,7 +26706,7 @@ function decodeSparkAddress(address2, network) {
           amount: sparkInvoiceFields.paymentType.satsPayment.amount
         } : void 0 : void 0,
         memo: sparkInvoiceFields.memo,
-        senderPublicKey: sparkInvoiceFields.senderPublicKey ? (0, import_utils12.bytesToHex)(sparkInvoiceFields.senderPublicKey) : void 0,
+        senderPublicKey: sparkInvoiceFields.senderPublicKey ? (0, import_utils14.bytesToHex)(sparkInvoiceFields.senderPublicKey) : void 0,
         expiryTime: sparkInvoiceFields.expiryTime
       },
       signature: signatureHex
@@ -26693,7 +26755,7 @@ function isValidSparkAddress(address2) {
 }
 function isValidPublicKey(publicKey) {
   try {
-    const point = import_secp256k110.secp256k1.ProjectivePoint.fromHex(publicKey);
+    const point = import_secp256k110.secp256k1.Point.fromHex(publicKey);
     point.assertValidity();
   } catch (error) {
     throw new ValidationError(
@@ -26728,7 +26790,7 @@ function validateSparkInvoiceFields(sparkInvoiceFields) {
   }
   if (senderPublicKey) {
     try {
-      isValidPublicKey((0, import_utils12.bytesToHex)(senderPublicKey));
+      isValidPublicKey((0, import_utils14.bytesToHex)(senderPublicKey));
     } catch (error) {
       throw new ValidationError(
         "Invalid sender public key",
@@ -28883,12 +28945,12 @@ function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction
 
 // src/utils/token-transactions.ts
 init_buffer();
-var import_utils14 = require("@noble/curves/abstract/utils");
-var import_utils15 = require("@scure/btc-signer/utils");
+var import_utils15 = require("@noble/curves/abstract/utils");
+var import_utils16 = require("@scure/btc-signer/utils");
 function sumAvailableTokens(outputs) {
   try {
     return outputs.reduce(
-      (sum, output) => sum + BigInt((0, import_utils14.bytesToNumberBE)(output.output.tokenAmount)),
+      (sum, output) => sum + BigInt((0, import_utils15.bytesToNumberBE)(output.output.tokenAmount)),
       BigInt(0)
     );
   } catch (error) {
@@ -28919,7 +28981,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_utils16.equalBytes)(info.tokenMetadata.rawTokenIdentifier, tokenIdentifierBytes)
   );
   if (!tokenBalance) {
     return {
@@ -29022,14 +29084,14 @@ var TokenTransactionService = class {
       }
       if (this.config.getTokenTransactionVersion() !== "V0" && receiverAddress.sparkInvoiceFields) {
         return {
-          receiverPublicKey: (0, import_utils17.hexToBytes)(receiverAddress.identityPublicKey),
+          receiverPublicKey: (0, import_utils18.hexToBytes)(receiverAddress.identityPublicKey),
           rawTokenIdentifier,
           tokenAmount: transfer.tokenAmount,
           sparkInvoice: transfer.receiverSparkAddress
         };
       }
       return {
-        receiverPublicKey: (0, import_utils17.hexToBytes)(receiverAddress.identityPublicKey),
+        receiverPublicKey: (0, import_utils18.hexToBytes)(receiverAddress.identityPublicKey),
         rawTokenIdentifier,
         tokenPublicKey,
         // Remove for full v0 deprecation
@@ -29068,7 +29130,7 @@ var TokenTransactionService = class {
     const tokenOutputs = tokenOutputData.map((output) => ({
       ownerPublicKey: output.receiverPublicKey,
       tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: (0, import_utils16.numberToBytesBE)(output.tokenAmount, 16)
+      tokenAmount: (0, import_utils17.numberToBytesBE)(output.tokenAmount, 16)
     }));
     if (availableTokenAmount > totalRequestedAmount) {
       const changeAmount = availableTokenAmount - totalRequestedAmount;
@@ -29076,7 +29138,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils16.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils17.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -29107,7 +29169,7 @@ var TokenTransactionService = class {
       (output) => ({
         ownerPublicKey: output.receiverPublicKey,
         tokenIdentifier: output.rawTokenIdentifier,
-        tokenAmount: (0, import_utils16.numberToBytesBE)(output.tokenAmount, 16)
+        tokenAmount: (0, import_utils17.numberToBytesBE)(output.tokenAmount, 16)
       })
     );
     if (availableTokenAmount > totalRequestedAmount) {
@@ -29116,7 +29178,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenIdentifier: firstTokenIdentifierBytes,
-        tokenAmount: (0, import_utils16.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils17.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -29143,7 +29205,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_utils18.hexToBytes)(operator.identityPublicKey));
     }
     return operatorKeys;
   }
@@ -29227,7 +29289,7 @@ var TokenTransactionService = class {
               {
                 field: "revocationCommitment",
                 value: derivedRevocationCommitment,
-                expected: (0, import_utils16.bytesToHex)(outputsToSpendCommitments[outputIndex]),
+                expected: (0, import_utils17.bytesToHex)(outputsToSpendCommitments[outputIndex]),
                 outputIndex
               }
             )
@@ -29253,7 +29315,7 @@ var TokenTransactionService = class {
         threshold
       );
     }
-    return (0, import_utils16.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils17.bytesToHex)(finalTokenTransactionHash);
   }
   async broadcastTokenTransactionV1(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
@@ -29267,7 +29329,7 @@ var TokenTransactionService = class {
       finalTokenTransactionHash,
       signingOperators
     );
-    return (0, import_utils16.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils17.bytesToHex)(finalTokenTransactionHash);
   }
   async startTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkClient(
@@ -29491,7 +29553,7 @@ var TokenTransactionService = class {
           const identityPublicKey = await this.config.signer.getIdentityPublicKey();
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils18.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let operatorSpecificSignatures = [];
@@ -29706,8 +29768,8 @@ var TokenTransactionService = class {
       this.config.getCoordinatorAddress()
     );
     let queryParams = {
-      tokenPublicKeys: issuerPublicKeys?.map(import_utils17.hexToBytes),
-      ownerPublicKeys: ownerPublicKeys?.map(import_utils17.hexToBytes),
+      tokenPublicKeys: issuerPublicKeys?.map(import_utils18.hexToBytes),
+      ownerPublicKeys: ownerPublicKeys?.map(import_utils18.hexToBytes),
       tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
         const { tokenIdentifier } = decodeBech32mTokenIdentifier(
           identifier,
@@ -29715,7 +29777,7 @@ var TokenTransactionService = class {
         );
         return tokenIdentifier;
       }),
-      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils17.hexToBytes),
+      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils18.hexToBytes),
       outputIds: outputIds || [],
       limit: pageSize,
       offset
@@ -29774,8 +29836,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_utils18.hexToBytes),
+      ownerPublicKeys: ownerPublicKeys?.map(import_utils18.hexToBytes),
       tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
         const { tokenIdentifier } = decodeBech32mTokenIdentifier(
           identifier,
@@ -29783,7 +29845,7 @@ var TokenTransactionService = class {
         );
         return tokenIdentifier;
       }),
-      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils17.hexToBytes),
+      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils18.hexToBytes),
       outputIds: outputIds || [],
       limit: pageSize,
       offset
@@ -29818,7 +29880,7 @@ var TokenTransactionService = class {
       });
     }
     const exactMatch = tokenOutputs.find(
-      (item) => (0, import_utils16.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
+      (item) => (0, import_utils17.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
     );
     if (exactMatch) {
       return [exactMatch];
@@ -29829,7 +29891,7 @@ var TokenTransactionService = class {
     for (const outputWithPreviousTransactionData of tokenOutputs) {
       if (remainingAmount <= 0n) break;
       selectedOutputs.push(outputWithPreviousTransactionData);
-      remainingAmount -= (0, import_utils16.bytesToNumberBE)(
+      remainingAmount -= (0, import_utils17.bytesToNumberBE)(
         outputWithPreviousTransactionData.output.tokenAmount
       );
     }
@@ -29845,13 +29907,13 @@ var TokenTransactionService = class {
     if (strategy === "SMALL_FIRST") {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils16.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils16.bytesToNumberBE)(b.output.tokenAmount)
+          (0, import_utils17.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils17.bytesToNumberBE)(b.output.tokenAmount)
         );
       });
     } else {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils16.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils16.bytesToNumberBE)(a.output.tokenAmount)
+          (0, import_utils17.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils17.bytesToNumberBE)(a.output.tokenAmount)
         );
       });
     }
@@ -29859,7 +29921,7 @@ var TokenTransactionService = class {
   // 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_utils17.bytesToHex)(publicKey) === (0, import_utils17.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
       if (tokenSignatures === "SCHNORR") {
         return await this.config.signer.signSchnorrWithIdentityKey(message);
       } else {
@@ -29868,8 +29930,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_utils17.bytesToHex)(publicKey),
+        expected: (0, import_utils17.bytesToHex)(await this.config.signer.getIdentityPublicKey())
       });
     }
   }
@@ -29932,7 +29994,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils18.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -29954,7 +30016,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils18.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -29970,7 +30032,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_utils18.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let ownerSignature;
@@ -29987,7 +30049,7 @@ var TokenTransactionService = class {
       }
       inputTtxoSignaturesPerOperator.push({
         ttxoSignatures,
-        operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
+        operatorIdentityPublicKey: (0, import_utils18.hexToBytes)(operator.identityPublicKey)
       });
     }
     return inputTtxoSignaturesPerOperator;
@@ -30000,23 +30062,23 @@ function isTokenTransaction(tokenTransaction) {
 // src/utils/adaptor-signature.ts
 init_buffer();
 var import_modular = require("@noble/curves/abstract/modular");
-var import_utils18 = require("@noble/curves/abstract/utils");
+var import_utils19 = require("@noble/curves/abstract/utils");
 var import_secp256k113 = require("@noble/curves/secp256k1");
 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 sBigInt = (0, import_utils19.bytesToNumberBE)(s2);
+  const tBigInt = (0, import_utils19.bytesToNumberBE)(adaptorPrivateKeyBytes);
   const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k113.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(newS, 32)]);
+  const newSignature = new Uint8Array([...r, ...(0, import_utils19.numberToBytesBE)(newS, 32)]);
   return newSignature;
 }
 function generateAdaptorFromSignature(signature) {
   const adaptorPrivateKey = import_secp256k113.secp256k1.utils.randomPrivateKey();
   const { r, s: s2 } = parseSignature(signature);
-  const sBigInt = (0, import_utils18.bytesToNumberBE)(s2);
-  const tBigInt = (0, import_utils18.bytesToNumberBE)(adaptorPrivateKey);
+  const sBigInt = (0, import_utils19.bytesToNumberBE)(s2);
+  const tBigInt = (0, import_utils19.bytesToNumberBE)(adaptorPrivateKey);
   const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k113.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(newS, 32)]);
+  const newSignature = new Uint8Array([...r, ...(0, import_utils19.numberToBytesBE)(newS, 32)]);
   return {
     adaptorSignature: newSignature,
     adaptorPrivateKey
@@ -30033,10 +30095,10 @@ function validateOutboundAdaptorSignature(pubkey, hash, signature, adaptorPubkey
 }
 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 sBigInt = (0, import_utils19.bytesToNumberBE)(s2);
+  const adaptorPrivateKey = (0, import_utils19.bytesToNumberBE)(adaptorPrivateKeyBytes);
   const newS = (0, import_modular.mod)(sBigInt + adaptorPrivateKey, import_secp256k113.secp256k1.CURVE.n);
-  const newSig = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(newS, 32)]);
+  const newSig = new Uint8Array([...r, ...(0, import_utils19.numberToBytesBE)(newS, 32)]);
   try {
     if (import_secp256k113.schnorr.verify(newSig, hash, pubkey)) {
       return newSig;
@@ -30045,7 +30107,7 @@ function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes
     console.error("[applyAdaptorToSignature] Addition verification failed:", e);
   }
   const altS = (0, import_modular.mod)(sBigInt - adaptorPrivateKey, import_secp256k113.secp256k1.CURVE.n);
-  const altSig = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(altS, 32)]);
+  const altSig = new Uint8Array([...r, ...(0, import_utils19.numberToBytesBE)(altS, 32)]);
   try {
     if (import_secp256k113.schnorr.verify(altSig, hash, pubkey)) {
       return altSig;
@@ -30062,39 +30124,37 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   if (hash.length !== 32) {
     throw new Error(`wrong size for message (got ${hash.length}, want 32)`);
   }
-  const pubKey = import_secp256k113.schnorr.utils.lift_x((0, import_utils18.bytesToNumberBE)(pubKeyBytes));
+  const pubKey = import_secp256k113.schnorr.utils.lift_x((0, import_utils19.bytesToNumberBE)(pubKeyBytes));
   pubKey.assertValidity();
   const { r, s: s2 } = parseSignature(signature);
   const commitmenet = import_secp256k113.schnorr.utils.taggedHash(
     "BIP0340/challenge",
     r,
-    pubKey.toRawBytes().slice(1),
+    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_utils18.bytesToNumberBE)(commitmenet), import_secp256k113.secp256k1.CURVE.n);
+  const e = (0, import_modular.mod)((0, import_utils19.bytesToNumberBE)(commitmenet), import_secp256k113.secp256k1.CURVE.n);
   const negE = (0, import_modular.mod)(-e, import_secp256k113.secp256k1.CURVE.n);
-  const R = import_secp256k113.secp256k1.ProjectivePoint.BASE.multiplyAndAddUnsafe(
-    pubKey,
-    (0, import_utils18.bytesToNumberBE)(s2),
-    negE
-  );
-  if (!R) {
-    throw new Error("R is undefined");
+  const sG = import_secp256k113.secp256k1.Point.BASE.multiplyUnsafe((0, import_utils19.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_secp256k113.secp256k1.ProjectivePoint.fromHex(adaptorPubkey);
+  const adaptorPoint = import_secp256k113.secp256k1.Point.fromHex(adaptorPubkey);
   const newR = R.add(adaptorPoint);
-  if (!inbound && newR.equals(import_secp256k113.secp256k1.ProjectivePoint.ZERO)) {
+  if (!inbound && newR.equals(import_secp256k113.secp256k1.Point.ZERO)) {
     throw new Error("calculated R point is the point at infinity");
   }
   newR.assertValidity();
-  if (!newR.hasEvenY()) {
+  if (newR.y % 2n !== 0n) {
     throw new Error("calculated R y-value is odd");
   }
-  const rNum = (0, import_utils18.bytesToNumberBE)(r);
+  const rNum = (0, import_utils19.bytesToNumberBE)(r);
   if (newR.toAffine().x !== rNum) {
     throw new Error("calculated R point was not given R");
   }
@@ -30115,15 +30175,15 @@ function parseSignature(signature) {
   }
   const r = signature.slice(0, 32);
   const s2 = signature.slice(32, 64);
-  if ((0, import_utils18.bytesToNumberBE)(r) >= import_secp256k113.secp256k1.CURVE.Fp.ORDER) {
+  if ((0, import_utils19.bytesToNumberBE)(r) >= import_secp256k113.secp256k1.CURVE.Fp.ORDER) {
     throw new ValidationError("Invalid signature: r >= field prime", {
-      rValue: (0, import_utils18.bytesToNumberBE)(r),
+      rValue: (0, import_utils19.bytesToNumberBE)(r),
       fieldPrime: import_secp256k113.secp256k1.CURVE.Fp.ORDER
     });
   }
-  if ((0, import_utils18.bytesToNumberBE)(s2) >= import_secp256k113.secp256k1.CURVE.n) {
+  if ((0, import_utils19.bytesToNumberBE)(s2) >= import_secp256k113.secp256k1.CURVE.n) {
     throw new ValidationError("Invalid signature: s >= group order", {
-      sValue: (0, import_utils18.bytesToNumberBE)(s2),
+      sValue: (0, import_utils19.bytesToNumberBE)(s2),
       groupOrder: import_secp256k113.secp256k1.CURVE.n
     });
   }
@@ -30139,7 +30199,7 @@ var import_nice_grpc_common3 = require("nice-grpc-common");
 
 // src/services/signing.ts
 init_buffer();
-var import_utils19 = require("@noble/curves/abstract/utils");
+var import_utils20 = require("@noble/curves/abstract/utils");
 var SigningService = class {
   config;
   constructor(config) {
@@ -30195,7 +30255,7 @@ var SigningService = class {
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
       const cpfpNodeOutPoint = {
-        txid: (0, import_utils19.hexToBytes)(getTxId(nodeTx)),
+        txid: (0, import_utils20.hexToBytes)(getTxId(nodeTx)),
         index: 0
       };
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
@@ -30221,7 +30281,7 @@ var SigningService = class {
       if (leaf.leaf.directTx.length > 0) {
         directNodeTx = getTxFromRawTxBytes(leaf.leaf.directTx);
         directNodeOutPoint = {
-          txid: (0, import_utils19.hexToBytes)(getTxId(directNodeTx)),
+          txid: (0, import_utils20.hexToBytes)(getTxId(directNodeTx)),
           index: 0
         };
       }
@@ -30305,15 +30365,15 @@ var SigningService = class {
 
 // src/tests/utils/test-faucet.ts
 init_buffer();
-var import_utils20 = require("@noble/curves/abstract/utils");
+var import_utils21 = require("@noble/curves/abstract/utils");
 var import_secp256k114 = require("@noble/curves/secp256k1");
 var btc3 = __toESM(require("@scure/btc-signer"), 1);
 var import_btc_signer5 = require("@scure/btc-signer");
-var import_utils21 = require("@scure/btc-signer/utils");
-var STATIC_FAUCET_KEY = (0, import_utils20.hexToBytes)(
+var import_utils22 = require("@scure/btc-signer/utils");
+var STATIC_FAUCET_KEY = (0, import_utils21.hexToBytes)(
   "deadbeef1337cafe4242424242424242deadbeef1337cafe4242424242424242"
 );
-var STATIC_MINING_KEY = (0, import_utils20.hexToBytes)(
+var STATIC_MINING_KEY = (0, import_utils21.hexToBytes)(
   "1337cafe4242deadbeef4242424242421337cafe4242deadbeef424242424242"
 );
 var SATS_PER_BTC = 1e8;
@@ -30376,7 +30436,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     if (!scanResult.success || scanResult.unspents.length === 0) {
       const blockHash = await this.generateToAddress(1, address2);
       const block = await this.getBlock(blockHash[0]);
-      const fundingTx = import_btc_signer5.Transaction.fromRaw((0, import_utils20.hexToBytes)(block.tx[0].hex), {
+      const fundingTx = import_btc_signer5.Transaction.fromRaw((0, import_utils21.hexToBytes)(block.tx[0].hex), {
         allowUnknownOutputs: true
       });
       await this.generateToAddress(100, this.miningAddress);
@@ -30438,13 +30498,13 @@ var BitcoinFaucet = class _BitcoinFaucet {
       },
       STATIC_MINING_KEY
     );
-    await this.broadcastTx((0, import_utils20.bytesToHex)(signedSplitTx.extract()));
+    await this.broadcastTx((0, import_utils21.bytesToHex)(signedSplitTx.extract()));
     const splitTxId = signedSplitTx.id;
     for (let i = 0; i < numCoinsToCreate; i++) {
       this.coins.push({
         key: STATIC_FAUCET_KEY,
         outpoint: {
-          txid: (0, import_utils20.hexToBytes)(splitTxId),
+          txid: (0, import_utils21.hexToBytes)(splitTxId),
           index: i
         },
         txout: signedSplitTx.getOutput(i)
@@ -30472,7 +30532,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       coinToSend.txout,
       coinToSend.key
     );
-    await this.broadcastTx((0, import_utils20.bytesToHex)(signedTx.extract()));
+    await this.broadcastTx((0, import_utils21.bytesToHex)(signedTx.extract()));
   }
   async signFaucetCoin(unsignedTx, fundingTxOut, key) {
     const pubKey = import_secp256k114.secp256k1.getPublicKey(key);
@@ -30492,7 +30552,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       new Array(unsignedTx.inputsLength).fill(fundingTxOut.amount)
     );
     const merkleRoot = new Uint8Array();
-    const tweakedKey = (0, import_utils21.taprootTweakPrivKey)(key, merkleRoot);
+    const tweakedKey = (0, import_utils22.taprootTweakPrivKey)(key, merkleRoot);
     if (!tweakedKey)
       throw new Error("Invalid private key for taproot tweaking");
     const signature = import_secp256k114.schnorr.sign(sighash, tweakedKey);
@@ -30592,7 +30652,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       });
     }
     const signedTx = await this.signFaucetCoin(tx, coin.txout, coin.key);
-    const txHex = (0, import_utils20.bytesToHex)(signedTx.extract());
+    const txHex = (0, import_utils21.bytesToHex)(signedTx.extract());
     await this.broadcastTx(txHex);
     const randomKey = import_secp256k114.secp256k1.utils.randomPrivateKey();
     const randomPubKey = import_secp256k114.secp256k1.getPublicKey(randomKey);
@@ -30610,18 +30670,18 @@ var BitcoinFaucet = class _BitcoinFaucet {
 
 // src/types/sdk-types.ts
 init_buffer();
-var import_utils22 = require("@noble/curves/abstract/utils");
+var import_utils23 = require("@noble/curves/abstract/utils");
 function mapTreeNodeToWalletLeaf(proto) {
   return {
     id: proto.id,
     treeId: proto.treeId,
     value: proto.value,
     parentNodeId: proto.parentNodeId,
-    nodeTx: (0, import_utils22.bytesToHex)(proto.nodeTx),
-    refundTx: (0, import_utils22.bytesToHex)(proto.refundTx),
+    nodeTx: (0, import_utils23.bytesToHex)(proto.nodeTx),
+    refundTx: (0, import_utils23.bytesToHex)(proto.refundTx),
     vout: proto.vout,
-    verifyingPublicKey: (0, import_utils22.bytesToHex)(proto.verifyingPublicKey),
-    ownerIdentityPublicKey: (0, import_utils22.bytesToHex)(proto.ownerIdentityPublicKey),
+    verifyingPublicKey: (0, import_utils23.bytesToHex)(proto.verifyingPublicKey),
+    ownerIdentityPublicKey: (0, import_utils23.bytesToHex)(proto.ownerIdentityPublicKey),
     signingKeyshare: proto.signingKeyshare,
     status: proto.status,
     network: Network[proto.network]
@@ -30630,14 +30690,14 @@ function mapTreeNodeToWalletLeaf(proto) {
 function mapTransferLeafToWalletTransferLeaf(proto) {
   return {
     leaf: proto.leaf ? mapTreeNodeToWalletLeaf(proto.leaf) : void 0,
-    secretCipher: (0, import_utils22.bytesToHex)(proto.secretCipher),
-    signature: (0, import_utils22.bytesToHex)(proto.signature),
-    intermediateRefundTx: (0, import_utils22.bytesToHex)(proto.intermediateRefundTx)
+    secretCipher: (0, import_utils23.bytesToHex)(proto.secretCipher),
+    signature: (0, import_utils23.bytesToHex)(proto.signature),
+    intermediateRefundTx: (0, import_utils23.bytesToHex)(proto.intermediateRefundTx)
   };
 }
 function mapTransferToWalletTransfer(proto, identityPublicKey, userRequest) {
-  const receiverIdentityPublicKey = (0, import_utils22.bytesToHex)(proto.receiverIdentityPublicKey);
-  const senderIdentityPublicKey = (0, import_utils22.bytesToHex)(proto.senderIdentityPublicKey);
+  const receiverIdentityPublicKey = (0, import_utils23.bytesToHex)(proto.receiverIdentityPublicKey);
+  const senderIdentityPublicKey = (0, import_utils23.bytesToHex)(proto.senderIdentityPublicKey);
   return {
     id: proto.id,
     senderIdentityPublicKey,
@@ -30829,7 +30889,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     try {
       if (event?.$case === "transfer" && event.transfer.transfer && event.transfer.transfer.type !== 40 /* COUNTER_SWAP */) {
         const { senderIdentityPublicKey, receiverIdentityPublicKey } = event.transfer.transfer;
-        if (event.transfer.transfer && !(0, import_utils23.equalBytes)(senderIdentityPublicKey, receiverIdentityPublicKey)) {
+        if (event.transfer.transfer && !(0, import_utils24.equalBytes)(senderIdentityPublicKey, receiverIdentityPublicKey)) {
           await this.claimTransfer({
             transfer: event.transfer.transfer,
             emit: true,
@@ -30898,7 +30958,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
             setTimeout(maybeUnref, 100);
           }
         };
-        if (import_core12.isNode) {
+        if (import_core13.isNode) {
           maybeUnref();
         }
         const claimedTransfersIds = await this.claimTransfers();
@@ -30994,10 +31054,10 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
               leavesToIgnore.add(nodeId);
               continue;
             }
-            if (leaf.status !== operatorLeaf.status || !leaf.signingKeyshare || !operatorLeaf.signingKeyshare || !(0, import_utils23.equalBytes)(
+            if (leaf.status !== operatorLeaf.status || !leaf.signingKeyshare || !operatorLeaf.signingKeyshare || !(0, import_utils24.equalBytes)(
               leaf.signingKeyshare.publicKey,
               operatorLeaf.signingKeyshare.publicKey
-            ) || !(0, import_utils23.equalBytes)(leaf.nodeTx, operatorLeaf.nodeTx)) {
+            ) || !(0, import_utils24.equalBytes)(leaf.nodeTx, operatorLeaf.nodeTx)) {
               leavesToIgnore.add(nodeId);
             }
           }
@@ -31048,7 +31108,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     });
   }
   verifyKey(pubkey1, pubkey2, verifyingKey) {
-    return (0, import_utils23.equalBytes)(addPublicKeys(pubkey1, pubkey2), verifyingKey);
+    return (0, import_utils24.equalBytes)(addPublicKeys(pubkey1, pubkey2), verifyingKey);
   }
   async selectLeaves(targetAmounts) {
     if (targetAmounts.length === 0) {
@@ -31206,7 +31266,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    * @returns {Promise<string>} The identity public key as a hex string.
    */
   async getIdentityPublicKey() {
-    return (0, import_utils23.bytesToHex)(await this.config.signer.getIdentityPublicKey());
+    return (0, import_utils24.bytesToHex)(await this.config.signer.getIdentityPublicKey());
   }
   /**
    * Gets the Spark address of the wallet.
@@ -31216,7 +31276,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   async getSparkAddress() {
     if (!this.sparkAddress) {
       this.sparkAddress = encodeSparkAddress({
-        identityPublicKey: (0, import_utils23.bytesToHex)(
+        identityPublicKey: (0, import_utils24.bytesToHex)(
           await this.config.signer.getIdentityPublicKey()
         ),
         network: this.config.getNetworkType()
@@ -31279,7 +31339,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       $case: "tokensPayment",
       tokensPayment: {
         tokenIdentifier: decodedTokenIdentifier ?? void 0,
-        amount: amount ? (0, import_utils23.numberToVarBytesBE)(amount) : void 0
+        amount: amount ? (0, import_utils24.numberToVarBytesBE)(amount) : void 0
       }
     };
     const invoiceFields = {
@@ -31287,7 +31347,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       id: (0, import_uuidv75.uuidv7obj)().bytes,
       paymentType: protoPayment,
       memo: memo ?? void 0,
-      senderPublicKey: senderPublicKey ? (0, import_utils23.hexToBytes)(senderPublicKey) : void 0,
+      senderPublicKey: senderPublicKey ? (0, import_utils24.hexToBytes)(senderPublicKey) : void 0,
       expiryTime: expiryTime ?? void 0
     };
     validateSparkInvoiceFields(invoiceFields);
@@ -31300,7 +31360,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const signature = await this.config.signer.signSchnorrWithIdentityKey(hash);
     return encodeSparkAddressWithSignature(
       {
-        identityPublicKey: (0, import_utils23.bytesToHex)(identityPublicKey),
+        identityPublicKey: (0, import_utils24.bytesToHex)(identityPublicKey),
         network: this.config.getNetworkType(),
         sparkInvoiceFields: invoiceFields
       },
@@ -31346,7 +31406,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         mnemonic = mnemonicOrSeed;
         seed = await this.config.signer.mnemonicToSeed(mnemonicOrSeed);
       } else {
-        seed = (0, import_utils23.hexToBytes)(mnemonicOrSeed);
+        seed = (0, import_utils24.hexToBytes)(mnemonicOrSeed);
       }
     }
     await this.initWalletFromSeed(seed, accountNumber);
@@ -31368,7 +31428,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       });
     }
     this.sparkAddress = encodeSparkAddress({
-      identityPublicKey: (0, import_utils23.bytesToHex)(identityPublicKey),
+      identityPublicKey: (0, import_utils24.bytesToHex)(identityPublicKey),
       network: this.config.getNetworkType()
     });
     return this.sparkAddress;
@@ -31488,7 +31548,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       directFromCpfpSignatureMap
     } = await this.transferService.startSwapSignRefund(
       leafKeyTweaks,
-      (0, import_utils23.hexToBytes)(this.config.getSspIdentityPublicKey()),
+      (0, import_utils24.hexToBytes)(this.config.getSspIdentityPublicKey()),
       new Date(Date.now() + 2 * 60 * 1e3)
     );
     try {
@@ -31548,18 +31608,18 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       const userLeaves = [];
       userLeaves.push({
         leaf_id: transfer.leaves[0].leaf.id,
-        raw_unsigned_refund_transaction: (0, import_utils23.bytesToHex)(
+        raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
           transfer.leaves[0].intermediateRefundTx
         ),
-        direct_raw_unsigned_refund_transaction: (0, import_utils23.bytesToHex)(
+        direct_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
           transfer.leaves[0].intermediateDirectRefundTx
         ),
-        direct_from_cpfp_raw_unsigned_refund_transaction: (0, import_utils23.bytesToHex)(
+        direct_from_cpfp_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
           transfer.leaves[0].intermediateDirectFromCpfpRefundTx
         ),
-        adaptor_added_signature: (0, import_utils23.bytesToHex)(cpfpAdaptorSignature),
-        direct_adaptor_added_signature: (0, import_utils23.bytesToHex)(directAdaptorSignature),
-        direct_from_cpfp_adaptor_added_signature: (0, import_utils23.bytesToHex)(
+        adaptor_added_signature: (0, import_utils24.bytesToHex)(cpfpAdaptorSignature),
+        direct_adaptor_added_signature: (0, import_utils24.bytesToHex)(directAdaptorSignature),
+        direct_from_cpfp_adaptor_added_signature: (0, import_utils24.bytesToHex)(
           directFromCpfpAdaptorSignature
         )
       });
@@ -31612,24 +31672,24 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         }
         userLeaves.push({
           leaf_id: leaf.leaf.id,
-          raw_unsigned_refund_transaction: (0, import_utils23.bytesToHex)(
+          raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
             leaf.intermediateRefundTx
           ),
-          direct_raw_unsigned_refund_transaction: (0, import_utils23.bytesToHex)(
+          direct_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
             leaf.intermediateDirectRefundTx
           ),
-          direct_from_cpfp_raw_unsigned_refund_transaction: (0, import_utils23.bytesToHex)(
+          direct_from_cpfp_raw_unsigned_refund_transaction: (0, import_utils24.bytesToHex)(
             leaf.intermediateDirectFromCpfpRefundTx
           ),
-          adaptor_added_signature: (0, import_utils23.bytesToHex)(cpfpSignature),
-          direct_adaptor_added_signature: (0, import_utils23.bytesToHex)(directSignature),
-          direct_from_cpfp_adaptor_added_signature: (0, import_utils23.bytesToHex)(
+          adaptor_added_signature: (0, import_utils24.bytesToHex)(cpfpSignature),
+          direct_adaptor_added_signature: (0, import_utils24.bytesToHex)(directSignature),
+          direct_from_cpfp_adaptor_added_signature: (0, import_utils24.bytesToHex)(
             directFromCpfpSignature
           )
         });
       }
       const sspClient = this.getSspClient();
-      const cpfpAdaptorPubkey = (0, import_utils23.bytesToHex)(
+      const cpfpAdaptorPubkey = (0, import_utils24.bytesToHex)(
         import_secp256k115.secp256k1.getPublicKey(cpfpAdaptorPrivateKey)
       );
       if (!cpfpAdaptorPubkey) {
@@ -31637,13 +31697,13 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       }
       let directAdaptorPubkey;
       if (directAdaptorPrivateKey.length > 0) {
-        directAdaptorPubkey = (0, import_utils23.bytesToHex)(
+        directAdaptorPubkey = (0, import_utils24.bytesToHex)(
           import_secp256k115.secp256k1.getPublicKey(directAdaptorPrivateKey)
         );
       }
       let directFromCpfpAdaptorPubkey;
       if (directFromCpfpAdaptorPrivateKey.length > 0) {
-        directFromCpfpAdaptorPubkey = (0, import_utils23.bytesToHex)(
+        directFromCpfpAdaptorPubkey = (0, import_utils24.bytesToHex)(
           import_secp256k115.secp256k1.getPublicKey(directFromCpfpAdaptorPrivateKey)
         );
       }
@@ -31703,7 +31763,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           throw new Error(`Leaf not found for node ${nodeId}`);
         }
         const cpfpNodeTx = getTxFromRawTxBytes(node.nodeTx);
-        const cpfpRefundTxBytes = (0, import_utils23.hexToBytes)(leaf.rawUnsignedRefundTransaction);
+        const cpfpRefundTxBytes = (0, import_utils24.hexToBytes)(leaf.rawUnsignedRefundTransaction);
         const cpfpRefundTx = getTxFromRawTxBytes(cpfpRefundTxBytes);
         const cpfpSighash = getSigHashFromTx(
           cpfpRefundTx,
@@ -31712,7 +31772,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         );
         const nodePublicKey = node.verifyingPublicKey;
         const taprootKey = computeTaprootKeyNoScript(nodePublicKey.slice(1));
-        const cpfpAdaptorSignatureBytes = (0, import_utils23.hexToBytes)(
+        const cpfpAdaptorSignatureBytes = (0, import_utils24.hexToBytes)(
           leaf.adaptorSignedSignature
         );
         applyAdaptorToSignature(
@@ -31723,7 +31783,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         );
         if (leaf.directRawUnsignedRefundTransaction) {
           const directNodeTx = getTxFromRawTxBytes(node.directTx);
-          const directRefundTxBytes = (0, import_utils23.hexToBytes)(
+          const directRefundTxBytes = (0, import_utils24.hexToBytes)(
             leaf.directRawUnsignedRefundTransaction
           );
           const directRefundTx = getTxFromRawTxBytes(directRefundTxBytes);
@@ -31737,7 +31797,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
               `Direct adaptor signed signature missing for node ${nodeId}`
             );
           }
-          const directAdaptorSignatureBytes = (0, import_utils23.hexToBytes)(
+          const directAdaptorSignatureBytes = (0, import_utils24.hexToBytes)(
             leaf.directAdaptorSignedSignature
           );
           applyAdaptorToSignature(
@@ -31748,7 +31808,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           );
         }
         if (leaf.directFromCpfpRawUnsignedRefundTransaction) {
-          const directFromCpfpRefundTxBytes = (0, import_utils23.hexToBytes)(
+          const directFromCpfpRefundTxBytes = (0, import_utils24.hexToBytes)(
             leaf.directFromCpfpRawUnsignedRefundTransaction
           );
           const directFromCpfpRefundTx = getTxFromRawTxBytes(
@@ -31764,7 +31824,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
               `Direct adaptor signed signature missing for node ${nodeId}`
             );
           }
-          const directFromCpfpAdaptorSignatureBytes = (0, import_utils23.hexToBytes)(
+          const directFromCpfpAdaptorSignatureBytes = (0, import_utils24.hexToBytes)(
             leaf.directFromCpfpAdaptorSignedSignature
           );
           applyAdaptorToSignature(
@@ -31783,9 +31843,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         directFromCpfpSignatureMap
       );
       const completeResponse = await sspClient.completeLeaveSwap({
-        adaptorSecretKey: (0, import_utils23.bytesToHex)(cpfpAdaptorPrivateKey),
-        directAdaptorSecretKey: (0, import_utils23.bytesToHex)(directAdaptorPrivateKey),
-        directFromCpfpAdaptorSecretKey: (0, import_utils23.bytesToHex)(
+        adaptorSecretKey: (0, import_utils24.bytesToHex)(cpfpAdaptorPrivateKey),
+        directAdaptorSecretKey: (0, import_utils24.bytesToHex)(directAdaptorPrivateKey),
+        directFromCpfpAdaptorSecretKey: (0, import_utils24.bytesToHex)(
           directFromCpfpAdaptorPrivateKey
         ),
         userOutboundTransferExternalId: transfer.id,
@@ -31880,12 +31940,12 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     let tokenMetadataMap = /* @__PURE__ */ new Map();
     for (const [tokenIdentifier, metadata] of this.tokenMetadata) {
       tokenMetadataMap.set(tokenIdentifier, {
-        tokenPublicKey: (0, import_utils23.bytesToHex)(metadata.issuerPublicKey),
+        tokenPublicKey: (0, import_utils24.bytesToHex)(metadata.issuerPublicKey),
         rawTokenIdentifier: metadata.tokenIdentifier,
         tokenName: metadata.tokenName,
         tokenTicker: metadata.tokenTicker,
         decimals: metadata.decimals,
-        maxSupply: (0, import_utils23.bytesToNumberBE)(metadata.maxSupply)
+        maxSupply: (0, import_utils24.bytesToNumberBE)(metadata.maxSupply)
       });
     }
     return tokenMetadataMap;
@@ -32009,7 +32069,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         offset
       });
       return response.utxos.map((utxo) => ({
-        txid: (0, import_utils23.bytesToHex)(utxo.txid),
+        txid: (0, import_utils24.bytesToHex)(utxo.txid),
         vout: utxo.vout
       })) ?? [];
     } catch (error) {
@@ -32079,7 +32139,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     if (network === BitcoinNetwork_default.FUTURE_VALUE) {
       network = BitcoinNetwork_default.REGTEST;
     }
-    const depositSecretKey = (0, import_utils23.bytesToHex)(
+    const depositSecretKey = (0, import_utils24.bytesToHex)(
       await this.config.signer.getStaticDepositSecretKey(0)
     );
     const message = await this.getStaticDepositSigningPayload(
@@ -32092,7 +32152,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     );
     const hashBuffer = (0, import_sha212.sha256)(message);
     const signatureBytes = await this.config.signer.signMessageWithIdentityKey(hashBuffer);
-    const signature = (0, import_utils23.bytesToHex)(signatureBytes);
+    const signature = (0, import_utils24.bytesToHex)(signatureBytes);
     const response = await this.sspClient.claimStaticDeposit({
       transactionId,
       outputIndex,
@@ -32244,7 +32304,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       networkJSON.toLowerCase(),
       2 /* Refund */,
       creditAmountSats,
-      (0, import_utils23.bytesToHex)(spendTxSighash)
+      (0, import_utils24.bytesToHex)(spendTxSighash)
     );
     const hashBuffer = (0, import_sha212.sha256)(message);
     const swapResponseUserSignature = await this.config.signer.signMessageWithIdentityKey(hashBuffer);
@@ -32253,7 +32313,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     );
     const swapResponse = await sparkClient.initiate_static_deposit_utxo_refund({
       onChainUtxo: {
-        txid: (0, import_utils23.hexToBytes)(depositTransactionId),
+        txid: (0, import_utils24.hexToBytes)(depositTransactionId),
         vout: outputIndex,
         network: networkType
       },
@@ -32322,7 +32382,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     creditAmountView.setUint32(0, lowerHalf, true);
     creditAmountView.setUint32(4, upperHalf, true);
     parts.push(new Uint8Array(creditAmountBuffer));
-    parts.push((0, import_utils23.hexToBytes)(sspSignature));
+    parts.push((0, import_utils24.hexToBytes)(sspSignature));
     const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
     const payload = new Uint8Array(totalLength);
     let offset = 0;
@@ -32727,9 +32787,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       });
     }
     const signerIdentityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const isSelfTransfer = (0, import_utils23.equalBytes)(
+    const isSelfTransfer = (0, import_utils24.equalBytes)(
       signerIdentityPublicKey,
-      (0, import_utils23.hexToBytes)(receiverAddress.identityPublicKey)
+      (0, import_utils24.hexToBytes)(receiverAddress.identityPublicKey)
     );
     return await this.withLeaves(async () => {
       let leavesToSend = (await this.selectLeaves([amountSats])).get(
@@ -32751,7 +32811,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       );
       const transfer = await this.transferService.sendTransferWithKeyTweaks(
         leafKeyTweaks,
-        (0, import_utils23.hexToBytes)(receiverAddress.identityPublicKey)
+        (0, import_utils24.hexToBytes)(receiverAddress.identityPublicKey)
       );
       const leavesToRemove = new Set(leavesToSend.map((leaf) => leaf.id));
       this.leaves = this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id));
@@ -32767,7 +32827,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       }
       return mapTransferToWalletTransfer(
         transfer,
-        (0, import_utils23.bytesToHex)(await this.config.signer.getIdentityPublicKey())
+        (0, import_utils24.bytesToHex)(await this.config.signer.getIdentityPublicKey())
       );
     });
   }
@@ -33123,7 +33183,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       const invoice2 = await sspClient.requestLightningReceive({
         amountSats: amountSats2,
         network: bitcoinNetwork,
-        paymentHash: (0, import_utils23.bytesToHex)(paymentHash),
+        paymentHash: (0, import_utils24.bytesToHex)(paymentHash),
         expirySecs: expirySeconds,
         memo: memo2,
         includeSparkAddress,
@@ -33232,7 +33292,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const sparkFallbackAddress = decodedInvoice.fallbackAddress;
     const paymentHash = decodedInvoice.paymentHash;
     if (preferSpark) {
-      if (sparkFallbackAddress === void 0 || isValidSparkFallback((0, import_utils23.hexToBytes)(sparkFallbackAddress)) === false) {
+      if (sparkFallbackAddress === void 0 || isValidSparkFallback((0, import_utils24.hexToBytes)(sparkFallbackAddress)) === false) {
         console.warn(
           "No valid spark address found in invoice. Defaulting to lightning."
         );
@@ -33286,10 +33346,10 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       );
       const swapResponse = await this.lightningService.swapNodesForPreimage({
         leaves: leavesToSend,
-        receiverIdentityPubkey: (0, import_utils23.hexToBytes)(
+        receiverIdentityPubkey: (0, import_utils24.hexToBytes)(
           this.config.getSspIdentityPublicKey()
         ),
-        paymentHash: (0, import_utils23.hexToBytes)(paymentHash),
+        paymentHash: (0, import_utils24.hexToBytes)(paymentHash),
         isInboundPayment: false,
         invoiceString: invoice,
         feeSats: feeEstimate,
@@ -33407,7 +33467,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     });
     await this.syncTokenOutputs();
     const bech32mTokenIdentifier = encodeBech32mTokenIdentifier({
-      tokenIdentifier: (0, import_utils23.hexToBytes)(firstTokenIdentifierHexSeen),
+      tokenIdentifier: (0, import_utils24.hexToBytes)(firstTokenIdentifierHexSeen),
       network: this.config.getNetworkType()
     });
     const receiverOutputs = decoded.map((d) => ({
@@ -33438,7 +33498,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     if (!feeEstimate) {
       throw new Error("Failed to get lightning send fee estimate");
     }
-    const satsFeeEstimate = (0, import_core12.mapCurrencyAmount)(feeEstimate.feeEstimate);
+    const satsFeeEstimate = (0, import_core13.mapCurrencyAmount)(feeEstimate.feeEstimate);
     return Math.ceil(satsFeeEstimate.sats);
   }
   // ***** Cooperative Exit Flow *****
@@ -33595,11 +33655,11 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const connectorOutputs = [];
     for (let i = 0; i < connectorTx.outputsLength - 1; i++) {
       connectorOutputs.push({
-        txid: (0, import_utils23.hexToBytes)(connectorTxId),
+        txid: (0, import_utils24.hexToBytes)(connectorTxId),
         index: i
       });
     }
-    const sspPubIdentityKey = (0, import_utils23.hexToBytes)(this.config.getSspIdentityPublicKey());
+    const sspPubIdentityKey = (0, import_utils24.hexToBytes)(this.config.getSspIdentityPublicKey());
     const transfer = await this.coopExitService.getConnectorRefundSignatures({
       leaves: leafKeyTweaks,
       exitTxId: coopExitTxId,
@@ -33653,7 +33713,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     return transfers?.[0];
   }
   async constructTransfersWithUserRequest(transfers) {
-    const identityPublicKey = (0, import_utils23.bytesToHex)(
+    const identityPublicKey = (0, import_utils24.bytesToHex)(
       await this.config.signer.getIdentityPublicKey()
     );
     const userRequests = await this.sspClient?.getTransfers(
@@ -33897,7 +33957,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       hash,
       compact
     );
-    return (0, import_utils23.bytesToHex)(signature);
+    return (0, import_utils24.bytesToHex)(signature);
   }
   /**
    * Validates a message with the identity key.
@@ -33909,7 +33969,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   async validateMessageWithIdentityKey(message, signature) {
     const hash = (0, import_sha212.sha256)(message);
     if (typeof signature === "string") {
-      signature = (0, import_utils23.hexToBytes)(signature);
+      signature = (0, import_utils24.hexToBytes)(signature);
     }
     return this.config.signer.validateMessageWithIdentityKey(hash, signature);
   }
@@ -33922,7 +33982,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    */
   async signTransaction(txHex, keyType = "auto-detect") {
     try {
-      const tx = import_btc_signer6.Transaction.fromRaw((0, import_utils23.hexToBytes)(txHex));
+      const tx = import_btc_signer6.Transaction.fromRaw((0, import_utils24.hexToBytes)(txHex));
       let publicKey;
       switch (keyType.toLowerCase()) {
         case "identity":
@@ -33955,7 +34015,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           publicKey,
           this.config.getNetwork()
         );
-        if ((0, import_utils23.bytesToHex)(script) === (0, import_utils23.bytesToHex)(identityScript)) {
+        if ((0, import_utils24.bytesToHex)(script) === (0, import_utils24.bytesToHex)(identityScript)) {
           try {
             this.config.signer.signTransactionIndex(tx, i, publicKey);
             inputsSigned++;
@@ -33999,13 +34059,13 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
             depositPubKey,
             this.config.getNetwork()
           );
-          if ((0, import_utils23.bytesToHex)(script) === (0, import_utils23.bytesToHex)(identityScript)) {
+          if ((0, import_utils24.bytesToHex)(script) === (0, import_utils24.bytesToHex)(identityScript)) {
             return {
               publicKey: identityPubKey,
               keyType: "identity"
             };
           }
-          if ((0, import_utils23.bytesToHex)(script) === (0, import_utils23.bytesToHex)(depositScript)) {
+          if ((0, import_utils24.bytesToHex)(script) === (0, import_utils24.bytesToHex)(depositScript)) {
             return {
               publicKey: depositPubKey,
               keyType: "deposit"
@@ -34348,7 +34408,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         } catch (error) {
           if (error instanceof Error) {
             error.message += ` [traceId: ${traceId}]`;
-          } else if ((0, import_core12.isObject)(error)) {
+          } else if ((0, import_core13.isObject)(error)) {
             error["traceId"] = traceId;
           }
           throw error;
@@ -34424,9 +34484,11 @@ __export(utils_exports, {
   DIRECT_TIMELOCK_OFFSET: () => DIRECT_TIMELOCK_OFFSET,
   INITIAL_DIRECT_SEQUENCE: () => INITIAL_DIRECT_SEQUENCE,
   INITIAL_SEQUENCE: () => INITIAL_SEQUENCE,
+  LOGGER_NAMES: () => LOGGER_NAMES,
   LRC_WALLET_NETWORK: () => LRC_WALLET_NETWORK,
   Network: () => Network2,
   NetworkToProto: () => NetworkToProto,
+  SparkSdkLogger: () => SparkSdkLogger,
   TEST_UNILATERAL_DIRECT_SEQUENCE: () => TEST_UNILATERAL_DIRECT_SEQUENCE,
   TEST_UNILATERAL_SEQUENCE: () => TEST_UNILATERAL_SEQUENCE,
   addPrivateKeys: () => addPrivateKeys,
@@ -34573,7 +34635,7 @@ async function isTxBroadcast(txid, baseUrl, network) {
 
 // src/utils/unilateral-exit.ts
 init_buffer();
-var import_utils24 = require("@noble/curves/abstract/utils");
+var import_utils25 = require("@noble/curves/abstract/utils");
 var import_legacy = require("@noble/hashes/legacy");
 var import_sha213 = require("@noble/hashes/sha2");
 var btc4 = __toESM(require("@scure/btc-signer"), 1);
@@ -34588,7 +34650,7 @@ function isEphemeralAnchorOutput(script, amount) {
 }
 async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network) {
   const result = [];
-  const nodes = nodeHexStrings.map((hex) => TreeNode.decode((0, import_utils24.hexToBytes)(hex)));
+  const nodes = nodeHexStrings.map((hex) => TreeNode.decode((0, import_utils25.hexToBytes)(hex)));
   const nodeMap = /* @__PURE__ */ new Map();
   for (const node of nodes) {
     nodeMap.set(node.id, node);
@@ -34644,10 +34706,10 @@ async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network)
       }
     }
     for (const chainNode of chain) {
-      const nodeTx = (0, import_utils24.bytesToHex)(chainNode.nodeTx);
+      const nodeTx = (0, import_utils25.bytesToHex)(chainNode.nodeTx);
       transactions.push(nodeTx);
       if (chainNode.id === node.id) {
-        const refundTx = (0, import_utils24.bytesToHex)(chainNode.refundTx);
+        const refundTx = (0, import_utils25.bytesToHex)(chainNode.refundTx);
         transactions.push(refundTx);
       }
     }
@@ -34677,7 +34739,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           `Node hex string at index ${i} appears to be a raw transaction hex, not a TreeNode protobuf. Use 'leafidtohex' command to convert node IDs to proper hex strings.`
         );
       }
-      const nodeBytes = (0, import_utils24.hexToBytes)(hex);
+      const nodeBytes = (0, import_utils25.hexToBytes)(hex);
       const node = TreeNode.decode(nodeBytes);
       if (!node.id) {
         throw new Error(
@@ -34753,7 +34815,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
       }
     }
     for (const chainNode of chain) {
-      let nodeTxHex = (0, import_utils24.bytesToHex)(chainNode.nodeTx);
+      let nodeTxHex = (0, import_utils25.bytesToHex)(chainNode.nodeTx);
       try {
         const txObj = getTxFromRawTxHex(nodeTxHex);
         const txid = getTxId(txObj);
@@ -34770,7 +34832,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
         for (let i = txObj.outputsLength - 1; i >= 0; i--) {
           const output = txObj.getOutput(i);
           if (output?.amount === 0n && output.script) {
-            anchorOutputScriptHex = (0, import_utils24.bytesToHex)(output.script);
+            anchorOutputScriptHex = (0, import_utils25.bytesToHex)(output.script);
             break;
           }
         }
@@ -34791,11 +34853,11 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
         usedUtxos,
         correctedParentTx
       } = constructFeeBumpTx(nodeTxHex, availableUtxos, feeRate, void 0);
-      const feeBumpTx = btc4.Transaction.fromPSBT((0, import_utils24.hexToBytes)(nodeFeeBumpPsbt));
+      const feeBumpTx = btc4.Transaction.fromPSBT((0, import_utils25.hexToBytes)(nodeFeeBumpPsbt));
       var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
       var feeBumpOutPubKey = null;
       for (const usedUtxo of usedUtxos) {
-        if (feeBumpOut && (0, import_utils24.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
+        if (feeBumpOut && (0, import_utils25.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
           feeBumpOutPubKey = usedUtxo.publicKey;
         }
         const index = availableUtxos.findIndex(
@@ -34810,20 +34872,20 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           txid: getTxId(feeBumpTx),
           vout: 0,
           value: feeBumpOut.amount,
-          script: (0, import_utils24.bytesToHex)(feeBumpOut.script),
+          script: (0, import_utils25.bytesToHex)(feeBumpOut.script),
           publicKey: feeBumpOutPubKey
         });
       const finalNodeTx = correctedParentTx || nodeTxHex;
       txPackages.push({ tx: finalNodeTx, feeBumpPsbt: nodeFeeBumpPsbt });
       if (chainNode.id === node.id) {
-        let refundTxHex = (0, import_utils24.bytesToHex)(chainNode.refundTx);
+        let refundTxHex = (0, import_utils25.bytesToHex)(chainNode.refundTx);
         try {
           const txObj = getTxFromRawTxHex(refundTxHex);
           let anchorOutputScriptHex;
           for (let i = txObj.outputsLength - 1; i >= 0; i--) {
             const output = txObj.getOutput(i);
             if (output?.amount === 0n && output.script) {
-              anchorOutputScriptHex = (0, import_utils24.bytesToHex)(output.script);
+              anchorOutputScriptHex = (0, import_utils25.bytesToHex)(output.script);
               break;
             }
           }
@@ -34846,12 +34908,12 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           void 0
         );
         const feeBumpTx2 = btc4.Transaction.fromPSBT(
-          (0, import_utils24.hexToBytes)(refundFeeBump.feeBumpPsbt)
+          (0, import_utils25.hexToBytes)(refundFeeBump.feeBumpPsbt)
         );
         var feeBumpOut = feeBumpTx2.outputsLength === 1 ? feeBumpTx2.getOutput(0) : null;
         var feeBumpOutPubKey = null;
         for (const usedUtxo of usedUtxos) {
-          if (feeBumpOut && (0, import_utils24.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
+          if (feeBumpOut && (0, import_utils25.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
             feeBumpOutPubKey = usedUtxo.publicKey;
           }
           const index = availableUtxos.findIndex(
@@ -34866,7 +34928,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
             txid: getTxId(feeBumpTx2),
             vout: 0,
             value: feeBumpOut.amount,
-            script: (0, import_utils24.bytesToHex)(feeBumpOut.script),
+            script: (0, import_utils25.bytesToHex)(feeBumpOut.script),
             publicKey: feeBumpOutPubKey
           });
         txPackages.push({
@@ -34961,10 +35023,10 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
     if (!fundingUtxo) {
       throw new Error(`UTXO at index ${i} is undefined`);
     }
-    const pubKeyHash = hash160((0, import_utils24.hexToBytes)(fundingUtxo.publicKey));
+    const pubKeyHash = hash160((0, import_utils25.hexToBytes)(fundingUtxo.publicKey));
     const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
-    const providedScript = (0, import_utils24.hexToBytes)(fundingUtxo.script);
-    if ((0, import_utils24.bytesToHex)(scriptToUse) !== (0, import_utils24.bytesToHex)(providedScript)) {
+    const providedScript = (0, import_utils25.hexToBytes)(fundingUtxo.script);
+    if ((0, import_utils25.bytesToHex)(scriptToUse) !== (0, import_utils25.bytesToHex)(providedScript)) {
       throw new Error(
         `\u274C  Derived script doesn't match provided script for UTXO ${i + 1}.`
       );
@@ -35029,7 +35091,7 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
   }
   let psbtHex;
   try {
-    psbtHex = (0, import_utils24.bytesToHex)(builder.toPSBT());
+    psbtHex = (0, import_utils25.bytesToHex)(builder.toPSBT());
   } catch (error) {
     throw new Error(`Failed to extract transaction: ${error}`);
   }
@@ -35071,6 +35133,9 @@ function getSparkAddressFromTaproot(taprootAddress) {
   throw new ValidationError("Invalid taproot address");
 }
 
+// src/utils/index.ts
+init_logging();
+
 // src/debug.ts
 var s = {
   SparkWallet,