@buildonspark/spark-sdk 0.2.10 → 0.2.12

package/dist/index.cjs

@@ -50,6 +50,43 @@ var init_buffer = __esm({
   }
 });
 
+// src/utils/logging.ts
+var import_core8, LOGGER_NAMES, SparkSdkLogger;
+var init_logging = __esm({
+  "src/utils/logging.ts"() {
+    "use strict";
+    init_buffer();
+    import_core8 = 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_core8.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/wasm/spark_bindings.js
 function getUint8ArrayMemory0() {
   if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -1073,6 +1110,13 @@ function signFrost({
   statechainCommitments,
   adaptorPubKey
 }) {
+  SparkSdkLogger.get(LOGGER_NAMES.wasm).trace("signFrost", {
+    message: (0, import_utils12.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_utils12.bytesToHex)(message),
+    statechainCommitments,
+    selfCommitment,
+    statechainSignatures,
+    selfSignature: (0, import_utils12.bytesToHex)(selfSignature),
+    statechainPublicKeys,
+    selfPublicKey: (0, import_utils12.bytesToHex)(selfPublicKey),
+    verifyingKey: (0, import_utils12.bytesToHex)(verifyingKey),
+    adaptorPubKey: adaptorPubKey ? (0, import_utils12.bytesToHex)(adaptorPubKey) : void 0
+  });
   return wasm_aggregate_frost(
     message,
     statechainCommitments,
@@ -1123,11 +1178,14 @@ function decryptEcies({
 }) {
   return decrypt_ecies(encryptedMsg, privateKey);
 }
+var import_utils12;
 var init_wasm = __esm({
   "src/spark_bindings/wasm/index.ts"() {
     "use strict";
     init_buffer();
+    import_utils12 = 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() {
@@ -1317,6 +1375,7 @@ __export(index_exports, {
   INITIAL_SEQUENCE: () => INITIAL_SEQUENCE,
   InternalValidationError: () => InternalValidationError,
   KeyDerivationType: () => KeyDerivationType,
+  LOGGER_NAMES: () => LOGGER_NAMES,
   LRC_WALLET_NETWORK: () => LRC_WALLET_NETWORK,
   Network: () => Network2,
   NetworkError: () => NetworkError,
@@ -1324,6 +1383,7 @@ __export(index_exports, {
   NotImplementedError: () => NotImplementedError,
   RPCError: () => RPCError,
   SparkSDKError: () => SparkSDKError,
+  SparkSdkLogger: () => SparkSdkLogger,
   SparkWallet: () => SparkWalletBrowser,
   TEST_UNILATERAL_DIRECT_SEQUENCE: () => TEST_UNILATERAL_DIRECT_SEQUENCE,
   TEST_UNILATERAL_SEQUENCE: () => TEST_UNILATERAL_SEQUENCE,
@@ -1556,9 +1616,97 @@ init_buffer();
 
 // src/utils/address.ts
 init_buffer();
+var import_wire5 = require("@bufbuild/protobuf/wire");
 var import_secp256k1 = require("@noble/curves/secp256k1");
-var import_utils2 = require("@noble/hashes/utils");
+var import_utils2 = require("@noble/curves/utils");
+var import_utils3 = require("@noble/hashes/utils");
 var import_base2 = require("@scure/base");
+var import_uuidv7 = require("uuidv7");
+
+// src/proto/google/protobuf/timestamp.ts
+init_buffer();
+var import_wire = require("@bufbuild/protobuf/wire");
+function createBaseTimestamp() {
+  return { seconds: 0, nanos: 0 };
+}
+var Timestamp = {
+  encode(message, writer = new import_wire.BinaryWriter()) {
+    if (message.seconds !== 0) {
+      writer.uint32(8).int64(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTimestamp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.seconds = longToNumber(reader.int64());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.nanos = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      seconds: isSet(object.seconds) ? globalThis.Number(object.seconds) : 0,
+      nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.seconds !== 0) {
+      obj.seconds = Math.round(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      obj.nanos = Math.round(message.nanos);
+    }
+    return obj;
+  },
+  create(base) {
+    return Timestamp.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTimestamp();
+    message.seconds = object.seconds ?? 0;
+    message.nanos = object.nanos ?? 0;
+    return message;
+  }
+};
+function longToNumber(int64) {
+  const num = globalThis.Number(int64.toString());
+  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+  }
+  return num;
+}
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
 
 // src/proto/spark.ts
 init_buffer();
@@ -1566,7 +1714,7 @@ var import_wire4 = require("@bufbuild/protobuf/wire");
 
 // src/proto/common.ts
 init_buffer();
-var import_wire = require("@bufbuild/protobuf/wire");
+var import_wire2 = require("@bufbuild/protobuf/wire");
 function signatureIntentFromJSON(object) {
   switch (object) {
     case 0:
@@ -1611,7 +1759,7 @@ function createBaseSigningCommitment() {
   return { hiding: new Uint8Array(0), binding: new Uint8Array(0) };
 }
 var SigningCommitment = {
-  encode(message, writer = new import_wire.BinaryWriter()) {
+  encode(message, writer = new import_wire2.BinaryWriter()) {
     if (message.hiding.length !== 0) {
       writer.uint32(10).bytes(message.hiding);
     }
@@ -1621,7 +1769,7 @@ var SigningCommitment = {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
+    const reader = input instanceof import_wire2.BinaryReader ? input : new import_wire2.BinaryReader(input);
     const end = length === void 0 ? reader.len : reader.pos + length;
     const message = createBaseSigningCommitment();
     while (reader.pos < end) {
@@ -1651,8 +1799,8 @@ var SigningCommitment = {
   },
   fromJSON(object) {
     return {
-      hiding: isSet(object.hiding) ? bytesFromBase64(object.hiding) : new Uint8Array(0),
-      binding: isSet(object.binding) ? bytesFromBase64(object.binding) : new Uint8Array(0)
+      hiding: isSet2(object.hiding) ? bytesFromBase64(object.hiding) : new Uint8Array(0),
+      binding: isSet2(object.binding) ? bytesFromBase64(object.binding) : new Uint8Array(0)
     };
   },
   toJSON(message) {
@@ -1698,22 +1846,22 @@ function base64FromBytes(arr) {
     return globalThis.btoa(bin.join(""));
   }
 }
-function isSet(value) {
+function isSet2(value) {
   return value !== null && value !== void 0;
 }
 
 // src/proto/google/protobuf/empty.ts
 init_buffer();
-var import_wire2 = require("@bufbuild/protobuf/wire");
+var import_wire3 = require("@bufbuild/protobuf/wire");
 function createBaseEmpty() {
   return {};
 }
 var Empty = {
-  encode(_, writer = new import_wire2.BinaryWriter()) {
+  encode(_, writer = new import_wire3.BinaryWriter()) {
     return writer;
   },
   decode(input, length) {
-    const reader = input instanceof import_wire2.BinaryReader ? input : new import_wire2.BinaryReader(input);
+    const reader = input instanceof import_wire3.BinaryReader ? input : new import_wire3.BinaryReader(input);
     const end = length === void 0 ? reader.len : reader.pos + length;
     const message = createBaseEmpty();
     while (reader.pos < end) {
@@ -1743,91 +1891,6 @@ var Empty = {
   }
 };
 
-// src/proto/google/protobuf/timestamp.ts
-init_buffer();
-var import_wire3 = require("@bufbuild/protobuf/wire");
-function createBaseTimestamp() {
-  return { seconds: 0, nanos: 0 };
-}
-var Timestamp = {
-  encode(message, writer = new import_wire3.BinaryWriter()) {
-    if (message.seconds !== 0) {
-      writer.uint32(8).int64(message.seconds);
-    }
-    if (message.nanos !== 0) {
-      writer.uint32(16).int32(message.nanos);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof import_wire3.BinaryReader ? input : new import_wire3.BinaryReader(input);
-    const end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseTimestamp();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 8) {
-            break;
-          }
-          message.seconds = longToNumber(reader.int64());
-          continue;
-        }
-        case 2: {
-          if (tag !== 16) {
-            break;
-          }
-          message.nanos = reader.int32();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      seconds: isSet2(object.seconds) ? globalThis.Number(object.seconds) : 0,
-      nanos: isSet2(object.nanos) ? globalThis.Number(object.nanos) : 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.seconds !== 0) {
-      obj.seconds = Math.round(message.seconds);
-    }
-    if (message.nanos !== 0) {
-      obj.nanos = Math.round(message.nanos);
-    }
-    return obj;
-  },
-  create(base) {
-    return Timestamp.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseTimestamp();
-    message.seconds = object.seconds ?? 0;
-    message.nanos = object.nanos ?? 0;
-    return message;
-  }
-};
-function longToNumber(int64) {
-  const num = globalThis.Number(int64.toString());
-  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
-    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
-  }
-  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
-    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
-  }
-  return num;
-}
-function isSet2(value) {
-  return value !== null && value !== void 0;
-}
-
 // src/proto/spark.ts
 var Network = /* @__PURE__ */ ((Network5) => {
   Network5[Network5["UNSPECIFIED"] = 0] = "UNSPECIFIED";
@@ -2123,6 +2186,41 @@ function utxoSwapRequestTypeToJSON(object) {
       return "UNRECOGNIZED";
   }
 }
+function invoiceStatusFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "NOT_FOUND":
+      return 0 /* NOT_FOUND */;
+    case 1:
+    case "PENDING":
+      return 1 /* PENDING */;
+    case 2:
+    case "FINALIZED":
+      return 2 /* FINALIZED */;
+    case 3:
+    case "EXPIRED":
+      return 3 /* EXPIRED */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function invoiceStatusToJSON(object) {
+  switch (object) {
+    case 0 /* NOT_FOUND */:
+      return "NOT_FOUND";
+    case 1 /* PENDING */:
+      return "PENDING";
+    case 2 /* FINALIZED */:
+      return "FINALIZED";
+    case 3 /* EXPIRED */:
+      return "EXPIRED";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
 function initiatePreimageSwapRequest_ReasonFromJSON(object) {
   switch (object) {
     case 0:
@@ -2862,6 +2960,140 @@ var GenerateDepositAddressResponse = {
     return message;
   }
 };
+function createBaseGenerateStaticDepositAddressRequest() {
+  return { signingPublicKey: new Uint8Array(0), identityPublicKey: new Uint8Array(0), network: 0 };
+}
+var GenerateStaticDepositAddressRequest = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.signingPublicKey.length !== 0) {
+      writer.uint32(10).bytes(message.signingPublicKey);
+    }
+    if (message.identityPublicKey.length !== 0) {
+      writer.uint32(18).bytes(message.identityPublicKey);
+    }
+    if (message.network !== 0) {
+      writer.uint32(24).int32(message.network);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseGenerateStaticDepositAddressRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.signingPublicKey = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.identityPublicKey = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.network = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      signingPublicKey: isSet3(object.signingPublicKey) ? bytesFromBase642(object.signingPublicKey) : new Uint8Array(0),
+      identityPublicKey: isSet3(object.identityPublicKey) ? bytesFromBase642(object.identityPublicKey) : new Uint8Array(0),
+      network: isSet3(object.network) ? networkFromJSON(object.network) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.signingPublicKey.length !== 0) {
+      obj.signingPublicKey = base64FromBytes2(message.signingPublicKey);
+    }
+    if (message.identityPublicKey.length !== 0) {
+      obj.identityPublicKey = base64FromBytes2(message.identityPublicKey);
+    }
+    if (message.network !== 0) {
+      obj.network = networkToJSON(message.network);
+    }
+    return obj;
+  },
+  create(base) {
+    return GenerateStaticDepositAddressRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseGenerateStaticDepositAddressRequest();
+    message.signingPublicKey = object.signingPublicKey ?? new Uint8Array(0);
+    message.identityPublicKey = object.identityPublicKey ?? new Uint8Array(0);
+    message.network = object.network ?? 0;
+    return message;
+  }
+};
+function createBaseGenerateStaticDepositAddressResponse() {
+  return { depositAddress: void 0 };
+}
+var GenerateStaticDepositAddressResponse = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.depositAddress !== void 0) {
+      Address.encode(message.depositAddress, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseGenerateStaticDepositAddressResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.depositAddress = Address.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { depositAddress: isSet3(object.depositAddress) ? Address.fromJSON(object.depositAddress) : void 0 };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.depositAddress !== void 0) {
+      obj.depositAddress = Address.toJSON(message.depositAddress);
+    }
+    return obj;
+  },
+  create(base) {
+    return GenerateStaticDepositAddressResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseGenerateStaticDepositAddressResponse();
+    message.depositAddress = object.depositAddress !== void 0 && object.depositAddress !== null ? Address.fromPartial(object.depositAddress) : void 0;
+    return message;
+  }
+};
 function createBaseUTXO() {
   return { rawTx: new Uint8Array(0), vout: 0, network: 0, txid: new Uint8Array(0) };
 }
@@ -8975,7 +9207,8 @@ function createBaseTransferLeaf() {
     signature: new Uint8Array(0),
     intermediateRefundTx: new Uint8Array(0),
     intermediateDirectRefundTx: new Uint8Array(0),
-    intermediateDirectFromCpfpRefundTx: new Uint8Array(0)
+    intermediateDirectFromCpfpRefundTx: new Uint8Array(0),
+    pendingKeyTweakPublicKey: new Uint8Array(0)
   };
 }
 var TransferLeaf = {
@@ -8998,6 +9231,9 @@ var TransferLeaf = {
     if (message.intermediateDirectFromCpfpRefundTx.length !== 0) {
       writer.uint32(50).bytes(message.intermediateDirectFromCpfpRefundTx);
     }
+    if (message.pendingKeyTweakPublicKey.length !== 0) {
+      writer.uint32(58).bytes(message.pendingKeyTweakPublicKey);
+    }
     return writer;
   },
   decode(input, length) {
@@ -9049,6 +9285,13 @@ var TransferLeaf = {
           message.intermediateDirectFromCpfpRefundTx = reader.bytes();
           continue;
         }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.pendingKeyTweakPublicKey = reader.bytes();
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -9064,7 +9307,8 @@ var TransferLeaf = {
       signature: isSet3(object.signature) ? bytesFromBase642(object.signature) : new Uint8Array(0),
       intermediateRefundTx: isSet3(object.intermediateRefundTx) ? bytesFromBase642(object.intermediateRefundTx) : new Uint8Array(0),
       intermediateDirectRefundTx: isSet3(object.intermediateDirectRefundTx) ? bytesFromBase642(object.intermediateDirectRefundTx) : new Uint8Array(0),
-      intermediateDirectFromCpfpRefundTx: isSet3(object.intermediateDirectFromCpfpRefundTx) ? bytesFromBase642(object.intermediateDirectFromCpfpRefundTx) : new Uint8Array(0)
+      intermediateDirectFromCpfpRefundTx: isSet3(object.intermediateDirectFromCpfpRefundTx) ? bytesFromBase642(object.intermediateDirectFromCpfpRefundTx) : new Uint8Array(0),
+      pendingKeyTweakPublicKey: isSet3(object.pendingKeyTweakPublicKey) ? bytesFromBase642(object.pendingKeyTweakPublicKey) : new Uint8Array(0)
     };
   },
   toJSON(message) {
@@ -9087,6 +9331,9 @@ var TransferLeaf = {
     if (message.intermediateDirectFromCpfpRefundTx.length !== 0) {
       obj.intermediateDirectFromCpfpRefundTx = base64FromBytes2(message.intermediateDirectFromCpfpRefundTx);
     }
+    if (message.pendingKeyTweakPublicKey.length !== 0) {
+      obj.pendingKeyTweakPublicKey = base64FromBytes2(message.pendingKeyTweakPublicKey);
+    }
     return obj;
   },
   create(base) {
@@ -9100,6 +9347,7 @@ var TransferLeaf = {
     message.intermediateRefundTx = object.intermediateRefundTx ?? new Uint8Array(0);
     message.intermediateDirectRefundTx = object.intermediateDirectRefundTx ?? new Uint8Array(0);
     message.intermediateDirectFromCpfpRefundTx = object.intermediateDirectFromCpfpRefundTx ?? new Uint8Array(0);
+    message.pendingKeyTweakPublicKey = object.pendingKeyTweakPublicKey ?? new Uint8Array(0);
     return message;
   }
 };
@@ -11997,13 +12245,16 @@ var QueryUserSignedRefundsRequest = {
   }
 };
 function createBaseQueryUserSignedRefundsResponse() {
-  return { userSignedRefunds: [] };
+  return { userSignedRefunds: [], transfer: void 0 };
 }
 var QueryUserSignedRefundsResponse = {
   encode(message, writer = new import_wire4.BinaryWriter()) {
     for (const v of message.userSignedRefunds) {
       UserSignedRefund.encode(v, writer.uint32(10).fork()).join();
     }
+    if (message.transfer !== void 0) {
+      Transfer.encode(message.transfer, writer.uint32(26).fork()).join();
+    }
     return writer;
   },
   decode(input, length) {
@@ -12020,6 +12271,13 @@ var QueryUserSignedRefundsResponse = {
           message.userSignedRefunds.push(UserSignedRefund.decode(reader, reader.uint32()));
           continue;
         }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.transfer = Transfer.decode(reader, reader.uint32());
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -12030,7 +12288,8 @@ var QueryUserSignedRefundsResponse = {
   },
   fromJSON(object) {
     return {
-      userSignedRefunds: globalThis.Array.isArray(object?.userSignedRefunds) ? object.userSignedRefunds.map((e) => UserSignedRefund.fromJSON(e)) : []
+      userSignedRefunds: globalThis.Array.isArray(object?.userSignedRefunds) ? object.userSignedRefunds.map((e) => UserSignedRefund.fromJSON(e)) : [],
+      transfer: isSet3(object.transfer) ? Transfer.fromJSON(object.transfer) : void 0
     };
   },
   toJSON(message) {
@@ -12038,6 +12297,9 @@ var QueryUserSignedRefundsResponse = {
     if (message.userSignedRefunds?.length) {
       obj.userSignedRefunds = message.userSignedRefunds.map((e) => UserSignedRefund.toJSON(e));
     }
+    if (message.transfer !== void 0) {
+      obj.transfer = Transfer.toJSON(message.transfer);
+    }
     return obj;
   },
   create(base) {
@@ -12046,6 +12308,7 @@ var QueryUserSignedRefundsResponse = {
   fromPartial(object) {
     const message = createBaseQueryUserSignedRefundsResponse();
     message.userSignedRefunds = object.userSignedRefunds?.map((e) => UserSignedRefund.fromPartial(e)) || [];
+    message.transfer = object.transfer !== void 0 && object.transfer !== null ? Transfer.fromPartial(object.transfer) : void 0;
     return message;
   }
 };
@@ -12932,7 +13195,8 @@ function createBaseDepositAddressQueryResult() {
     depositAddress: "",
     userSigningPublicKey: new Uint8Array(0),
     verifyingPublicKey: new Uint8Array(0),
-    leafId: void 0
+    leafId: void 0,
+    proofOfPossession: void 0
   };
 }
 var DepositAddressQueryResult = {
@@ -12949,6 +13213,9 @@ var DepositAddressQueryResult = {
     if (message.leafId !== void 0) {
       writer.uint32(34).string(message.leafId);
     }
+    if (message.proofOfPossession !== void 0) {
+      DepositAddressProof.encode(message.proofOfPossession, writer.uint32(42).fork()).join();
+    }
     return writer;
   },
   decode(input, length) {
@@ -12986,6 +13253,13 @@ var DepositAddressQueryResult = {
           message.leafId = reader.string();
           continue;
         }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.proofOfPossession = DepositAddressProof.decode(reader, reader.uint32());
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -12999,7 +13273,8 @@ var DepositAddressQueryResult = {
       depositAddress: isSet3(object.depositAddress) ? globalThis.String(object.depositAddress) : "",
       userSigningPublicKey: isSet3(object.userSigningPublicKey) ? bytesFromBase642(object.userSigningPublicKey) : new Uint8Array(0),
       verifyingPublicKey: isSet3(object.verifyingPublicKey) ? bytesFromBase642(object.verifyingPublicKey) : new Uint8Array(0),
-      leafId: isSet3(object.leafId) ? globalThis.String(object.leafId) : void 0
+      leafId: isSet3(object.leafId) ? globalThis.String(object.leafId) : void 0,
+      proofOfPossession: isSet3(object.proofOfPossession) ? DepositAddressProof.fromJSON(object.proofOfPossession) : void 0
     };
   },
   toJSON(message) {
@@ -13016,6 +13291,9 @@ var DepositAddressQueryResult = {
     if (message.leafId !== void 0) {
       obj.leafId = message.leafId;
     }
+    if (message.proofOfPossession !== void 0) {
+      obj.proofOfPossession = DepositAddressProof.toJSON(message.proofOfPossession);
+    }
     return obj;
   },
   create(base) {
@@ -13027,6 +13305,7 @@ var DepositAddressQueryResult = {
     message.userSigningPublicKey = object.userSigningPublicKey ?? new Uint8Array(0);
     message.verifyingPublicKey = object.verifyingPublicKey ?? new Uint8Array(0);
     message.leafId = object.leafId ?? void 0;
+    message.proofOfPossession = object.proofOfPossession !== void 0 && object.proofOfPossession !== null ? DepositAddressProof.fromPartial(object.proofOfPossession) : void 0;
     return message;
   }
 };
@@ -14991,7 +15270,7 @@ var QueryNodesByValueResponse_NodesEntry = {
   }
 };
 function createBaseGetUtxosForAddressRequest() {
-  return { address: "", offset: 0, limit: 0, network: 0 };
+  return { address: "", offset: 0, limit: 0, network: 0, excludeClaimed: false };
 }
 var GetUtxosForAddressRequest = {
   encode(message, writer = new import_wire4.BinaryWriter()) {
@@ -15007,6 +15286,9 @@ var GetUtxosForAddressRequest = {
     if (message.network !== 0) {
       writer.uint32(32).int32(message.network);
     }
+    if (message.excludeClaimed !== false) {
+      writer.uint32(40).bool(message.excludeClaimed);
+    }
     return writer;
   },
   decode(input, length) {
@@ -15044,6 +15326,13 @@ var GetUtxosForAddressRequest = {
           message.network = reader.int32();
           continue;
         }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.excludeClaimed = reader.bool();
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -15057,7 +15346,8 @@ var GetUtxosForAddressRequest = {
       address: isSet3(object.address) ? globalThis.String(object.address) : "",
       offset: isSet3(object.offset) ? globalThis.Number(object.offset) : 0,
       limit: isSet3(object.limit) ? globalThis.Number(object.limit) : 0,
-      network: isSet3(object.network) ? networkFromJSON(object.network) : 0
+      network: isSet3(object.network) ? networkFromJSON(object.network) : 0,
+      excludeClaimed: isSet3(object.excludeClaimed) ? globalThis.Boolean(object.excludeClaimed) : false
     };
   },
   toJSON(message) {
@@ -15074,6 +15364,9 @@ var GetUtxosForAddressRequest = {
     if (message.network !== 0) {
       obj.network = networkToJSON(message.network);
     }
+    if (message.excludeClaimed !== false) {
+      obj.excludeClaimed = message.excludeClaimed;
+    }
     return obj;
   },
   create(base) {
@@ -15085,6 +15378,7 @@ var GetUtxosForAddressRequest = {
     message.offset = object.offset ?? 0;
     message.limit = object.limit ?? 0;
     message.network = object.network ?? 0;
+    message.excludeClaimed = object.excludeClaimed ?? false;
     return message;
   }
 };
@@ -15156,6 +15450,225 @@ var GetUtxosForAddressResponse = {
     return message;
   }
 };
+function createBaseQuerySparkInvoicesRequest() {
+  return { limit: 0, offset: 0, invoice: [] };
+}
+var QuerySparkInvoicesRequest = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.limit !== 0) {
+      writer.uint32(8).int64(message.limit);
+    }
+    if (message.offset !== 0) {
+      writer.uint32(16).int64(message.offset);
+    }
+    for (const v of message.invoice) {
+      writer.uint32(26).string(v);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseQuerySparkInvoicesRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.limit = longToNumber2(reader.int64());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.offset = longToNumber2(reader.int64());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.invoice.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      limit: isSet3(object.limit) ? globalThis.Number(object.limit) : 0,
+      offset: isSet3(object.offset) ? globalThis.Number(object.offset) : 0,
+      invoice: globalThis.Array.isArray(object?.invoice) ? object.invoice.map((e) => globalThis.String(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.limit !== 0) {
+      obj.limit = Math.round(message.limit);
+    }
+    if (message.offset !== 0) {
+      obj.offset = Math.round(message.offset);
+    }
+    if (message.invoice?.length) {
+      obj.invoice = message.invoice;
+    }
+    return obj;
+  },
+  create(base) {
+    return QuerySparkInvoicesRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseQuerySparkInvoicesRequest();
+    message.limit = object.limit ?? 0;
+    message.offset = object.offset ?? 0;
+    message.invoice = object.invoice?.map((e) => e) || [];
+    return message;
+  }
+};
+function createBaseQuerySparkInvoicesResponse() {
+  return { offset: 0, invoiceStatuses: [] };
+}
+var QuerySparkInvoicesResponse = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.offset !== 0) {
+      writer.uint32(8).int64(message.offset);
+    }
+    for (const v of message.invoiceStatuses) {
+      InvoiceResponse.encode(v, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseQuerySparkInvoicesResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.offset = longToNumber2(reader.int64());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.invoiceStatuses.push(InvoiceResponse.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      offset: isSet3(object.offset) ? globalThis.Number(object.offset) : 0,
+      invoiceStatuses: globalThis.Array.isArray(object?.invoiceStatuses) ? object.invoiceStatuses.map((e) => InvoiceResponse.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.offset !== 0) {
+      obj.offset = Math.round(message.offset);
+    }
+    if (message.invoiceStatuses?.length) {
+      obj.invoiceStatuses = message.invoiceStatuses.map((e) => InvoiceResponse.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return QuerySparkInvoicesResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseQuerySparkInvoicesResponse();
+    message.offset = object.offset ?? 0;
+    message.invoiceStatuses = object.invoiceStatuses?.map((e) => InvoiceResponse.fromPartial(e)) || [];
+    return message;
+  }
+};
+function createBaseInvoiceResponse() {
+  return { invoice: "", status: 0 };
+}
+var InvoiceResponse = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.invoice !== "") {
+      writer.uint32(10).string(message.invoice);
+    }
+    if (message.status !== 0) {
+      writer.uint32(16).int32(message.status);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseInvoiceResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.invoice = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.status = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      invoice: isSet3(object.invoice) ? globalThis.String(object.invoice) : "",
+      status: isSet3(object.status) ? invoiceStatusFromJSON(object.status) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.invoice !== "") {
+      obj.invoice = message.invoice;
+    }
+    if (message.status !== 0) {
+      obj.status = invoiceStatusToJSON(message.status);
+    }
+    return obj;
+  },
+  create(base) {
+    return InvoiceResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseInvoiceResponse();
+    message.invoice = object.invoice ?? "";
+    message.status = object.status ?? 0;
+    return message;
+  }
+};
 var SparkServiceDefinition = {
   name: "SparkService",
   fullName: "spark.SparkService",
@@ -15168,6 +15681,15 @@ var SparkServiceDefinition = {
       responseStream: false,
       options: {}
     },
+    /** Generates a new static deposit address of the user or returns the existing one for the specified network. */
+    generate_static_deposit_address: {
+      name: "generate_static_deposit_address",
+      requestType: GenerateStaticDepositAddressRequest,
+      requestStream: false,
+      responseType: GenerateStaticDepositAddressResponse,
+      responseStream: false,
+      options: {}
+    },
     start_deposit_tree_creation: {
       name: "start_deposit_tree_creation",
       requestType: StartDepositTreeCreationRequest,
@@ -15609,6 +16131,14 @@ var SparkServiceDefinition = {
       responseType: GetUtxosForAddressResponse,
       responseStream: false,
       options: {}
+    },
+    query_spark_invoices: {
+      name: "query_spark_invoices",
+      requestType: QuerySparkInvoicesRequest,
+      requestStream: false,
+      responseType: QuerySparkInvoicesResponse,
+      responseStream: false,
+      options: {}
     }
   }
 };
@@ -15839,9 +16369,6 @@ function uint64be(value) {
 }
 
 // src/utils/address.ts
-var import_uuidv7 = require("uuidv7");
-var import_utils3 = require("@noble/curves/abstract/utils");
-var import_wire5 = require("@bufbuild/protobuf/wire");
 var BECH32M_LIMIT = 1024;
 var AddressNetwork = {
   MAINNET: "sp",
@@ -15856,7 +16383,7 @@ function encodeSparkAddress(payload) {
 function encodeSparkAddressWithSignature(payload, signature) {
   try {
     isValidPublicKey(payload.identityPublicKey);
-    const identityPublicKey = (0, import_utils2.hexToBytes)(payload.identityPublicKey);
+    const identityPublicKey = (0, import_utils3.hexToBytes)(payload.identityPublicKey);
     let sparkInvoiceFields;
     if (payload.sparkInvoiceFields) {
       validateSparkInvoiceFields(payload.sparkInvoiceFields);
@@ -15900,8 +16427,8 @@ function decodeSparkAddress(address2, network) {
     }
     const payload = SparkAddress.decode(import_base2.bech32m.fromWords(decoded.words));
     const { identityPublicKey, sparkInvoiceFields, signature } = payload;
-    const identityPubkeyHex = (0, import_utils2.bytesToHex)(identityPublicKey);
-    const signatureHex = signature ? (0, import_utils2.bytesToHex)(signature) : void 0;
+    const identityPubkeyHex = (0, import_utils3.bytesToHex)(identityPublicKey);
+    const signatureHex = signature ? (0, import_utils3.bytesToHex)(signature) : void 0;
     isValidPublicKey(identityPubkeyHex);
     return {
       identityPublicKey: identityPubkeyHex,
@@ -15911,10 +16438,10 @@ function decodeSparkAddress(address2, network) {
         id: import_uuidv7.UUID.ofInner(sparkInvoiceFields.id).toString(),
         paymentType: sparkInvoiceFields.paymentType ? sparkInvoiceFields.paymentType.$case === "tokensPayment" ? {
           type: "tokens",
-          tokenIdentifier: sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier ? (0, import_utils2.bytesToHex)(
+          tokenIdentifier: sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier ? (0, import_utils3.bytesToHex)(
             sparkInvoiceFields.paymentType.tokensPayment.tokenIdentifier
           ) : void 0,
-          amount: sparkInvoiceFields.paymentType.tokensPayment.amount ? (0, import_utils3.bytesToNumberBE)(
+          amount: sparkInvoiceFields.paymentType.tokensPayment.amount ? (0, import_utils2.bytesToNumberBE)(
             sparkInvoiceFields.paymentType.tokensPayment.amount
           ) : void 0
         } : sparkInvoiceFields.paymentType.$case === "satsPayment" ? {
@@ -15922,7 +16449,7 @@ function decodeSparkAddress(address2, network) {
           amount: sparkInvoiceFields.paymentType.satsPayment.amount
         } : void 0 : void 0,
         memo: sparkInvoiceFields.memo,
-        senderPublicKey: sparkInvoiceFields.senderPublicKey ? (0, import_utils2.bytesToHex)(sparkInvoiceFields.senderPublicKey) : void 0,
+        senderPublicKey: sparkInvoiceFields.senderPublicKey ? (0, import_utils3.bytesToHex)(sparkInvoiceFields.senderPublicKey) : void 0,
         expiryTime: sparkInvoiceFields.expiryTime
       },
       signature: signatureHex
@@ -15971,7 +16498,7 @@ function isValidSparkAddress(address2) {
 }
 function isValidPublicKey(publicKey) {
   try {
-    const point = import_secp256k1.secp256k1.ProjectivePoint.fromHex(publicKey);
+    const point = import_secp256k1.secp256k1.Point.fromHex(publicKey);
     point.assertValidity();
   } catch (error) {
     throw new ValidationError(
@@ -16006,7 +16533,7 @@ function validateSparkInvoiceFields(sparkInvoiceFields) {
   }
   if (senderPublicKey) {
     try {
-      isValidPublicKey((0, import_utils2.bytesToHex)(senderPublicKey));
+      isValidPublicKey((0, import_utils3.bytesToHex)(senderPublicKey));
     } catch (error) {
       throw new ValidationError(
         "Invalid sender public key",
@@ -16057,7 +16584,7 @@ function validateSparkInvoiceFields(sparkInvoiceFields) {
             value: tokensAmount
           });
         }
-        const tokensAmountBigInt = (0, import_utils3.bytesToNumberBE)(tokensAmount);
+        const tokensAmountBigInt = (0, import_utils2.bytesToNumberBE)(tokensAmount);
         if (tokensAmountBigInt < 0 || tokensAmountBigInt > MAX_UINT128) {
           throw new ValidationError(
             "Asset amount must be between 0 and MAX_UINT128",
@@ -16201,8 +16728,8 @@ function encodeSparkInvoiceFieldsV1Canonical(f) {
 // src/utils/adaptor-signature.ts
 init_buffer();
 var import_modular = require("@noble/curves/abstract/modular");
-var import_utils4 = require("@noble/curves/abstract/utils");
 var import_secp256k12 = require("@noble/curves/secp256k1");
+var import_utils4 = require("@noble/curves/utils");
 function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
   const { r, s } = parseSignature(signature);
   const sBigInt = (0, import_utils4.bytesToNumberBE)(s);
@@ -16269,7 +16796,7 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   const commitmenet = import_secp256k12.schnorr.utils.taggedHash(
     "BIP0340/challenge",
     r,
-    pubKey.toRawBytes().slice(1),
+    pubKey.toBytes().slice(1),
     hash
   );
   if (commitmenet.length > 32) {
@@ -16277,22 +16804,20 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   }
   const e = (0, import_modular.mod)((0, import_utils4.bytesToNumberBE)(commitmenet), import_secp256k12.secp256k1.CURVE.n);
   const negE = (0, import_modular.mod)(-e, import_secp256k12.secp256k1.CURVE.n);
-  const R = import_secp256k12.secp256k1.ProjectivePoint.BASE.multiplyAndAddUnsafe(
-    pubKey,
-    (0, import_utils4.bytesToNumberBE)(s),
-    negE
-  );
-  if (!R) {
-    throw new Error("R is undefined");
+  const sG = import_secp256k12.secp256k1.Point.BASE.multiplyUnsafe((0, import_utils4.bytesToNumberBE)(s));
+  const eP = pubKey.multiplyUnsafe(negE);
+  const R = sG.add(eP);
+  if (R.is0()) {
+    throw new Error("R is zero");
   }
   R.assertValidity();
-  const adaptorPoint = import_secp256k12.secp256k1.ProjectivePoint.fromHex(adaptorPubkey);
+  const adaptorPoint = import_secp256k12.secp256k1.Point.fromHex(adaptorPubkey);
   const newR = R.add(adaptorPoint);
-  if (!inbound && newR.equals(import_secp256k12.secp256k1.ProjectivePoint.ZERO)) {
+  if (!inbound && newR.equals(import_secp256k12.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_utils4.bytesToNumberBE)(r);
@@ -16333,8 +16858,8 @@ function parseSignature(signature) {
 
 // src/utils/bitcoin.ts
 init_buffer();
-var import_utils5 = require("@noble/curves/abstract/utils");
 var import_secp256k13 = require("@noble/curves/secp256k1");
+var import_utils5 = require("@noble/curves/utils");
 var import_sha22 = require("@noble/hashes/sha2");
 var btc2 = __toESM(require("@scure/btc-signer"), 1);
 
@@ -16442,8 +16967,8 @@ function computeTaprootKeyNoScript(pubkey) {
   const taggedHash = import_secp256k13.schnorr.utils.taggedHash("TapTweak", pubkey);
   const tweak = (0, import_utils5.bytesToNumberBE)(taggedHash);
   const P = import_secp256k13.schnorr.utils.lift_x(import_secp256k13.schnorr.utils.bytesToNumberBE(pubkey));
-  const Q = P.add(import_secp256k13.secp256k1.ProjectivePoint.fromPrivateKey(tweak));
-  return Q.toRawBytes();
+  const Q = P.add(import_secp256k13.secp256k1.Point.fromPrivateKey(tweak));
+  return Q.toBytes();
 }
 function getP2TRScriptFromPublicKey(pubKey, network) {
   if (pubKey.length !== 33) {
@@ -16453,9 +16978,9 @@ function getP2TRScriptFromPublicKey(pubKey, network) {
       expected: 33
     });
   }
-  const internalKey = import_secp256k13.secp256k1.ProjectivePoint.fromHex(pubKey);
+  const internalKey = import_secp256k13.secp256k1.Point.fromHex(pubKey);
   const script = btc2.p2tr(
-    internalKey.toRawBytes().slice(1, 33),
+    internalKey.toBytes().slice(1, 33),
     void 0,
     getNetwork(network)
   ).script;
@@ -16475,9 +17000,9 @@ function getP2TRAddressFromPublicKey(pubKey, network) {
       expected: 33
     });
   }
-  const internalKey = import_secp256k13.secp256k1.ProjectivePoint.fromHex(pubKey);
+  const internalKey = import_secp256k13.secp256k1.Point.fromHex(pubKey);
   const address2 = btc2.p2tr(
-    internalKey.toRawBytes().slice(1, 33),
+    internalKey.toBytes().slice(1, 33),
     void 0,
     getNetwork(network)
   ).address;
@@ -16579,8 +17104,8 @@ function getTxEstimatedVbytesSizeByNumberOfInputsOutputs(numInputs, numOutputs)
 
 // src/utils/keys.ts
 init_buffer();
-var import_utils6 = require("@noble/curves/abstract/utils");
 var import_secp256k14 = require("@noble/curves/secp256k1");
+var import_utils6 = require("@noble/curves/utils");
 function addPublicKeys(a, b) {
   if (a.length !== 33 || b.length !== 33) {
     throw new ValidationError("Public keys must be 33 bytes", {
@@ -16589,9 +17114,9 @@ function addPublicKeys(a, b) {
       expected: 33
     });
   }
-  const pubkeyA = import_secp256k14.secp256k1.ProjectivePoint.fromHex(a);
-  const pubkeyB = import_secp256k14.secp256k1.ProjectivePoint.fromHex(b);
-  return pubkeyA.add(pubkeyB).toRawBytes(true);
+  const pubkeyA = import_secp256k14.secp256k1.Point.fromHex(a);
+  const pubkeyB = import_secp256k14.secp256k1.Point.fromHex(b);
+  return pubkeyA.add(pubkeyB).toBytes(true);
 }
 function applyAdditiveTweakToPublicKey(pubkey, tweak) {
   if (pubkey.length !== 33) {
@@ -16608,11 +17133,11 @@ function applyAdditiveTweakToPublicKey(pubkey, tweak) {
       expected: 32
     });
   }
-  const pubkeyPoint = import_secp256k14.secp256k1.ProjectivePoint.fromHex(pubkey);
+  const pubkeyPoint = import_secp256k14.secp256k1.Point.fromHex(pubkey);
   const privTweek = import_secp256k14.secp256k1.utils.normPrivateKeyToScalar(tweak);
   const pubTweek = import_secp256k14.secp256k1.getPublicKey(privTweek, true);
-  const tweekPoint = import_secp256k14.secp256k1.ProjectivePoint.fromHex(pubTweek);
-  return pubkeyPoint.add(tweekPoint).toRawBytes(true);
+  const tweekPoint = import_secp256k14.secp256k1.Point.fromHex(pubTweek);
+  return pubkeyPoint.add(tweekPoint).toBytes(true);
 }
 function subtractPublicKeys(a, b) {
   if (a.length !== 33 || b.length !== 33) {
@@ -16622,9 +17147,9 @@ function subtractPublicKeys(a, b) {
       expected: 33
     });
   }
-  const pubkeyA = import_secp256k14.secp256k1.ProjectivePoint.fromHex(a);
-  const pubkeyB = import_secp256k14.secp256k1.ProjectivePoint.fromHex(b);
-  return pubkeyA.subtract(pubkeyB).toRawBytes(true);
+  const pubkeyA = import_secp256k14.secp256k1.Point.fromHex(a);
+  const pubkeyB = import_secp256k14.secp256k1.Point.fromHex(b);
+  return pubkeyA.subtract(pubkeyB).toBytes(true);
 }
 function addPrivateKeys(a, b) {
   if (a.length !== 32 || b.length !== 32) {
@@ -17837,7 +18362,7 @@ fragment UserRequestFragment on UserRequest {
 
 // src/types/sdk-types.ts
 init_buffer();
-var import_utils7 = require("@noble/curves/abstract/utils");
+var import_utils7 = require("@noble/curves/utils");
 function mapTreeNodeToWalletLeaf(proto) {
   return {
     id: proto.id,
@@ -17988,8 +18513,8 @@ function collectResponses(responses) {
 
 // src/utils/secret-sharing.ts
 init_buffer();
-var import_utils8 = require("@noble/curves/abstract/utils");
 var import_secp256k15 = require("@noble/curves/secp256k1");
+var import_utils8 = require("@noble/curves/utils");
 function getRandomBigInt(max) {
   const byteLength = max.toString(2).length + 7 >> 3;
   const maxBigInt = max;
@@ -18075,11 +18600,11 @@ function generatePolynomialForSecretSharing(fieldModulus, secret, degree) {
   const coefficients = new Array(degree);
   const proofs = new Array(degree);
   coefficients[0] = secret;
-  proofs[0] = import_secp256k15.secp256k1.ProjectivePoint.fromPrivateKey(secret).toRawBytes(true);
+  proofs[0] = import_secp256k15.secp256k1.Point.fromPrivateKey(secret).toBytes(true);
   for (let i = 1; i < degree; i++) {
     const coefficient = getRandomBigInt(fieldModulus);
     coefficients[i] = coefficient;
-    proofs[i] = import_secp256k15.secp256k1.ProjectivePoint.fromPrivateKey(coefficient).toRawBytes(true);
+    proofs[i] = import_secp256k15.secp256k1.Point.fromPrivateKey(coefficient).toBytes(true);
   }
   return {
     fieldModulus,
@@ -18151,9 +18676,9 @@ function recoverSecret(shares) {
   return result;
 }
 function validateShare(share) {
-  const targetPubkey = import_secp256k15.secp256k1.ProjectivePoint.fromPrivateKey(
-    share.share
-  ).toRawBytes(true);
+  const targetPubkey = import_secp256k15.secp256k1.Point.fromPrivateKey(share.share).toBytes(
+    true
+  );
   let resultPubkey = share.proofs[0];
   if (!resultPubkey) {
     throw new ValidationError("Result pubkey is not valid", {
@@ -18172,8 +18697,8 @@ function validateShare(share) {
       });
     }
     const value = share.index ** BigInt(i) % share.fieldModulus;
-    const scaledPoint = import_secp256k15.secp256k1.ProjectivePoint.fromHex(pubkey).multiply(value);
-    resultPubkey = import_secp256k15.secp256k1.ProjectivePoint.fromHex(resultPubkey).add(scaledPoint).toRawBytes(true);
+    const scaledPoint = import_secp256k15.secp256k1.Point.fromHex(pubkey).multiply(value);
+    resultPubkey = import_secp256k15.secp256k1.Point.fromHex(resultPubkey).add(scaledPoint).toBytes(true);
   }
   if (!(0, import_utils8.equalBytes)(resultPubkey, targetPubkey)) {
     throw new ValidationError("Share is not valid", {
@@ -18374,8 +18899,7 @@ function getNetworkFromBech32mTokenIdentifier(bech32mTokenIdentifier) {
 
 // src/utils/token-transactions.ts
 init_buffer();
-var import_utils9 = require("@noble/curves/abstract/utils");
-var import_utils10 = require("@scure/btc-signer/utils");
+var import_utils9 = require("@noble/curves/utils");
 function sumAvailableTokens(outputs) {
   try {
     return outputs.reduce(
@@ -18410,7 +18934,7 @@ function filterTokenBalanceForTokenIdentifier(tokenBalances, tokenIdentifier) {
   }
   const tokenIdentifierBytes = decodeBech32mTokenIdentifier(tokenIdentifier).tokenIdentifier;
   const tokenBalance = [...tokenBalances.entries()].find(
-    ([, info]) => (0, import_utils10.equalBytes)(info.tokenMetadata.rawTokenIdentifier, tokenIdentifierBytes)
+    ([, info]) => (0, import_utils9.equalBytes)(info.tokenMetadata.rawTokenIdentifier, tokenIdentifierBytes)
   );
   if (!tokenBalance) {
     return {
@@ -18424,7 +18948,7 @@ function filterTokenBalanceForTokenIdentifier(tokenBalances, tokenIdentifier) {
 
 // src/utils/transfer_package.ts
 init_buffer();
-var import_utils11 = require("@noble/curves/abstract/utils");
+var import_utils10 = require("@noble/curves/utils");
 var import_sha24 = require("@noble/hashes/sha2");
 function getTransferPackageSigningPayload(transferID, transferPackage) {
   const encryptedPayload = transferPackage.keyTweakPackage;
@@ -18433,7 +18957,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_utils11.hexToBytes)(transferID.replaceAll("-", ""));
+  let message = (0, import_utils10.hexToBytes)(transferID.replaceAll("-", ""));
   for (const pair of pairs) {
     const keyPart = encoder.encode(pair.key + ":");
     const separator = encoder.encode(";");
@@ -18786,7 +19310,7 @@ function getEphemeralAnchorOutput() {
 
 // src/utils/unilateral-exit.ts
 init_buffer();
-var import_utils12 = require("@noble/curves/abstract/utils");
+var import_utils11 = require("@noble/curves/utils");
 var import_legacy = require("@noble/hashes/legacy");
 var import_sha25 = require("@noble/hashes/sha2");
 var btc3 = __toESM(require("@scure/btc-signer"), 1);
@@ -18801,7 +19325,7 @@ function isEphemeralAnchorOutput(script, amount) {
 }
 async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network) {
   const result = [];
-  const nodes = nodeHexStrings.map((hex) => TreeNode.decode((0, import_utils12.hexToBytes)(hex)));
+  const nodes = nodeHexStrings.map((hex) => TreeNode.decode((0, import_utils11.hexToBytes)(hex)));
   const nodeMap = /* @__PURE__ */ new Map();
   for (const node of nodes) {
     nodeMap.set(node.id, node);
@@ -18857,10 +19381,10 @@ async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network)
       }
     }
     for (const chainNode of chain) {
-      const nodeTx = (0, import_utils12.bytesToHex)(chainNode.nodeTx);
+      const nodeTx = (0, import_utils11.bytesToHex)(chainNode.nodeTx);
       transactions.push(nodeTx);
       if (chainNode.id === node.id) {
-        const refundTx = (0, import_utils12.bytesToHex)(chainNode.refundTx);
+        const refundTx = (0, import_utils11.bytesToHex)(chainNode.refundTx);
         transactions.push(refundTx);
       }
     }
@@ -18890,7 +19414,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_utils12.hexToBytes)(hex);
+      const nodeBytes = (0, import_utils11.hexToBytes)(hex);
       const node = TreeNode.decode(nodeBytes);
       if (!node.id) {
         throw new Error(
@@ -18966,7 +19490,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
       }
     }
     for (const chainNode of chain) {
-      let nodeTxHex = (0, import_utils12.bytesToHex)(chainNode.nodeTx);
+      let nodeTxHex = (0, import_utils11.bytesToHex)(chainNode.nodeTx);
       try {
         const txObj = getTxFromRawTxHex(nodeTxHex);
         const txid = getTxId(txObj);
@@ -18983,7 +19507,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_utils12.bytesToHex)(output.script);
+            anchorOutputScriptHex = (0, import_utils11.bytesToHex)(output.script);
             break;
           }
         }
@@ -19004,11 +19528,11 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
         usedUtxos,
         correctedParentTx
       } = constructFeeBumpTx(nodeTxHex, availableUtxos, feeRate, void 0);
-      const feeBumpTx = btc3.Transaction.fromPSBT((0, import_utils12.hexToBytes)(nodeFeeBumpPsbt));
+      const feeBumpTx = btc3.Transaction.fromPSBT((0, import_utils11.hexToBytes)(nodeFeeBumpPsbt));
       var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
       var feeBumpOutPubKey = null;
       for (const usedUtxo of usedUtxos) {
-        if (feeBumpOut && (0, import_utils12.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
+        if (feeBumpOut && (0, import_utils11.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
           feeBumpOutPubKey = usedUtxo.publicKey;
         }
         const index = availableUtxos.findIndex(
@@ -19023,20 +19547,20 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           txid: getTxId(feeBumpTx),
           vout: 0,
           value: feeBumpOut.amount,
-          script: (0, import_utils12.bytesToHex)(feeBumpOut.script),
+          script: (0, import_utils11.bytesToHex)(feeBumpOut.script),
           publicKey: feeBumpOutPubKey
         });
       const finalNodeTx = correctedParentTx || nodeTxHex;
       txPackages.push({ tx: finalNodeTx, feeBumpPsbt: nodeFeeBumpPsbt });
       if (chainNode.id === node.id) {
-        let refundTxHex = (0, import_utils12.bytesToHex)(chainNode.refundTx);
+        let refundTxHex = (0, import_utils11.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_utils12.bytesToHex)(output.script);
+              anchorOutputScriptHex = (0, import_utils11.bytesToHex)(output.script);
               break;
             }
           }
@@ -19059,12 +19583,12 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           void 0
         );
         const feeBumpTx2 = btc3.Transaction.fromPSBT(
-          (0, import_utils12.hexToBytes)(refundFeeBump.feeBumpPsbt)
+          (0, import_utils11.hexToBytes)(refundFeeBump.feeBumpPsbt)
         );
         var feeBumpOut = feeBumpTx2.outputsLength === 1 ? feeBumpTx2.getOutput(0) : null;
         var feeBumpOutPubKey = null;
         for (const usedUtxo of usedUtxos) {
-          if (feeBumpOut && (0, import_utils12.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
+          if (feeBumpOut && (0, import_utils11.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
             feeBumpOutPubKey = usedUtxo.publicKey;
           }
           const index = availableUtxos.findIndex(
@@ -19079,7 +19603,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
             txid: getTxId(feeBumpTx2),
             vout: 0,
             value: feeBumpOut.amount,
-            script: (0, import_utils12.bytesToHex)(feeBumpOut.script),
+            script: (0, import_utils11.bytesToHex)(feeBumpOut.script),
             publicKey: feeBumpOutPubKey
           });
         txPackages.push({
@@ -19174,10 +19698,10 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
     if (!fundingUtxo) {
       throw new Error(`UTXO at index ${i} is undefined`);
     }
-    const pubKeyHash = hash160((0, import_utils12.hexToBytes)(fundingUtxo.publicKey));
+    const pubKeyHash = hash160((0, import_utils11.hexToBytes)(fundingUtxo.publicKey));
     const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
-    const providedScript = (0, import_utils12.hexToBytes)(fundingUtxo.script);
-    if ((0, import_utils12.bytesToHex)(scriptToUse) !== (0, import_utils12.bytesToHex)(providedScript)) {
+    const providedScript = (0, import_utils11.hexToBytes)(fundingUtxo.script);
+    if ((0, import_utils11.bytesToHex)(scriptToUse) !== (0, import_utils11.bytesToHex)(providedScript)) {
       throw new Error(
         `\u274C  Derived script doesn't match provided script for UTXO ${i + 1}.`
       );
@@ -19242,7 +19766,7 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
   }
   let psbtHex;
   try {
-    psbtHex = (0, import_utils12.bytesToHex)(builder.toPSBT());
+    psbtHex = (0, import_utils11.bytesToHex)(builder.toPSBT());
   } catch (error) {
     throw new Error(`Failed to extract transaction: ${error}`);
   }
@@ -19284,11 +19808,14 @@ function getSparkAddressFromTaproot(taprootAddress) {
   throw new ValidationError("Invalid taproot address");
 }
 
+// src/utils/index.ts
+init_logging();
+
 // src/signer/signer.ts
 init_buffer();
 var import_secp256k17 = require("@bitcoinerlab/secp256k1");
-var import_utils13 = require("@noble/curves/abstract/utils");
 var import_secp256k18 = require("@noble/curves/secp256k1");
+var import_utils13 = require("@noble/curves/utils");
 var import_sha26 = require("@noble/hashes/sha2");
 var import_bip32 = require("@scure/bip32");
 var import_bip39 = require("@scure/bip39");
@@ -19298,19 +19825,19 @@ var ecies = __toESM(require("eciesjs"), 1);
 
 // src/constants.ts
 init_buffer();
-var import_core8 = require("@lightsparkdev/core");
+var import_core9 = 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.12" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
   baseEnvStr = `bun/${bunVersion}`;
-} else if (import_core8.isNode) {
+} else if (import_core9.isNode) {
   baseEnvStr = `node/${process.version}`;
 } else if (isReactNative) {
   baseEnvStr = "react-native";
-} else if (import_core8.isBare) {
+} else if (import_core9.isBare) {
   const bareVersion = Bare.version;
   baseEnvStr = `bare/${bareVersion}`;
 } else {
@@ -19831,9 +20358,9 @@ init_buffer();
 
 // src/spark-wallet/spark-wallet.ts
 init_buffer();
-var import_core12 = require("@lightsparkdev/core");
-var import_utils24 = require("@noble/curves/abstract/utils");
+var import_core13 = require("@lightsparkdev/core");
 var import_secp256k115 = require("@noble/curves/secp256k1");
+var import_utils24 = require("@noble/curves/utils");
 var import_bip392 = require("@scure/bip39");
 var import_english2 = require("@scure/bip39/wordlists/english");
 var import_btc_signer6 = require("@scure/btc-signer");
@@ -19842,7 +20369,7 @@ var import_uuidv75 = require("uuidv7");
 
 // src/graphql/client.ts
 init_buffer();
-var import_core10 = require("@lightsparkdev/core");
+var import_core11 = require("@lightsparkdev/core");
 var import_sha27 = require("@noble/hashes/sha2");
 
 // src/graphql/mutations/ClaimStaticDeposit.ts
@@ -19896,7 +20423,7 @@ init_buffer();
 
 // src/graphql/objects/CoopExitRequest.ts
 init_buffer();
-var import_core9 = require("@lightsparkdev/core");
+var import_core10 = require("@lightsparkdev/core");
 var CoopExitRequestFromJson = (obj) => {
   return {
     id: obj["coop_exit_request_id"],
@@ -20477,13 +21004,13 @@ var SspClient = class {
     this.authProvider = new SparkAuthProvider();
     const { fetch } = getFetch();
     const options = config.sspClientOptions;
-    this.requester = new import_core10.Requester(
-      new import_core10.NodeKeyCache(import_core10.DefaultCrypto),
+    this.requester = new import_core11.Requester(
+      new import_core11.NodeKeyCache(import_core11.DefaultCrypto),
       options.schemaEndpoint || `graphql/spark/2025-03-19`,
       `spark-sdk/0.0.0`,
       this.authProvider,
       options.baseUrl,
-      import_core10.DefaultCrypto,
+      import_core11.DefaultCrypto,
       void 0,
       fetch
     );
@@ -20858,7 +21385,7 @@ var SspClient = class {
       {
         queryPayload: GetChallenge,
         variables: {
-          public_key: (0, import_core10.bytesToHex)(await this.signer.getIdentityPublicKey())
+          public_key: (0, import_core11.bytesToHex)(await this.signer.getIdentityPublicKey())
         },
         constructObject: (response) => {
           return GetChallengeOutputFromJson(response.get_challenge);
@@ -20874,7 +21401,7 @@ var SspClient = class {
         variables: {
           protected_challenge: protectedChallenge,
           signature,
-          identity_public_key: (0, import_core10.bytesToHex)(
+          identity_public_key: (0, import_core11.bytesToHex)(
             await this.signer.getIdentityPublicKey()
           )
         },
@@ -20919,7 +21446,7 @@ var SspClient = class {
           );
           return;
         } catch (err) {
-          if ((0, import_core10.isError)(err) && err.message.toLowerCase().includes("challenge expired")) {
+          if ((0, import_core11.isError)(err) && err.message.toLowerCase().includes("challenge expired")) {
             lastErr = err;
             continue;
           }
@@ -21086,7 +21613,7 @@ var WalletConfigService = class {
 
 // src/services/connection.ts
 init_buffer();
-var import_core11 = require("@lightsparkdev/core");
+var import_core12 = require("@lightsparkdev/core");
 var import_sha28 = 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");
@@ -24844,7 +25371,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);
@@ -24861,7 +25388,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) {
@@ -24892,7 +25419,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) {
@@ -24998,7 +25525,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(
@@ -25049,7 +25576,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",
@@ -25071,14 +25598,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);
@@ -25149,7 +25676,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;
@@ -25199,8 +25726,8 @@ var import_uuidv73 = require("uuidv7");
 
 // src/services/transfer.ts
 init_buffer();
-var import_utils15 = require("@noble/curves/abstract/utils");
 var import_secp256k19 = require("@noble/curves/secp256k1");
+var import_utils15 = require("@noble/curves/utils");
 var import_sha29 = require("@noble/hashes/sha2");
 var import_btc_signer2 = require("@scure/btc-signer");
 var ecies2 = __toESM(require("eciesjs"), 1);
@@ -27104,7 +27631,8 @@ var DepositService = class {
   }
   async validateDepositAddress({
     address: address2,
-    userPubkey
+    userPubkey,
+    verifyCoordinatorProof = false
   }) {
     if (!address2.depositAddressProof || !address2.depositAddressProof.proofOfPossessionSignature || !address2.depositAddressProof.addressSignatures) {
       throw new ValidationError(
@@ -27142,7 +27670,7 @@ var DepositService = class {
     }
     const addrHash = (0, import_sha210.sha256)(address2.address);
     for (const operator of Object.values(this.config.getSigningOperators())) {
-      if (operator.identifier === this.config.getCoordinatorIdentifier()) {
+      if (operator.identifier === this.config.getCoordinatorIdentifier() && !verifyCoordinatorProof) {
         continue;
       }
       const operatorPubkey2 = (0, import_utils16.hexToBytes)(operator.identityPublicKey);
@@ -27154,7 +27682,11 @@ var DepositService = class {
         });
       }
       const sig = import_secp256k110.secp256k1.Signature.fromDER(operatorSig);
-      const isVerified2 = import_secp256k110.secp256k1.verify(sig, addrHash, operatorPubkey2);
+      const isVerified2 = import_secp256k110.secp256k1.verify(
+        sig.toCompactRawBytes(),
+        addrHash,
+        operatorPubkey2
+      );
       if (!isVerified2) {
         throw new ValidationError("Operator signature verification failed", {
           field: "operatorSignature",
@@ -27163,6 +27695,46 @@ var DepositService = class {
       }
     }
   }
+  async generateStaticDepositAddress({
+    signingPubkey
+  }) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let depositResp;
+    try {
+      depositResp = await sparkClient.generate_static_deposit_address({
+        signingPublicKey: signingPubkey,
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        network: this.config.getNetworkProto()
+      });
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to generate static deposit address",
+        {
+          operation: "generate_static_deposit_address",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
+    if (!depositResp.depositAddress) {
+      throw new ValidationError(
+        "No static deposit address response from coordinator",
+        {
+          field: "depositAddress",
+          value: depositResp
+        }
+      );
+    }
+    await this.validateDepositAddress({
+      address: depositResp.depositAddress,
+      userPubkey: signingPubkey,
+      verifyCoordinatorProof: true
+    });
+    return depositResp;
+  }
   async generateDepositAddress({
     signingPubkey,
     leafId,
@@ -27703,8 +28275,8 @@ var DepositService = class {
 
 // src/services/lightning.ts
 init_buffer();
-var import_utils18 = require("@noble/curves/abstract/utils");
 var import_secp256k111 = require("@noble/curves/secp256k1");
+var import_utils18 = require("@noble/curves/utils");
 var import_sha211 = require("@noble/hashes/sha2");
 var import_uuidv74 = require("uuidv7");
 
@@ -28052,8 +28624,8 @@ var LightningService = class {
 
 // src/services/token-transactions.ts
 init_buffer();
-var import_utils19 = require("@noble/curves/abstract/utils");
 var import_secp256k113 = require("@noble/curves/secp256k1");
+var import_utils19 = require("@noble/curves/utils");
 var import_utils20 = require("@noble/hashes/utils");
 
 // src/utils/token-hashing.ts
@@ -30972,7 +31544,7 @@ var import_nice_grpc_common3 = require("nice-grpc-common");
 
 // src/services/signing.ts
 init_buffer();
-var import_utils21 = require("@noble/curves/abstract/utils");
+var import_utils21 = require("@noble/curves/utils");
 var SigningService = class {
   config;
   constructor(config) {
@@ -31138,8 +31710,8 @@ var SigningService = class {
 
 // src/tests/utils/test-faucet.ts
 init_buffer();
-var import_utils22 = require("@noble/curves/abstract/utils");
 var import_secp256k114 = require("@noble/curves/secp256k1");
+var import_utils22 = require("@noble/curves/utils");
 var btc5 = __toESM(require("@scure/btc-signer"), 1);
 var import_btc_signer5 = require("@scure/btc-signer");
 var import_utils23 = require("@scure/btc-signer/utils");
@@ -31685,7 +32257,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();
@@ -32707,7 +33279,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    * @returns {Promise<string>} A Bitcoin address for depositing funds
    */
   async getSingleUseDepositAddress() {
-    return await this.generateDepositAddress(false);
+    return await this.generateDepositAddress();
   }
   /**
    * Generates a new static deposit address for receiving bitcoin funds.
@@ -32716,43 +33288,32 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    * @returns {Promise<string>} A Bitcoin address for depositing funds
    */
   async getStaticDepositAddress() {
-    try {
-      return await this.generateDepositAddress(true);
-    } catch (error) {
-      if (error.message?.includes("static deposit address already exists")) {
-        const existingAddresses = await this.queryStaticDepositAddresses();
-        if (existingAddresses.length > 0 && existingAddresses[0]) {
-          return existingAddresses[0];
-        } else {
-          throw error;
-        }
-      } else {
-        throw error;
-      }
+    const signingPubkey = await this.config.signer.getStaticDepositSigningKey(0);
+    const address2 = await this.depositService.generateStaticDepositAddress({
+      signingPubkey
+    });
+    if (!address2.depositAddress) {
+      throw new RPCError("Failed to generate static deposit address", {
+        method: "generateStaticDepositAddress",
+        params: { signingPubkey }
+      });
     }
+    return address2.depositAddress.address;
   }
   /**
    * Generates a deposit address for receiving funds.
-   *
-   * @param {boolean} static - Whether the address is static or single use
    * @returns {Promise<string>} A deposit address
    * @private
    */
-  async generateDepositAddress(isStatic) {
+  async generateDepositAddress() {
     const leafId = (0, import_uuidv75.uuidv7)();
-    let signingPubkey;
-    if (isStatic) {
-      signingPubkey = await this.config.signer.getStaticDepositSigningKey(0);
-    } else {
-      signingPubkey = await this.config.signer.getPublicKeyFromDerivation({
-        type: "leaf" /* LEAF */,
-        path: leafId
-      });
-    }
+    const signingPubkey = await this.config.signer.getPublicKeyFromDerivation({
+      type: "leaf" /* LEAF */,
+      path: leafId
+    });
     const address2 = await this.depositService.generateDepositAddress({
       signingPubkey,
-      leafId,
-      isStatic
+      leafId
     });
     if (!address2.depositAddress) {
       throw new RPCError("Failed to generate deposit address", {
@@ -32779,7 +33340,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    * @param offset - Pagination offset (default 0).
    * @returns {Promise<{ txid: string, vout: number }[]>} List of confirmed UTXOs.
    */
-  async getUtxosForDepositAddress(depositAddress, limit = 100, offset = 0) {
+  async getUtxosForDepositAddress(depositAddress, limit = 100, offset = 0, excludeClaimed = false) {
     if (!depositAddress) {
       throw new ValidationError("Deposit address cannot be empty", {
         field: "depositAddress"
@@ -32793,7 +33354,8 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         address: depositAddress,
         network: NetworkToProto[this.config.getNetwork()],
         limit,
-        offset
+        offset,
+        excludeClaimed
       });
       return response.utxos.map((utxo) => ({
         txid: (0, import_utils24.bytesToHex)(utxo.txid),
@@ -34225,7 +34787,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 *****
@@ -35135,7 +35697,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;
@@ -35208,7 +35770,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
 var import_sdk_trace_web = require("@opentelemetry/sdk-trace-web");
 var import_instrumentation = require("@opentelemetry/instrumentation");
 var import_instrumentation_fetch = require("@opentelemetry/instrumentation-fetch");
-var import_core13 = require("@opentelemetry/core");
+var import_core14 = require("@opentelemetry/core");
 var import_api2 = require("@opentelemetry/api");
 var SparkWalletBrowser = class _SparkWalletBrowser extends SparkWallet {
   static async initialize({
@@ -35244,7 +35806,7 @@ function initializeTracerEnvBrowser({
 }) {
   const provider = new import_sdk_trace_web.WebTracerProvider({ spanProcessors });
   provider.register();
-  import_api2.propagation.setGlobalPropagator(new import_core13.W3CTraceContextPropagator());
+  import_api2.propagation.setGlobalPropagator(new import_core14.W3CTraceContextPropagator());
   (0, import_instrumentation.registerInstrumentations)({
     instrumentations: [
       new import_instrumentation_fetch.FetchInstrumentation({
@@ -35278,6 +35840,7 @@ setCrypto(cryptoImpl2);
   INITIAL_SEQUENCE,
   InternalValidationError,
   KeyDerivationType,
+  LOGGER_NAMES,
   LRC_WALLET_NETWORK,
   Network,
   NetworkError,
@@ -35285,6 +35848,7 @@ setCrypto(cryptoImpl2);
   NotImplementedError,
   RPCError,
   SparkSDKError,
+  SparkSdkLogger,
   SparkWallet,
   TEST_UNILATERAL_DIRECT_SEQUENCE,
   TEST_UNILATERAL_SEQUENCE,