@buildonspark/spark-sdk 0.2.10 → 0.2.12

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,9 +1373,9 @@ 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_secp256k115 = require("@noble/curves/secp256k1");
+var import_utils23 = 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");
@@ -4116,6 +4174,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:
@@ -4855,6 +4948,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) };
 }
@@ -10968,7 +11195,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 = {
@@ -10991,6 +11219,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) {
@@ -11042,6 +11273,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;
@@ -11057,7 +11295,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) {
@@ -11080,6 +11319,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) {
@@ -11093,6 +11335,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;
   }
 };
@@ -13990,13 +14233,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) {
+      Transfer6.encode(message.transfer, writer.uint32(26).fork()).join();
+    }
     return writer;
   },
   decode(input, length) {
@@ -14013,6 +14259,13 @@ var QueryUserSignedRefundsResponse = {
           message.userSignedRefunds.push(UserSignedRefund.decode(reader, reader.uint32()));
           continue;
         }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.transfer = Transfer6.decode(reader, reader.uint32());
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -14023,7 +14276,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) ? Transfer6.fromJSON(object.transfer) : void 0
     };
   },
   toJSON(message) {
@@ -14031,6 +14285,9 @@ var QueryUserSignedRefundsResponse = {
     if (message.userSignedRefunds?.length) {
       obj.userSignedRefunds = message.userSignedRefunds.map((e) => UserSignedRefund.toJSON(e));
     }
+    if (message.transfer !== void 0) {
+      obj.transfer = Transfer6.toJSON(message.transfer);
+    }
     return obj;
   },
   create(base) {
@@ -14039,6 +14296,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 ? Transfer6.fromPartial(object.transfer) : void 0;
     return message;
   }
 };
@@ -14925,7 +15183,8 @@ function createBaseDepositAddressQueryResult() {
     depositAddress: "",
     userSigningPublicKey: new Uint8Array(0),
     verifyingPublicKey: new Uint8Array(0),
-    leafId: void 0
+    leafId: void 0,
+    proofOfPossession: void 0
   };
 }
 var DepositAddressQueryResult = {
@@ -14942,6 +15201,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) {
@@ -14979,6 +15241,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;
@@ -14992,7 +15261,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) {
@@ -15009,6 +15279,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) {
@@ -15020,6 +15293,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;
   }
 };
@@ -16984,7 +17258,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()) {
@@ -17000,6 +17274,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) {
@@ -17037,6 +17314,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;
@@ -17050,7 +17334,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) {
@@ -17067,6 +17352,9 @@ var GetUtxosForAddressRequest = {
     if (message.network !== 0) {
       obj.network = networkToJSON(message.network);
     }
+    if (message.excludeClaimed !== false) {
+      obj.excludeClaimed = message.excludeClaimed;
+    }
     return obj;
   },
   create(base) {
@@ -17078,6 +17366,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;
   }
 };
@@ -17149,6 +17438,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",
@@ -17161,6 +17669,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,
@@ -17602,6 +18119,14 @@ var SparkServiceDefinition = {
       responseType: GetUtxosForAddressResponse,
       responseStream: false,
       options: {}
+    },
+    query_spark_invoices: {
+      name: "query_spark_invoices",
+      requestType: QuerySparkInvoicesRequest,
+      requestStream: false,
+      responseType: QuerySparkInvoicesResponse,
+      responseStream: false,
+      options: {}
     }
   }
 };
@@ -17670,13 +18195,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_secp256k15 = require("@noble/curves/secp256k1");
+var import_utils5 = require("@noble/curves/utils");
 var import_sha22 = require("@noble/hashes/sha2");
 var import_bip32 = require("@scure/bip32");
 var import_bip39 = require("@scure/bip39");
 var import_english = require("@scure/bip39/wordlists/english");
-var import_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 +18209,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.12" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -17704,8 +18229,8 @@ var clientEnv = `js-spark-sdk/${packageVersion} ${baseEnvStr}`;
 
 // src/utils/keys.ts
 init_buffer();
-var import_utils2 = require("@noble/curves/abstract/utils");
 var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_utils2 = require("@noble/curves/utils");
 function addPublicKeys(a, b) {
   if (a.length !== 33 || b.length !== 33) {
     throw new ValidationError("Public keys must be 33 bytes", {
@@ -17714,9 +18239,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 +18258,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 +18272,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) {
@@ -17803,8 +18328,8 @@ function lastKeyWithTarget(target, keys) {
 
 // src/utils/secret-sharing.ts
 init_buffer();
-var import_utils3 = require("@noble/curves/abstract/utils");
 var import_secp256k12 = require("@noble/curves/secp256k1");
+var import_utils3 = require("@noble/curves/utils");
 
 // src/utils/crypto.ts
 init_buffer();
@@ -17904,11 +18429,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 +18505,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 +18526,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 +18721,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 +18855,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 +18891,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 +18933,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 +18945,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 +18966,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 +18990,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 +19410,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 +23168,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 +23185,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 +23216,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 +23322,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 +23373,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 +23395,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 +23473,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,8 +23523,8 @@ var import_uuidv72 = require("uuidv7");
 
 // src/utils/bitcoin.ts
 init_buffer();
-var import_utils6 = require("@noble/curves/abstract/utils");
 var import_secp256k16 = require("@noble/curves/secp256k1");
+var import_utils7 = require("@noble/curves/utils");
 var import_sha24 = require("@noble/hashes/sha2");
 var btc2 = __toESM(require("@scure/btc-signer"), 1);
 function computeTaprootKeyNoScript(pubkey) {
@@ -23011,10 +23536,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 +23549,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 +23571,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 +23589,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 +23614,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 +23661,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,8 +24012,8 @@ function getEphemeralAnchorOutput() {
 
 // src/services/transfer.ts
 init_buffer();
-var import_utils8 = require("@noble/curves/abstract/utils");
 var import_secp256k17 = require("@noble/curves/secp256k1");
+var import_utils9 = require("@noble/curves/utils");
 var import_sha26 = require("@noble/hashes/sha2");
 var import_btc_signer2 = require("@scure/btc-signer");
 var ecies2 = __toESM(require("eciesjs"), 1);
@@ -23496,7 +24021,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/utils");
 var import_sha25 = require("@noble/hashes/sha2");
 function getTransferPackageSigningPayload(transferID, transferPackage) {
   const encryptedPayload = transferPackage.keyTweakPackage;
@@ -23505,7 +24030,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 +24410,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 +24451,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 +24476,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 +24499,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 +24798,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 +24806,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 +24940,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 +24953,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 +25139,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 +25273,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 +25310,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 +25550,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 +25932,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();
@@ -25435,7 +25960,8 @@ var DepositService = class {
   }
   async validateDepositAddress({
     address: address2,
-    userPubkey
+    userPubkey,
+    verifyCoordinatorProof = false
   }) {
     if (!address2.depositAddressProof || !address2.depositAddressProof.proofOfPossessionSignature || !address2.depositAddressProof.addressSignatures) {
       throw new ValidationError(
@@ -25473,10 +25999,10 @@ var DepositService = class {
     }
     const addrHash = (0, import_sha28.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_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 +26011,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",
@@ -25494,6 +26024,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,
@@ -25561,7 +26131,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 +26150,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 +26281,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 +26445,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 +26458,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 +26528,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,8 +26604,8 @@ var DepositService = class {
 
 // src/services/lightning.ts
 init_buffer();
-var import_utils11 = require("@noble/curves/abstract/utils");
 var import_secp256k19 = require("@noble/curves/secp256k1");
+var import_utils12 = require("@noble/curves/utils");
 var import_sha29 = require("@noble/hashes/sha2");
 var import_uuidv73 = require("uuidv7");
 
@@ -26121,8 +26691,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 +26747,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 +26953,18 @@ var LightningService = class {
 
 // src/services/token-transactions.ts
 init_buffer();
-var import_utils16 = require("@noble/curves/abstract/utils");
 var import_secp256k112 = require("@noble/curves/secp256k1");
+var import_utils16 = require("@noble/curves/utils");
 var import_utils17 = require("@noble/hashes/utils");
 
 // src/utils/address.ts
 init_buffer();
+var import_wire8 = require("@bufbuild/protobuf/wire");
 var import_secp256k110 = require("@noble/curves/secp256k1");
-var import_utils12 = require("@noble/hashes/utils");
+var import_utils13 = require("@noble/curves/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 +27134,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 +27148,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 +27192,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 +27203,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 +27214,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 +27263,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 +27298,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 +29453,11 @@ 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/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) {
@@ -30000,8 +30569,8 @@ 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_secp256k113 = require("@noble/curves/secp256k1");
+var import_utils18 = require("@noble/curves/utils");
 function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
   const { r, s: s2 } = parseSignature(signature);
   const sBigInt = (0, import_utils18.bytesToNumberBE)(s2);
@@ -30068,7 +30637,7 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   const commitmenet = import_secp256k113.schnorr.utils.taggedHash(
     "BIP0340/challenge",
     r,
-    pubKey.toRawBytes().slice(1),
+    pubKey.toBytes().slice(1),
     hash
   );
   if (commitmenet.length > 32) {
@@ -30076,22 +30645,20 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   }
   const e = (0, import_modular.mod)((0, import_utils18.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_utils18.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);
@@ -30139,7 +30706,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_utils19 = require("@noble/curves/utils");
 var SigningService = class {
   config;
   constructor(config) {
@@ -30305,8 +30872,8 @@ var SigningService = class {
 
 // src/tests/utils/test-faucet.ts
 init_buffer();
-var import_utils20 = require("@noble/curves/abstract/utils");
 var import_secp256k114 = require("@noble/curves/secp256k1");
+var import_utils20 = require("@noble/curves/utils");
 var btc3 = __toESM(require("@scure/btc-signer"), 1);
 var import_btc_signer5 = require("@scure/btc-signer");
 var import_utils21 = require("@scure/btc-signer/utils");
@@ -30610,7 +31177,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
 
 // src/types/sdk-types.ts
 init_buffer();
-var import_utils22 = require("@noble/curves/abstract/utils");
+var import_utils22 = require("@noble/curves/utils");
 function mapTreeNodeToWalletLeaf(proto) {
   return {
     id: proto.id,
@@ -30898,7 +31465,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();
@@ -31920,7 +32487,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.
@@ -31929,43 +32496,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", {
@@ -31992,7 +32548,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"
@@ -32006,7 +32562,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_utils23.bytesToHex)(utxo.txid),
@@ -33438,7 +33995,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 *****
@@ -34348,7 +34905,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 +34981,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 +35132,7 @@ async function isTxBroadcast(txid, baseUrl, network) {
 
 // src/utils/unilateral-exit.ts
 init_buffer();
-var import_utils24 = require("@noble/curves/abstract/utils");
+var import_utils24 = require("@noble/curves/utils");
 var import_legacy = require("@noble/hashes/legacy");
 var import_sha213 = require("@noble/hashes/sha2");
 var btc4 = __toESM(require("@scure/btc-signer"), 1);
@@ -35071,6 +35630,9 @@ function getSparkAddressFromTaproot(taprootAddress) {
   throw new ValidationError("Invalid taproot address");
 }
 
+// src/utils/index.ts
+init_logging();
+
 // src/debug.ts
 var s = {
   SparkWallet,