@buildonspark/spark-sdk 0.3.2 → 0.3.4

package/dist/debug.cjs

@@ -1426,7 +1426,7 @@ init_buffer();
 // src/spark-wallet/spark-wallet.ts
 init_buffer();
 var import_core13 = require("@lightsparkdev/core");
-var import_secp256k115 = require("@noble/curves/secp256k1");
+var import_secp256k113 = 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");
@@ -1539,6 +1539,11 @@ var ConfigurationError = class extends SparkSDKError {
     super(message, context, originalError);
   }
 };
+var NotImplementedError = class extends SparkSDKError {
+  constructor(message, context, originalError) {
+    super(message, context, originalError);
+  }
+};
 
 // src/graphql/client.ts
 init_buffer();
@@ -4257,9 +4262,9 @@ function invoiceStatusFromJSON(object) {
     case 2:
     case "FINALIZED":
       return 2 /* FINALIZED */;
-    case 3:
-    case "EXPIRED":
-      return 3 /* EXPIRED */;
+    case 4:
+    case "RETURNED":
+      return 4 /* RETURNED */;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -4274,8 +4279,8 @@ function invoiceStatusToJSON(object) {
       return "PENDING";
     case 2 /* FINALIZED */:
       return "FINALIZED";
-    case 3 /* EXPIRED */:
-      return "EXPIRED";
+    case 4 /* RETURNED */:
+      return "RETURNED";
     case -1 /* UNRECOGNIZED */:
     default:
       return "UNRECOGNIZED";
@@ -6079,6 +6084,626 @@ var SigningResult_SignatureSharesEntry = {
     return message;
   }
 };
+function createBaseRenewLeafRequest() {
+  return { leafId: "", ownerIdentityPublicKey: new Uint8Array(0), signingJobs: void 0 };
+}
+var RenewLeafRequest = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.leafId !== "") {
+      writer.uint32(10).string(message.leafId);
+    }
+    if (message.ownerIdentityPublicKey.length !== 0) {
+      writer.uint32(18).bytes(message.ownerIdentityPublicKey);
+    }
+    switch (message.signingJobs?.$case) {
+      case "renewNodeTimelockSigningJob":
+        RenewNodeTimelockSigningJob.encode(message.signingJobs.renewNodeTimelockSigningJob, writer.uint32(26).fork()).join();
+        break;
+      case "renewRefundTimelockSigningJob":
+        RenewRefundTimelockSigningJob.encode(
+          message.signingJobs.renewRefundTimelockSigningJob,
+          writer.uint32(34).fork()
+        ).join();
+        break;
+    }
+    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 = createBaseRenewLeafRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.leafId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.ownerIdentityPublicKey = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.signingJobs = {
+            $case: "renewNodeTimelockSigningJob",
+            renewNodeTimelockSigningJob: RenewNodeTimelockSigningJob.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.signingJobs = {
+            $case: "renewRefundTimelockSigningJob",
+            renewRefundTimelockSigningJob: RenewRefundTimelockSigningJob.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      leafId: isSet3(object.leafId) ? globalThis.String(object.leafId) : "",
+      ownerIdentityPublicKey: isSet3(object.ownerIdentityPublicKey) ? bytesFromBase642(object.ownerIdentityPublicKey) : new Uint8Array(0),
+      signingJobs: isSet3(object.renewNodeTimelockSigningJob) ? {
+        $case: "renewNodeTimelockSigningJob",
+        renewNodeTimelockSigningJob: RenewNodeTimelockSigningJob.fromJSON(object.renewNodeTimelockSigningJob)
+      } : isSet3(object.renewRefundTimelockSigningJob) ? {
+        $case: "renewRefundTimelockSigningJob",
+        renewRefundTimelockSigningJob: RenewRefundTimelockSigningJob.fromJSON(object.renewRefundTimelockSigningJob)
+      } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.leafId !== "") {
+      obj.leafId = message.leafId;
+    }
+    if (message.ownerIdentityPublicKey.length !== 0) {
+      obj.ownerIdentityPublicKey = base64FromBytes2(message.ownerIdentityPublicKey);
+    }
+    if (message.signingJobs?.$case === "renewNodeTimelockSigningJob") {
+      obj.renewNodeTimelockSigningJob = RenewNodeTimelockSigningJob.toJSON(
+        message.signingJobs.renewNodeTimelockSigningJob
+      );
+    } else if (message.signingJobs?.$case === "renewRefundTimelockSigningJob") {
+      obj.renewRefundTimelockSigningJob = RenewRefundTimelockSigningJob.toJSON(
+        message.signingJobs.renewRefundTimelockSigningJob
+      );
+    }
+    return obj;
+  },
+  create(base) {
+    return RenewLeafRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRenewLeafRequest();
+    message.leafId = object.leafId ?? "";
+    message.ownerIdentityPublicKey = object.ownerIdentityPublicKey ?? new Uint8Array(0);
+    switch (object.signingJobs?.$case) {
+      case "renewNodeTimelockSigningJob": {
+        if (object.signingJobs?.renewNodeTimelockSigningJob !== void 0 && object.signingJobs?.renewNodeTimelockSigningJob !== null) {
+          message.signingJobs = {
+            $case: "renewNodeTimelockSigningJob",
+            renewNodeTimelockSigningJob: RenewNodeTimelockSigningJob.fromPartial(
+              object.signingJobs.renewNodeTimelockSigningJob
+            )
+          };
+        }
+        break;
+      }
+      case "renewRefundTimelockSigningJob": {
+        if (object.signingJobs?.renewRefundTimelockSigningJob !== void 0 && object.signingJobs?.renewRefundTimelockSigningJob !== null) {
+          message.signingJobs = {
+            $case: "renewRefundTimelockSigningJob",
+            renewRefundTimelockSigningJob: RenewRefundTimelockSigningJob.fromPartial(
+              object.signingJobs.renewRefundTimelockSigningJob
+            )
+          };
+        }
+        break;
+      }
+    }
+    return message;
+  }
+};
+function createBaseRenewNodeTimelockSigningJob() {
+  return {
+    splitNodeTxSigningJob: void 0,
+    splitNodeDirectTxSigningJob: void 0,
+    nodeTxSigningJob: void 0,
+    refundTxSigningJob: void 0,
+    directNodeTxSigningJob: void 0,
+    directRefundTxSigningJob: void 0,
+    directFromCpfpRefundTxSigningJob: void 0
+  };
+}
+var RenewNodeTimelockSigningJob = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.splitNodeTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.splitNodeTxSigningJob, writer.uint32(10).fork()).join();
+    }
+    if (message.splitNodeDirectTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.splitNodeDirectTxSigningJob, writer.uint32(18).fork()).join();
+    }
+    if (message.nodeTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.nodeTxSigningJob, writer.uint32(26).fork()).join();
+    }
+    if (message.refundTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.refundTxSigningJob, writer.uint32(34).fork()).join();
+    }
+    if (message.directNodeTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.directNodeTxSigningJob, writer.uint32(42).fork()).join();
+    }
+    if (message.directRefundTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.directRefundTxSigningJob, writer.uint32(50).fork()).join();
+    }
+    if (message.directFromCpfpRefundTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.directFromCpfpRefundTxSigningJob, writer.uint32(58).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 = createBaseRenewNodeTimelockSigningJob();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.splitNodeTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.splitNodeDirectTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.nodeTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.refundTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.directNodeTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.directRefundTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.directFromCpfpRefundTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      splitNodeTxSigningJob: isSet3(object.splitNodeTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.splitNodeTxSigningJob) : void 0,
+      splitNodeDirectTxSigningJob: isSet3(object.splitNodeDirectTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.splitNodeDirectTxSigningJob) : void 0,
+      nodeTxSigningJob: isSet3(object.nodeTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.nodeTxSigningJob) : void 0,
+      refundTxSigningJob: isSet3(object.refundTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.refundTxSigningJob) : void 0,
+      directNodeTxSigningJob: isSet3(object.directNodeTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.directNodeTxSigningJob) : void 0,
+      directRefundTxSigningJob: isSet3(object.directRefundTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.directRefundTxSigningJob) : void 0,
+      directFromCpfpRefundTxSigningJob: isSet3(object.directFromCpfpRefundTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.directFromCpfpRefundTxSigningJob) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.splitNodeTxSigningJob !== void 0) {
+      obj.splitNodeTxSigningJob = UserSignedTxSigningJob.toJSON(message.splitNodeTxSigningJob);
+    }
+    if (message.splitNodeDirectTxSigningJob !== void 0) {
+      obj.splitNodeDirectTxSigningJob = UserSignedTxSigningJob.toJSON(message.splitNodeDirectTxSigningJob);
+    }
+    if (message.nodeTxSigningJob !== void 0) {
+      obj.nodeTxSigningJob = UserSignedTxSigningJob.toJSON(message.nodeTxSigningJob);
+    }
+    if (message.refundTxSigningJob !== void 0) {
+      obj.refundTxSigningJob = UserSignedTxSigningJob.toJSON(message.refundTxSigningJob);
+    }
+    if (message.directNodeTxSigningJob !== void 0) {
+      obj.directNodeTxSigningJob = UserSignedTxSigningJob.toJSON(message.directNodeTxSigningJob);
+    }
+    if (message.directRefundTxSigningJob !== void 0) {
+      obj.directRefundTxSigningJob = UserSignedTxSigningJob.toJSON(message.directRefundTxSigningJob);
+    }
+    if (message.directFromCpfpRefundTxSigningJob !== void 0) {
+      obj.directFromCpfpRefundTxSigningJob = UserSignedTxSigningJob.toJSON(message.directFromCpfpRefundTxSigningJob);
+    }
+    return obj;
+  },
+  create(base) {
+    return RenewNodeTimelockSigningJob.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRenewNodeTimelockSigningJob();
+    message.splitNodeTxSigningJob = object.splitNodeTxSigningJob !== void 0 && object.splitNodeTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.splitNodeTxSigningJob) : void 0;
+    message.splitNodeDirectTxSigningJob = object.splitNodeDirectTxSigningJob !== void 0 && object.splitNodeDirectTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.splitNodeDirectTxSigningJob) : void 0;
+    message.nodeTxSigningJob = object.nodeTxSigningJob !== void 0 && object.nodeTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.nodeTxSigningJob) : void 0;
+    message.refundTxSigningJob = object.refundTxSigningJob !== void 0 && object.refundTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.refundTxSigningJob) : void 0;
+    message.directNodeTxSigningJob = object.directNodeTxSigningJob !== void 0 && object.directNodeTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.directNodeTxSigningJob) : void 0;
+    message.directRefundTxSigningJob = object.directRefundTxSigningJob !== void 0 && object.directRefundTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.directRefundTxSigningJob) : void 0;
+    message.directFromCpfpRefundTxSigningJob = object.directFromCpfpRefundTxSigningJob !== void 0 && object.directFromCpfpRefundTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.directFromCpfpRefundTxSigningJob) : void 0;
+    return message;
+  }
+};
+function createBaseRenewRefundTimelockSigningJob() {
+  return {
+    nodeTxSigningJob: void 0,
+    refundTxSigningJob: void 0,
+    directNodeTxSigningJob: void 0,
+    directRefundTxSigningJob: void 0,
+    directFromCpfpRefundTxSigningJob: void 0
+  };
+}
+var RenewRefundTimelockSigningJob = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.nodeTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.nodeTxSigningJob, writer.uint32(10).fork()).join();
+    }
+    if (message.refundTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.refundTxSigningJob, writer.uint32(18).fork()).join();
+    }
+    if (message.directNodeTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.directNodeTxSigningJob, writer.uint32(26).fork()).join();
+    }
+    if (message.directRefundTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.directRefundTxSigningJob, writer.uint32(34).fork()).join();
+    }
+    if (message.directFromCpfpRefundTxSigningJob !== void 0) {
+      UserSignedTxSigningJob.encode(message.directFromCpfpRefundTxSigningJob, writer.uint32(42).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 = createBaseRenewRefundTimelockSigningJob();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.nodeTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.refundTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.directNodeTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.directRefundTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.directFromCpfpRefundTxSigningJob = UserSignedTxSigningJob.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      nodeTxSigningJob: isSet3(object.nodeTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.nodeTxSigningJob) : void 0,
+      refundTxSigningJob: isSet3(object.refundTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.refundTxSigningJob) : void 0,
+      directNodeTxSigningJob: isSet3(object.directNodeTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.directNodeTxSigningJob) : void 0,
+      directRefundTxSigningJob: isSet3(object.directRefundTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.directRefundTxSigningJob) : void 0,
+      directFromCpfpRefundTxSigningJob: isSet3(object.directFromCpfpRefundTxSigningJob) ? UserSignedTxSigningJob.fromJSON(object.directFromCpfpRefundTxSigningJob) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.nodeTxSigningJob !== void 0) {
+      obj.nodeTxSigningJob = UserSignedTxSigningJob.toJSON(message.nodeTxSigningJob);
+    }
+    if (message.refundTxSigningJob !== void 0) {
+      obj.refundTxSigningJob = UserSignedTxSigningJob.toJSON(message.refundTxSigningJob);
+    }
+    if (message.directNodeTxSigningJob !== void 0) {
+      obj.directNodeTxSigningJob = UserSignedTxSigningJob.toJSON(message.directNodeTxSigningJob);
+    }
+    if (message.directRefundTxSigningJob !== void 0) {
+      obj.directRefundTxSigningJob = UserSignedTxSigningJob.toJSON(message.directRefundTxSigningJob);
+    }
+    if (message.directFromCpfpRefundTxSigningJob !== void 0) {
+      obj.directFromCpfpRefundTxSigningJob = UserSignedTxSigningJob.toJSON(message.directFromCpfpRefundTxSigningJob);
+    }
+    return obj;
+  },
+  create(base) {
+    return RenewRefundTimelockSigningJob.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRenewRefundTimelockSigningJob();
+    message.nodeTxSigningJob = object.nodeTxSigningJob !== void 0 && object.nodeTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.nodeTxSigningJob) : void 0;
+    message.refundTxSigningJob = object.refundTxSigningJob !== void 0 && object.refundTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.refundTxSigningJob) : void 0;
+    message.directNodeTxSigningJob = object.directNodeTxSigningJob !== void 0 && object.directNodeTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.directNodeTxSigningJob) : void 0;
+    message.directRefundTxSigningJob = object.directRefundTxSigningJob !== void 0 && object.directRefundTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.directRefundTxSigningJob) : void 0;
+    message.directFromCpfpRefundTxSigningJob = object.directFromCpfpRefundTxSigningJob !== void 0 && object.directFromCpfpRefundTxSigningJob !== null ? UserSignedTxSigningJob.fromPartial(object.directFromCpfpRefundTxSigningJob) : void 0;
+    return message;
+  }
+};
+function createBaseRenewLeafResponse() {
+  return { renewResult: void 0 };
+}
+var RenewLeafResponse = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    switch (message.renewResult?.$case) {
+      case "extendResult":
+        RenewNodeTimelockResult.encode(message.renewResult.extendResult, writer.uint32(10).fork()).join();
+        break;
+      case "refreshResult":
+        RenewRefundTimelockResult.encode(message.renewResult.refreshResult, writer.uint32(18).fork()).join();
+        break;
+    }
+    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 = createBaseRenewLeafResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.renewResult = {
+            $case: "extendResult",
+            extendResult: RenewNodeTimelockResult.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.renewResult = {
+            $case: "refreshResult",
+            refreshResult: RenewRefundTimelockResult.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      renewResult: isSet3(object.extendResult) ? { $case: "extendResult", extendResult: RenewNodeTimelockResult.fromJSON(object.extendResult) } : isSet3(object.refreshResult) ? { $case: "refreshResult", refreshResult: RenewRefundTimelockResult.fromJSON(object.refreshResult) } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.renewResult?.$case === "extendResult") {
+      obj.extendResult = RenewNodeTimelockResult.toJSON(message.renewResult.extendResult);
+    } else if (message.renewResult?.$case === "refreshResult") {
+      obj.refreshResult = RenewRefundTimelockResult.toJSON(message.renewResult.refreshResult);
+    }
+    return obj;
+  },
+  create(base) {
+    return RenewLeafResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRenewLeafResponse();
+    switch (object.renewResult?.$case) {
+      case "extendResult": {
+        if (object.renewResult?.extendResult !== void 0 && object.renewResult?.extendResult !== null) {
+          message.renewResult = {
+            $case: "extendResult",
+            extendResult: RenewNodeTimelockResult.fromPartial(object.renewResult.extendResult)
+          };
+        }
+        break;
+      }
+      case "refreshResult": {
+        if (object.renewResult?.refreshResult !== void 0 && object.renewResult?.refreshResult !== null) {
+          message.renewResult = {
+            $case: "refreshResult",
+            refreshResult: RenewRefundTimelockResult.fromPartial(object.renewResult.refreshResult)
+          };
+        }
+        break;
+      }
+    }
+    return message;
+  }
+};
+function createBaseRenewNodeTimelockResult() {
+  return { splitNode: void 0, node: void 0 };
+}
+var RenewNodeTimelockResult = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.splitNode !== void 0) {
+      TreeNode.encode(message.splitNode, writer.uint32(10).fork()).join();
+    }
+    if (message.node !== void 0) {
+      TreeNode.encode(message.node, 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 = createBaseRenewNodeTimelockResult();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.splitNode = TreeNode.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.node = TreeNode.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      splitNode: isSet3(object.splitNode) ? TreeNode.fromJSON(object.splitNode) : void 0,
+      node: isSet3(object.node) ? TreeNode.fromJSON(object.node) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.splitNode !== void 0) {
+      obj.splitNode = TreeNode.toJSON(message.splitNode);
+    }
+    if (message.node !== void 0) {
+      obj.node = TreeNode.toJSON(message.node);
+    }
+    return obj;
+  },
+  create(base) {
+    return RenewNodeTimelockResult.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRenewNodeTimelockResult();
+    message.splitNode = object.splitNode !== void 0 && object.splitNode !== null ? TreeNode.fromPartial(object.splitNode) : void 0;
+    message.node = object.node !== void 0 && object.node !== null ? TreeNode.fromPartial(object.node) : void 0;
+    return message;
+  }
+};
+function createBaseRenewRefundTimelockResult() {
+  return { node: void 0 };
+}
+var RenewRefundTimelockResult = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.node !== void 0) {
+      TreeNode.encode(message.node, 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 = createBaseRenewRefundTimelockResult();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.node = TreeNode.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { node: isSet3(object.node) ? TreeNode.fromJSON(object.node) : void 0 };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.node !== void 0) {
+      obj.node = TreeNode.toJSON(message.node);
+    }
+    return obj;
+  },
+  create(base) {
+    return RenewRefundTimelockResult.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseRenewRefundTimelockResult();
+    message.node = object.node !== void 0 && object.node !== null ? TreeNode.fromPartial(object.node) : void 0;
+    return message;
+  }
+};
 function createBaseNodeSignatureShares() {
   return {
     nodeId: "",
@@ -17859,7 +18484,7 @@ var QuerySparkInvoicesResponse = {
   }
 };
 function createBaseInvoiceResponse() {
-  return { invoice: "", status: 0 };
+  return { invoice: "", status: 0, transferType: void 0 };
 }
 var InvoiceResponse = {
   encode(message, writer = new import_wire4.BinaryWriter()) {
@@ -17869,6 +18494,14 @@ var InvoiceResponse = {
     if (message.status !== 0) {
       writer.uint32(16).int32(message.status);
     }
+    switch (message.transferType?.$case) {
+      case "satsTransfer":
+        SatsTransfer.encode(message.transferType.satsTransfer, writer.uint32(26).fork()).join();
+        break;
+      case "tokenTransfer":
+        TokenTransfer.encode(message.transferType.tokenTransfer, writer.uint32(34).fork()).join();
+        break;
+    }
     return writer;
   },
   decode(input, length) {
@@ -17892,6 +18525,23 @@ var InvoiceResponse = {
           message.status = reader.int32();
           continue;
         }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.transferType = { $case: "satsTransfer", satsTransfer: SatsTransfer.decode(reader, reader.uint32()) };
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.transferType = {
+            $case: "tokenTransfer",
+            tokenTransfer: TokenTransfer.decode(reader, reader.uint32())
+          };
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -17903,7 +18553,8 @@ var InvoiceResponse = {
   fromJSON(object) {
     return {
       invoice: isSet3(object.invoice) ? globalThis.String(object.invoice) : "",
-      status: isSet3(object.status) ? invoiceStatusFromJSON(object.status) : 0
+      status: isSet3(object.status) ? invoiceStatusFromJSON(object.status) : 0,
+      transferType: isSet3(object.satsTransfer) ? { $case: "satsTransfer", satsTransfer: SatsTransfer.fromJSON(object.satsTransfer) } : isSet3(object.tokenTransfer) ? { $case: "tokenTransfer", tokenTransfer: TokenTransfer.fromJSON(object.tokenTransfer) } : void 0
     };
   },
   toJSON(message) {
@@ -17914,6 +18565,11 @@ var InvoiceResponse = {
     if (message.status !== 0) {
       obj.status = invoiceStatusToJSON(message.status);
     }
+    if (message.transferType?.$case === "satsTransfer") {
+      obj.satsTransfer = SatsTransfer.toJSON(message.transferType.satsTransfer);
+    } else if (message.transferType?.$case === "tokenTransfer") {
+      obj.tokenTransfer = TokenTransfer.toJSON(message.transferType.tokenTransfer);
+    }
     return obj;
   },
   create(base) {
@@ -17923,6 +18579,130 @@ var InvoiceResponse = {
     const message = createBaseInvoiceResponse();
     message.invoice = object.invoice ?? "";
     message.status = object.status ?? 0;
+    switch (object.transferType?.$case) {
+      case "satsTransfer": {
+        if (object.transferType?.satsTransfer !== void 0 && object.transferType?.satsTransfer !== null) {
+          message.transferType = {
+            $case: "satsTransfer",
+            satsTransfer: SatsTransfer.fromPartial(object.transferType.satsTransfer)
+          };
+        }
+        break;
+      }
+      case "tokenTransfer": {
+        if (object.transferType?.tokenTransfer !== void 0 && object.transferType?.tokenTransfer !== null) {
+          message.transferType = {
+            $case: "tokenTransfer",
+            tokenTransfer: TokenTransfer.fromPartial(object.transferType.tokenTransfer)
+          };
+        }
+        break;
+      }
+    }
+    return message;
+  }
+};
+function createBaseSatsTransfer() {
+  return { transferId: new Uint8Array(0) };
+}
+var SatsTransfer = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.transferId.length !== 0) {
+      writer.uint32(10).bytes(message.transferId);
+    }
+    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 = createBaseSatsTransfer();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.transferId = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { transferId: isSet3(object.transferId) ? bytesFromBase642(object.transferId) : new Uint8Array(0) };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.transferId.length !== 0) {
+      obj.transferId = base64FromBytes2(message.transferId);
+    }
+    return obj;
+  },
+  create(base) {
+    return SatsTransfer.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSatsTransfer();
+    message.transferId = object.transferId ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseTokenTransfer() {
+  return { finalTokenTransactionHash: new Uint8Array(0) };
+}
+var TokenTransfer = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.finalTokenTransactionHash.length !== 0) {
+      writer.uint32(10).bytes(message.finalTokenTransactionHash);
+    }
+    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 = createBaseTokenTransfer();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.finalTokenTransactionHash = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      finalTokenTransactionHash: isSet3(object.finalTokenTransactionHash) ? bytesFromBase642(object.finalTokenTransactionHash) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.finalTokenTransactionHash.length !== 0) {
+      obj.finalTokenTransactionHash = base64FromBytes2(message.finalTokenTransactionHash);
+    }
+    return obj;
+  },
+  create(base) {
+    return TokenTransfer.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTokenTransfer();
+    message.finalTokenTransactionHash = object.finalTokenTransactionHash ?? new Uint8Array(0);
     return message;
   }
 };
@@ -18138,6 +18918,21 @@ var SparkServiceDefinition = {
       responseStream: false,
       options: {}
     },
+    /**
+     * Resets the timelocks for a leaf's transactions. Can be used to reset the
+     * refund transaction timelock for a leaf (when the node transaction
+     * timelock is still > 300) or reset the node and refund transaction
+     * timelock. Returns an error if a leaf is not yet eligible to renew the
+     * timelocks, see RenewLeafRequest for more details.
+     */
+    renew_leaf: {
+      name: "renew_leaf",
+      requestType: RenewLeafRequest,
+      requestStream: false,
+      responseType: RenewLeafResponse,
+      responseStream: false,
+      options: {}
+    },
     get_signing_operator_list: {
       name: "get_signing_operator_list",
       requestType: Empty,
@@ -18483,7 +19278,7 @@ var isWebExtension = (
   "chrome" in globalThis && globalThis.chrome.runtime?.id
 );
 var userAgent = "navigator" in globalThis ? globalThis.navigator.userAgent || "unknown-user-agent" : void 0;
-var packageVersion = true ? "0.3.2" : "unknown";
+var packageVersion = true ? "0.3.4" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -19459,7 +20254,6 @@ var BASE_CONFIG = {
   threshold: 2,
   signingOperators: getLocalSigningOperators(),
   tokenSignatures: "SCHNORR",
-  tokenTransactionVersion: "V1",
   tokenValidityDurationSeconds: 180,
   electrsUrl: getElectrsUrl("LOCAL"),
   expectedWithdrawBondSats: 1e4,
@@ -19663,9 +20457,6 @@ var WalletConfigService = class {
   getTokenSignatures() {
     return this.config.tokenSignatures;
   }
-  getTokenTransactionVersion() {
-    return this.config.tokenTransactionVersion;
-  }
   getTokenValidityDurationSeconds() {
     return this.config.tokenValidityDurationSeconds;
   }
@@ -23987,10 +24778,10 @@ var INITIAL_TIMELOCK = 2e3;
 var TEST_UNILATERAL_TIMELOCK = 100;
 var TIME_LOCK_INTERVAL = 100;
 var DIRECT_TIMELOCK_OFFSET = 50;
-var INITIAL_SEQUENCE = INITIAL_TIMELOCK;
-var INITIAL_DIRECT_SEQUENCE = INITIAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
-var TEST_UNILATERAL_SEQUENCE = TEST_UNILATERAL_TIMELOCK;
-var TEST_UNILATERAL_DIRECT_SEQUENCE = TEST_UNILATERAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
+var INITIAL_SEQUENCE = 1 << 30 | INITIAL_TIMELOCK;
+var INITIAL_DIRECT_SEQUENCE = 1 << 30 | INITIAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
+var TEST_UNILATERAL_SEQUENCE = 1 << 30 | TEST_UNILATERAL_TIMELOCK;
+var TEST_UNILATERAL_DIRECT_SEQUENCE = 1 << 30 | TEST_UNILATERAL_TIMELOCK + DIRECT_TIMELOCK_OFFSET;
 var ESTIMATED_TX_SIZE = 191;
 var DEFAULT_SATS_PER_VBYTE = 5;
 var DEFAULT_FEE_SATS = ESTIMATED_TX_SIZE * DEFAULT_SATS_PER_VBYTE;
@@ -24261,8 +25052,8 @@ function getCurrentTimelock(currSequence) {
 function getTransactionSequence(currSequence) {
   const timelock = getCurrentTimelock(currSequence);
   return {
-    nextSequence: timelock,
-    nextDirectSequence: timelock + DIRECT_TIMELOCK_OFFSET
+    nextSequence: 1 << 30 | timelock,
+    nextDirectSequence: 1 << 30 | timelock + DIRECT_TIMELOCK_OFFSET
   };
 }
 function checkIfValidSequence(currSequence) {
@@ -24305,8 +25096,8 @@ function getNextTransactionSequence(currSequence, isNodeTx) {
     });
   }
   return {
-    nextSequence: nextTimelock,
-    nextDirectSequence: nextTimelock + DIRECT_TIMELOCK_OFFSET
+    nextSequence: 1 << 30 | nextTimelock,
+    nextDirectSequence: 1 << 30 | nextTimelock + DIRECT_TIMELOCK_OFFSET
   };
 }
 function getEphemeralAnchorOutput() {
@@ -24369,51 +25160,6 @@ var BaseTransferService = class {
     this.connectionManager = connectionManager;
     this.signingService = signingService;
   }
-  async sendTransferTweakKey(transfer, leaves, cpfpRefundSignatureMap, directRefundSignatureMap, directFromCpfpRefundSignatureMap) {
-    const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
-      transfer.id,
-      transfer.receiverIdentityPublicKey,
-      leaves,
-      cpfpRefundSignatureMap,
-      directRefundSignatureMap,
-      directFromCpfpRefundSignatureMap
-    );
-    let updatedTransfer;
-    const coordinatorOperator = this.config.getSigningOperators()[this.config.getCoordinatorIdentifier()];
-    if (!coordinatorOperator) {
-      throw new ValidationError("Coordinator operator not found", {
-        field: "coordinator"
-      });
-    }
-    for (const [identifier, operator] of Object.entries(
-      this.config.getSigningOperators()
-    ).filter(([_, op]) => op.address !== this.config.getCoordinatorAddress())) {
-      updatedTransfer = await this.finalizeTransfer(
-        operator,
-        identifier,
-        keyTweakInputMap,
-        transfer,
-        updatedTransfer
-      );
-    }
-    updatedTransfer = await this.finalizeTransfer(
-      coordinatorOperator,
-      this.config.getCoordinatorIdentifier(),
-      keyTweakInputMap,
-      transfer,
-      updatedTransfer
-    );
-    if (!updatedTransfer) {
-      throw new ValidationError(
-        "No transfer response received from any operator",
-        {
-          field: "operators",
-          value: Object.keys(this.config.getSigningOperators()).length
-        }
-      );
-    }
-    return updatedTransfer;
-  }
   async deliverTransferPackage(transfer, leaves, cpfpRefundSignatureMap, directRefundSignatureMap, directFromCpfpRefundSignatureMap) {
     const keyTweakInputMap = await this.prepareSendTransferKeyTweaks(
       transfer.id,
@@ -24555,55 +25301,7 @@ var BaseTransferService = class {
     transferPackage.userSignature = new Uint8Array(signature);
     return transferPackage;
   }
-  async finalizeTransfer(operator, identifier, keyTweakInputMap, transfer, updatedTransfer) {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      operator.address
-    );
-    const leavesToSend = keyTweakInputMap.get(identifier);
-    if (!leavesToSend) {
-      throw new ValidationError("No leaves to send for operator", {
-        field: "operator",
-        value: identifier
-      });
-    }
-    let transferResp;
-    try {
-      transferResp = await sparkClient.finalize_transfer({
-        transferId: transfer.id,
-        ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        leavesToSend
-      });
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to finalize transfer",
-        {
-          method: "POST"
-        },
-        error
-      );
-    }
-    if (!updatedTransfer) {
-      updatedTransfer = transferResp.transfer;
-    } else {
-      if (!transferResp.transfer) {
-        throw new ValidationError("No transfer response from operator", {
-          field: "transfer",
-          value: transfer.id
-        });
-      }
-      if (!this.compareTransfers(updatedTransfer, transferResp.transfer)) {
-        throw new ValidationError(
-          "Inconsistent transfer response from operators",
-          {
-            field: "transfer",
-            value: transfer.id
-          }
-        );
-      }
-    }
-    return updatedTransfer;
-  }
-  async signRefunds(leafDataMap, operatorSigningResults, cpfpAdaptorPubKey, directAdaptorPubKey, directFromCpfpAdaptorPubKey) {
+  async signRefunds(leafDataMap, operatorSigningResults) {
     const nodeSignatures = [];
     for (const operatorSigningResult of operatorSigningResults) {
       const leafData = leafDataMap.get(operatorSigningResult.leafId);
@@ -24632,7 +25330,6 @@ var BaseTransferService = class {
         keyDerivation: leafData.keyDerivation,
         selfCommitment: leafData.signingNonceCommitment,
         statechainCommitments: operatorSigningResult.refundTxSigningResult?.signingNonceCommitments,
-        adaptorPubKey: cpfpAdaptorPubKey,
         verifyingKey: operatorSigningResult.verifyingKey
       });
       const cpfpRefundAggregate = await this.config.signer.aggregateFrost({
@@ -24643,8 +25340,7 @@ var BaseTransferService = class {
         statechainCommitments: operatorSigningResult.refundTxSigningResult?.signingNonceCommitments,
         selfCommitment: leafData.signingNonceCommitment,
         publicKey,
-        selfSignature: cpfpUserSignature,
-        adaptorPubKey: cpfpAdaptorPubKey
+        selfSignature: cpfpUserSignature
       });
       let directRefundAggregate;
       let directFromCpfpRefundAggregate;
@@ -24662,7 +25358,6 @@ var BaseTransferService = class {
             keyDerivation: leafData.keyDerivation,
             selfCommitment: leafData.directSigningNonceCommitment,
             statechainCommitments: operatorSigningResult.directRefundTxSigningResult?.signingNonceCommitments,
-            adaptorPubKey: directAdaptorPubKey,
             verifyingKey: operatorSigningResult.verifyingKey
           });
           directRefundAggregate = await this.config.signer.aggregateFrost({
@@ -24673,8 +25368,7 @@ var BaseTransferService = class {
             statechainCommitments: operatorSigningResult.directRefundTxSigningResult?.signingNonceCommitments,
             selfCommitment: leafData.directSigningNonceCommitment,
             publicKey,
-            selfSignature: directUserSignature,
-            adaptorPubKey: directAdaptorPubKey
+            selfSignature: directUserSignature
           });
         }
         if (leafData.directFromCpfpRefundTx) {
@@ -24689,7 +25383,6 @@ var BaseTransferService = class {
             keyDerivation: leafData.keyDerivation,
             selfCommitment: leafData.directFromCpfpRefundSigningNonceCommitment,
             statechainCommitments: operatorSigningResult.directFromCpfpRefundTxSigningResult?.signingNonceCommitments,
-            adaptorPubKey: directFromCpfpAdaptorPubKey,
             verifyingKey: operatorSigningResult.verifyingKey
           });
           directFromCpfpRefundAggregate = await this.config.signer.aggregateFrost({
@@ -24700,8 +25393,7 @@ var BaseTransferService = class {
             statechainCommitments: operatorSigningResult.directFromCpfpRefundTxSigningResult?.signingNonceCommitments,
             selfCommitment: leafData.directFromCpfpRefundSigningNonceCommitment,
             publicKey,
-            selfSignature: directFromCpfpUserSignature,
-            adaptorPubKey: directFromCpfpAdaptorPubKey
+            selfSignature: directFromCpfpUserSignature
           });
         }
       }
@@ -24817,30 +25509,6 @@ var TransferService = class extends BaseTransferService {
   constructor(config, connectionManager, signingService) {
     super(config, connectionManager, signingService);
   }
-  /**
-   * @deprecated Use sendTransferWithKeyTweaks instead
-   * Deprecated in v0.1.32
-   */
-  async sendTransfer(leaves, receiverIdentityPubkey) {
-    const {
-      transfer,
-      signatureMap,
-      directSignatureMap,
-      directFromCpfpSignatureMap
-    } = await this.sendTransferSignRefund(
-      leaves,
-      receiverIdentityPubkey,
-      new Date(Date.now() + DEFAULT_EXPIRY_TIME)
-    );
-    const transferWithTweakedKeys = await this.sendTransferTweakKey(
-      transfer,
-      leaves,
-      signatureMap,
-      directSignatureMap,
-      directFromCpfpSignatureMap
-    );
-    return transferWithTweakedKeys;
-  }
   async claimTransfer(transfer, leaves) {
     let proofMap;
     if (transfer.status === 2 /* TRANSFER_STATUS_SENDER_KEY_TWEAKED */) {
@@ -24984,18 +25652,7 @@ var TransferService = class extends BaseTransferService {
       leafDataMap
     };
   }
-  async counterSwapSignRefund(leaves, receiverIdentityPubkey, expiryTime, cpfpAdaptorPubKey, directAdaptorPubKey, directFromCpfpAdaptorPubKey) {
-    return this.sendTransferSignRefundInternal(
-      leaves,
-      receiverIdentityPubkey,
-      expiryTime,
-      true,
-      cpfpAdaptorPubKey,
-      directAdaptorPubKey,
-      directFromCpfpAdaptorPubKey
-    );
-  }
-  async sendTransferSignRefundInternal(leaves, receiverIdentityPubkey, expiryTime, forSwap, cpfpAdaptorPubKey, directAdaptorPubKey, directFromCpfpAdaptorPubKey) {
+  async sendTransferSignRefundInternal(leaves, receiverIdentityPubkey, expiryTime, forSwap) {
     const transferId = (0, import_uuidv7.uuidv7)();
     const leafDataMap = /* @__PURE__ */ new Map();
     for (const leaf of leaves) {
@@ -25030,21 +25687,7 @@ var TransferService = class extends BaseTransferService {
     );
     let response;
     try {
-      if (cpfpAdaptorPubKey !== void 0 || directAdaptorPubKey !== void 0 || directFromCpfpAdaptorPubKey !== void 0) {
-        response = await sparkClient.counter_leaf_swap_v2({
-          transfer: {
-            transferId,
-            leavesToSend: signingJobs,
-            ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-            receiverIdentityPublicKey: receiverIdentityPubkey,
-            expiryTime
-          },
-          swapId: (0, import_uuidv7.uuidv7)(),
-          adaptorPublicKey: cpfpAdaptorPubKey,
-          directAdaptorPublicKey: directAdaptorPubKey,
-          directFromCpfpAdaptorPublicKey: directFromCpfpAdaptorPubKey
-        });
-      } else if (forSwap) {
+      if (forSwap) {
         response = await sparkClient.start_leaf_swap_v2({
           transferId,
           leavesToSend: signingJobs,
@@ -25069,10 +25712,7 @@ var TransferService = class extends BaseTransferService {
     }
     const signatures = await this.signRefunds(
       leafDataMap,
-      response.signingResults,
-      cpfpAdaptorPubKey,
-      directAdaptorPubKey,
-      directFromCpfpAdaptorPubKey
+      response.signingResults
     );
     const cpfpSignatureMap = /* @__PURE__ */ new Map();
     const directSignatureMap = /* @__PURE__ */ new Map();
@@ -27243,7 +27883,6 @@ var LightningService = class {
 
 // src/services/token-transactions.ts
 init_buffer();
-var import_secp256k112 = require("@noble/curves/secp256k1");
 var import_utils16 = require("@noble/curves/utils");
 var import_utils17 = require("@noble/hashes/utils");
 
@@ -27426,6 +28065,13 @@ function uint64be(value) {
 // src/utils/address.ts
 var BECH32M_LIMIT = 1024;
 var AddressNetwork = {
+  MAINNET: "spark",
+  TESTNET: "sparkt",
+  REGTEST: "sparkrt",
+  SIGNET: "sparks",
+  LOCAL: "sparkl"
+};
+var LegacyAddressNetwork = {
   MAINNET: "sp",
   TESTNET: "spt",
   REGTEST: "sprt",
@@ -27456,7 +28102,7 @@ function encodeSparkAddressWithSignature(payload, signature) {
     const serializedPayload = w.finish();
     const words = import_base2.bech32m.toWords(serializedPayload);
     return bech32mEncode(
-      AddressNetwork[payload.network],
+      LegacyAddressNetwork[payload.network],
       words
     );
   } catch (error) {
@@ -27472,14 +28118,14 @@ function encodeSparkAddressWithSignature(payload, signature) {
 }
 function decodeSparkAddress(address2, network) {
   try {
-    const decoded = bech32mDecode(address2);
-    if (decoded.prefix !== AddressNetwork[network]) {
+    if (network !== getNetworkFromSparkAddress(address2)) {
       throw new ValidationError("Invalid Spark address prefix", {
         field: "address",
         value: address2,
-        expected: `prefix='${AddressNetwork[network]}'`
+        expected: `prefix='${AddressNetwork[network]}' or '${LegacyAddressNetwork[network]}'`
       });
     }
+    const decoded = bech32mDecode(address2);
     const payload = SparkAddress.decode(import_base2.bech32m.fromWords(decoded.words));
     const { identityPublicKey, sparkInvoiceFields, signature } = payload;
     const identityPubkeyHex = (0, import_utils14.bytesToHex)(identityPublicKey);
@@ -27523,18 +28169,35 @@ function decodeSparkAddress(address2, network) {
     );
   }
 }
+var PrefixToNetwork = Object.fromEntries(
+  Object.entries(AddressNetwork).map(([k, v]) => [v, k])
+);
+var LegacyPrefixToNetwork = Object.fromEntries(
+  Object.entries(LegacyAddressNetwork).map(([k, v]) => [v, k])
+);
+function getNetworkFromSparkAddress(address2) {
+  const { prefix } = bech32mDecode(address2);
+  const network = PrefixToNetwork[prefix] ?? LegacyPrefixToNetwork[prefix];
+  if (!network) {
+    throw new ValidationError("Invalid Spark address prefix", {
+      field: "network",
+      value: address2,
+      expected: "prefix='spark1', 'sparkt1', 'sparkrt1', 'sparks1', 'sparkl1' or legacy ('sp1', 'spt1', 'sprt1', 'sps1', 'spl1')"
+    });
+  }
+  return network;
+}
+function isLegacySparkAddress(address2) {
+  try {
+    const { prefix } = bech32mDecode(address2);
+    return prefix in LegacyPrefixToNetwork;
+  } catch (error) {
+    return false;
+  }
+}
 function isValidSparkAddress(address2) {
   try {
-    const network = Object.entries(AddressNetwork).find(
-      ([_, prefix]) => address2.startsWith(prefix)
-    )?.[0];
-    if (!network) {
-      throw new ValidationError("Invalid Spark address network", {
-        field: "network",
-        value: address2,
-        expected: Object.values(AddressNetwork)
-      });
-    }
+    const network = getNetworkFromSparkAddress(address2);
     decodeSparkAddress(address2, network);
     return true;
   } catch (error) {
@@ -27730,25 +28393,16 @@ function validateSparkInvoiceSignature(invoice) {
     );
   }
 }
-function getNetworkFromSparkAddress(address2) {
-  const { prefix } = bech32mDecode(address2);
-  const network = Object.entries(AddressNetwork).find(
-    ([, p]) => p === prefix
-  )?.[0];
-  if (!network) {
-    throw new ValidationError("Invalid Spark address network", {
-      field: "network",
-      value: address2,
-      expected: Object.values(AddressNetwork)
-    });
-  }
-  return network;
-}
 function toProtoTimestamp(date) {
   const ms = date.getTime();
   return { seconds: Math.floor(ms / 1e3), nanos: ms % 1e3 * 1e6 };
 }
+function assertBech32(s2) {
+  const i = s2.lastIndexOf("1");
+  if (i <= 0 || i >= s2.length - 1) throw new Error("invalid bech32 string");
+}
 function bech32mDecode(address2) {
+  assertBech32(address2);
   return import_base2.bech32m.decode(address2, BECH32M_LIMIT);
 }
 function bech32mEncode(prefix, words) {
@@ -27783,36 +28437,12 @@ function isSafeForNumber(bi) {
   return bi >= BigInt(Number.MIN_SAFE_INTEGER) && bi <= BigInt(Number.MAX_SAFE_INTEGER);
 }
 
-// src/utils/response-validation.ts
-init_buffer();
-function collectResponses(responses) {
-  const successfulResponses = responses.filter(
-    (result) => result.status === "fulfilled"
-  ).map((result) => result.value);
-  const failedResponses = responses.filter(
-    (result) => result.status === "rejected"
-  );
-  if (failedResponses.length > 0) {
-    const errors = failedResponses.map((result) => result.reason).join("\n");
-    throw new NetworkError(
-      `${failedResponses.length} out of ${responses.length} requests failed, please try again`,
-      {
-        errorCount: failedResponses.length,
-        errors
-      }
-    );
-  }
-  return successfulResponses;
-}
-
 // src/utils/token-hashing.ts
 init_buffer();
 var import_sha211 = require("@noble/hashes/sha2");
 var import_base3 = require("@scure/base");
 function hashTokenTransaction(tokenTransaction, partialHash = false) {
   switch (tokenTransaction.version) {
-    case 0:
-      return hashTokenTransactionV0(tokenTransaction, partialHash);
     case 1:
       return hashTokenTransactionV1(tokenTransaction, partialHash);
     case 2:
@@ -27824,345 +28454,6 @@ function hashTokenTransaction(tokenTransaction, partialHash = false) {
       });
   }
 }
-function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
-  if (!tokenTransaction) {
-    throw new ValidationError("token transaction cannot be nil", {
-      field: "tokenTransaction"
-    });
-  }
-  let allHashes = [];
-  if (tokenTransaction.tokenInputs?.$case === "transferInput") {
-    if (!tokenTransaction.tokenInputs.transferInput.outputsToSpend) {
-      throw new ValidationError("outputs to spend cannot be null", {
-        field: "tokenInputs.transferInput.outputsToSpend"
-      });
-    }
-    if (tokenTransaction.tokenInputs.transferInput.outputsToSpend.length === 0) {
-      throw new ValidationError("outputs to spend cannot be empty", {
-        field: "tokenInputs.transferInput.outputsToSpend"
-      });
-    }
-    for (const [
-      i,
-      output
-    ] of tokenTransaction.tokenInputs.transferInput.outputsToSpend.entries()) {
-      if (!output) {
-        throw new ValidationError(`output cannot be null at index ${i}`, {
-          field: `tokenInputs.transferInput.outputsToSpend[${i}]`,
-          index: i
-        });
-      }
-      const hashObj2 = import_sha211.sha256.create();
-      if (output.prevTokenTransactionHash) {
-        const prevHash = output.prevTokenTransactionHash;
-        if (output.prevTokenTransactionHash.length !== 32) {
-          throw new ValidationError(
-            `invalid previous transaction hash length at index ${i}`,
-            {
-              field: `tokenInputs.transferInput.outputsToSpend[${i}].prevTokenTransactionHash`,
-              value: prevHash,
-              expectedLength: 32,
-              actualLength: prevHash.length,
-              index: i
-            }
-          );
-        }
-        hashObj2.update(output.prevTokenTransactionHash);
-      }
-      const voutBytes = new Uint8Array(4);
-      new DataView(voutBytes.buffer).setUint32(
-        0,
-        output.prevTokenTransactionVout,
-        false
-      );
-      hashObj2.update(voutBytes);
-      allHashes.push(hashObj2.digest());
-    }
-  }
-  if (tokenTransaction.tokenInputs?.$case === "mintInput") {
-    const hashObj2 = import_sha211.sha256.create();
-    if (tokenTransaction.tokenInputs.mintInput.issuerPublicKey) {
-      const issuerPubKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-      if (issuerPubKey.length === 0) {
-        throw new ValidationError("issuer public key cannot be empty", {
-          field: "tokenInputs.mintInput.issuerPublicKey",
-          value: issuerPubKey,
-          expectedLength: 1,
-          actualLength: 0
-        });
-      }
-      hashObj2.update(issuerPubKey);
-      let timestampValue = 0;
-      const mintInput = tokenTransaction.tokenInputs.mintInput;
-      if ("issuerProvidedTimestamp" in mintInput) {
-        const v0MintInput = mintInput;
-        if (v0MintInput.issuerProvidedTimestamp != 0) {
-          timestampValue = v0MintInput.issuerProvidedTimestamp;
-        }
-      } else if ("clientCreatedTimestamp" in tokenTransaction && tokenTransaction.clientCreatedTimestamp) {
-        timestampValue = tokenTransaction.clientCreatedTimestamp.getTime();
-      }
-      if (timestampValue != 0) {
-        const timestampBytes = new Uint8Array(8);
-        new DataView(timestampBytes.buffer).setBigUint64(
-          0,
-          BigInt(timestampValue),
-          true
-          // true for little-endian to match Go implementation
-        );
-        hashObj2.update(timestampBytes);
-      }
-      allHashes.push(hashObj2.digest());
-    }
-  }
-  if (tokenTransaction.tokenInputs?.$case === "createInput") {
-    const issuerPubKeyHashObj = import_sha211.sha256.create();
-    const createInput = tokenTransaction.tokenInputs.createInput;
-    if (!createInput.issuerPublicKey || createInput.issuerPublicKey.length === 0) {
-      throw new ValidationError("issuer public key cannot be nil or empty", {
-        field: "tokenInputs.createInput.issuerPublicKey"
-      });
-    }
-    issuerPubKeyHashObj.update(createInput.issuerPublicKey);
-    allHashes.push(issuerPubKeyHashObj.digest());
-    const tokenNameHashObj = import_sha211.sha256.create();
-    if (!createInput.tokenName || createInput.tokenName.length === 0) {
-      throw new ValidationError("token name cannot be empty", {
-        field: "tokenInputs.createInput.tokenName"
-      });
-    }
-    if (createInput.tokenName.length > 20) {
-      throw new ValidationError("token name cannot be longer than 20 bytes", {
-        field: "tokenInputs.createInput.tokenName",
-        value: createInput.tokenName,
-        expectedLength: 20,
-        actualLength: createInput.tokenName.length
-      });
-    }
-    const tokenNameBytes = new Uint8Array(20);
-    const tokenNameEncoder = new TextEncoder();
-    tokenNameBytes.set(tokenNameEncoder.encode(createInput.tokenName));
-    tokenNameHashObj.update(tokenNameBytes);
-    allHashes.push(tokenNameHashObj.digest());
-    const tokenTickerHashObj = import_sha211.sha256.create();
-    if (!createInput.tokenTicker || createInput.tokenTicker.length === 0) {
-      throw new ValidationError("token ticker cannot be empty", {
-        field: "tokenInputs.createInput.tokenTicker"
-      });
-    }
-    if (createInput.tokenTicker.length > 6) {
-      throw new ValidationError("token ticker cannot be longer than 6 bytes", {
-        field: "tokenInputs.createInput.tokenTicker",
-        value: createInput.tokenTicker,
-        expectedLength: 6,
-        actualLength: createInput.tokenTicker.length
-      });
-    }
-    const tokenTickerBytes = new Uint8Array(6);
-    const tokenTickerEncoder = new TextEncoder();
-    tokenTickerBytes.set(tokenTickerEncoder.encode(createInput.tokenTicker));
-    tokenTickerHashObj.update(tokenTickerBytes);
-    allHashes.push(tokenTickerHashObj.digest());
-    const decimalsHashObj = import_sha211.sha256.create();
-    const decimalsBytes = new Uint8Array(4);
-    new DataView(decimalsBytes.buffer).setUint32(
-      0,
-      createInput.decimals,
-      false
-    );
-    decimalsHashObj.update(decimalsBytes);
-    allHashes.push(decimalsHashObj.digest());
-    const maxSupplyHashObj = import_sha211.sha256.create();
-    if (!createInput.maxSupply) {
-      throw new ValidationError("max supply cannot be nil", {
-        field: "tokenInputs.createInput.maxSupply"
-      });
-    }
-    if (createInput.maxSupply.length !== 16) {
-      throw new ValidationError("max supply must be exactly 16 bytes", {
-        field: "tokenInputs.createInput.maxSupply",
-        value: createInput.maxSupply,
-        expectedLength: 16,
-        actualLength: createInput.maxSupply.length
-      });
-    }
-    maxSupplyHashObj.update(createInput.maxSupply);
-    allHashes.push(maxSupplyHashObj.digest());
-    const isFreezableHashObj = import_sha211.sha256.create();
-    const isFreezableByte = new Uint8Array([createInput.isFreezable ? 1 : 0]);
-    isFreezableHashObj.update(isFreezableByte);
-    allHashes.push(isFreezableHashObj.digest());
-    const creationEntityHashObj = import_sha211.sha256.create();
-    if (!partialHash && createInput.creationEntityPublicKey) {
-      creationEntityHashObj.update(createInput.creationEntityPublicKey);
-    }
-    allHashes.push(creationEntityHashObj.digest());
-  }
-  if (!tokenTransaction.tokenOutputs) {
-    throw new ValidationError("token outputs cannot be null", {
-      field: "tokenOutputs"
-    });
-  }
-  if (tokenTransaction.tokenOutputs.length === 0 && tokenTransaction.tokenInputs?.$case !== "createInput") {
-    throw new ValidationError("token outputs cannot be empty", {
-      field: "tokenOutputs"
-    });
-  }
-  for (const [i, output] of tokenTransaction.tokenOutputs.entries()) {
-    if (!output) {
-      throw new ValidationError(`output cannot be null at index ${i}`, {
-        field: `tokenOutputs[${i}]`,
-        index: i
-      });
-    }
-    const hashObj2 = import_sha211.sha256.create();
-    if (output.id && !partialHash) {
-      if (output.id.length === 0) {
-        throw new ValidationError(`output ID at index ${i} cannot be empty`, {
-          field: `tokenOutputs[${i}].id`,
-          index: i
-        });
-      }
-      hashObj2.update(new TextEncoder().encode(output.id));
-    }
-    if (output.ownerPublicKey) {
-      if (output.ownerPublicKey.length === 0) {
-        throw new ValidationError(
-          `owner public key at index ${i} cannot be empty`,
-          {
-            field: `tokenOutputs[${i}].ownerPublicKey`,
-            index: i
-          }
-        );
-      }
-      hashObj2.update(output.ownerPublicKey);
-    }
-    if (!partialHash) {
-      const revPubKey = output.revocationCommitment;
-      if (revPubKey) {
-        if (revPubKey.length === 0) {
-          throw new ValidationError(
-            `revocation commitment at index ${i} cannot be empty`,
-            {
-              field: `tokenOutputs[${i}].revocationCommitment`,
-              index: i
-            }
-          );
-        }
-        hashObj2.update(revPubKey);
-      }
-      const bondBytes = new Uint8Array(8);
-      new DataView(bondBytes.buffer).setBigUint64(
-        0,
-        BigInt(output.withdrawBondSats),
-        false
-      );
-      hashObj2.update(bondBytes);
-      const locktimeBytes = new Uint8Array(8);
-      new DataView(locktimeBytes.buffer).setBigUint64(
-        0,
-        BigInt(output.withdrawRelativeBlockLocktime),
-        false
-      );
-      hashObj2.update(locktimeBytes);
-    }
-    if (output.tokenPublicKey) {
-      if (output.tokenPublicKey.length === 0) {
-        throw new ValidationError(
-          `token public key at index ${i} cannot be empty`,
-          {
-            field: `tokenOutputs[${i}].tokenPublicKey`,
-            index: i
-          }
-        );
-      }
-      hashObj2.update(output.tokenPublicKey);
-    }
-    if (output.tokenAmount) {
-      if (output.tokenAmount.length === 0) {
-        throw new ValidationError(
-          `token amount at index ${i} cannot be empty`,
-          {
-            field: `tokenOutputs[${i}].tokenAmount`,
-            index: i
-          }
-        );
-      }
-      if (output.tokenAmount.length > 16) {
-        throw new ValidationError(
-          `token amount at index ${i} exceeds maximum length`,
-          {
-            field: `tokenOutputs[${i}].tokenAmount`,
-            value: output.tokenAmount,
-            expectedLength: 16,
-            actualLength: output.tokenAmount.length,
-            index: i
-          }
-        );
-      }
-      hashObj2.update(output.tokenAmount);
-    }
-    allHashes.push(hashObj2.digest());
-  }
-  if (!tokenTransaction.sparkOperatorIdentityPublicKeys) {
-    throw new ValidationError(
-      "spark operator identity public keys cannot be null",
-      {}
-    );
-  }
-  const sortedPubKeys = [
-    ...tokenTransaction.sparkOperatorIdentityPublicKeys || []
-  ].sort((a, b) => {
-    for (let i = 0; i < a.length && i < b.length; i++) {
-      if (a[i] !== b[i]) return a[i] - b[i];
-    }
-    return a.length - b.length;
-  });
-  for (const [i, pubKey] of sortedPubKeys.entries()) {
-    if (!pubKey) {
-      throw new ValidationError(
-        `operator public key at index ${i} cannot be null`,
-        {
-          field: `sparkOperatorIdentityPublicKeys[${i}]`,
-          index: i
-        }
-      );
-    }
-    if (pubKey.length === 0) {
-      throw new ValidationError(
-        `operator public key at index ${i} cannot be empty`,
-        {
-          field: `sparkOperatorIdentityPublicKeys[${i}]`,
-          index: i
-        }
-      );
-    }
-    const hashObj2 = import_sha211.sha256.create();
-    hashObj2.update(pubKey);
-    allHashes.push(hashObj2.digest());
-  }
-  const hashObj = import_sha211.sha256.create();
-  let networkBytes = new Uint8Array(4);
-  new DataView(networkBytes.buffer).setUint32(
-    0,
-    tokenTransaction.network.valueOf(),
-    false
-    // false for big-endian
-  );
-  hashObj.update(networkBytes);
-  allHashes.push(hashObj.digest());
-  const finalHashObj = import_sha211.sha256.create();
-  const concatenatedHashes = new Uint8Array(
-    allHashes.reduce((sum, hash) => sum + hash.length, 0)
-  );
-  let offset = 0;
-  for (const hash of allHashes) {
-    concatenatedHashes.set(hash, offset);
-    offset += hash.length;
-  }
-  finalHashObj.update(concatenatedHashes);
-  return finalHashObj.digest();
-}
 function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
   if (!tokenTransaction) {
     throw new ValidationError("token transaction cannot be nil", {
@@ -29190,24 +29481,6 @@ function getNetworkFromBech32mTokenIdentifier(bech32mTokenIdentifier) {
   });
 }
 
-// src/utils/token-keyshares.ts
-init_buffer();
-var import_secp256k111 = require("@noble/curves/secp256k1");
-function recoverRevocationSecretFromKeyshares(keyshares, threshold) {
-  const shares = keyshares.map((keyshare) => ({
-    fieldModulus: BigInt("0x" + import_secp256k111.secp256k1.CURVE.n.toString(16)),
-    // secp256k1 curve order
-    threshold,
-    index: BigInt(keyshare.operatorIndex),
-    share: BigInt(
-      "0x" + import_buffer.Buffer.from(keyshare.keyshare.keyshare).toString("hex")
-    ),
-    proofs: []
-  }));
-  const recoveredSecret = recoverSecret(shares);
-  return bigIntToPrivateKey(recoveredSecret);
-}
-
 // src/utils/token-transaction-validation.ts
 init_buffer();
 function areByteArraysEqual(a, b) {
@@ -29219,250 +29492,6 @@ function areByteArraysEqual(a, b) {
 function hasDuplicates(array) {
   return new Set(array).size !== array.length;
 }
-function validateTokenTransactionV0(finalTokenTransaction, partialTokenTransaction, signingOperators, keyshareInfo, expectedWithdrawBondSats, expectedWithdrawRelativeBlockLocktime, expectedThreshold) {
-  if (finalTokenTransaction.network !== partialTokenTransaction.network) {
-    throw new InternalValidationError(
-      "Network mismatch in response token transaction",
-      {
-        value: finalTokenTransaction.network,
-        expected: partialTokenTransaction.network
-      }
-    );
-  }
-  if (!finalTokenTransaction.tokenInputs) {
-    throw new InternalValidationError(
-      "Token inputs missing in final transaction",
-      {
-        value: finalTokenTransaction
-      }
-    );
-  }
-  if (!partialTokenTransaction.tokenInputs) {
-    throw new InternalValidationError(
-      "Token inputs missing in partial transaction",
-      {
-        value: partialTokenTransaction
-      }
-    );
-  }
-  if (finalTokenTransaction.tokenInputs.$case !== partialTokenTransaction.tokenInputs.$case) {
-    throw new InternalValidationError(
-      `Transaction type mismatch: final transaction has ${finalTokenTransaction.tokenInputs.$case}, partial transaction has ${partialTokenTransaction.tokenInputs.$case}`,
-      {
-        value: finalTokenTransaction.tokenInputs.$case,
-        expected: partialTokenTransaction.tokenInputs.$case
-      }
-    );
-  }
-  if (finalTokenTransaction.sparkOperatorIdentityPublicKeys.length !== partialTokenTransaction.sparkOperatorIdentityPublicKeys.length) {
-    throw new InternalValidationError(
-      "Spark operator identity public keys count mismatch",
-      {
-        value: finalTokenTransaction.sparkOperatorIdentityPublicKeys.length,
-        expected: partialTokenTransaction.sparkOperatorIdentityPublicKeys.length
-      }
-    );
-  }
-  if (partialTokenTransaction.tokenInputs.$case === "mintInput" && finalTokenTransaction.tokenInputs.$case === "mintInput") {
-    const finalMintInput = finalTokenTransaction.tokenInputs.mintInput;
-    const partialMintInput = partialTokenTransaction.tokenInputs.mintInput;
-    if (!areByteArraysEqual(
-      finalMintInput.issuerPublicKey,
-      partialMintInput.issuerPublicKey
-    )) {
-      throw new InternalValidationError(
-        "Issuer public key mismatch in mint input",
-        {
-          value: finalMintInput.issuerPublicKey.toString(),
-          expected: partialMintInput.issuerPublicKey.toString()
-        }
-      );
-    }
-  } else if (partialTokenTransaction.tokenInputs.$case === "transferInput" && finalTokenTransaction.tokenInputs.$case === "transferInput") {
-    const finalTransferInput = finalTokenTransaction.tokenInputs.transferInput;
-    const partialTransferInput = partialTokenTransaction.tokenInputs.transferInput;
-    if (finalTransferInput.outputsToSpend.length !== partialTransferInput.outputsToSpend.length) {
-      throw new InternalValidationError(
-        "Outputs to spend count mismatch in transfer input",
-        {
-          value: finalTransferInput.outputsToSpend.length,
-          expected: partialTransferInput.outputsToSpend.length
-        }
-      );
-    }
-    for (let i = 0; i < finalTransferInput.outputsToSpend.length; i++) {
-      const finalOutput = finalTransferInput.outputsToSpend[i];
-      const partialOutput = partialTransferInput.outputsToSpend[i];
-      if (!finalOutput) {
-        throw new InternalValidationError(
-          "Token output to spend missing in final transaction",
-          {
-            outputIndex: i,
-            value: finalOutput
-          }
-        );
-      }
-      if (!partialOutput) {
-        throw new InternalValidationError(
-          "Token output to spend missing in partial transaction",
-          {
-            outputIndex: i,
-            value: partialOutput
-          }
-        );
-      }
-      if (!areByteArraysEqual(
-        finalOutput.prevTokenTransactionHash,
-        partialOutput.prevTokenTransactionHash
-      )) {
-        throw new InternalValidationError(
-          "Previous token transaction hash mismatch in transfer input",
-          {
-            outputIndex: i,
-            value: finalOutput.prevTokenTransactionHash.toString(),
-            expected: partialOutput.prevTokenTransactionHash.toString()
-          }
-        );
-      }
-      if (finalOutput.prevTokenTransactionVout !== partialOutput.prevTokenTransactionVout) {
-        throw new InternalValidationError(
-          "Previous token transaction vout mismatch in transfer input",
-          {
-            outputIndex: i,
-            value: finalOutput.prevTokenTransactionVout,
-            expected: partialOutput.prevTokenTransactionVout
-          }
-        );
-      }
-    }
-  }
-  if (finalTokenTransaction.tokenOutputs.length !== partialTokenTransaction.tokenOutputs.length) {
-    throw new InternalValidationError("Token outputs count mismatch", {
-      value: finalTokenTransaction.tokenOutputs.length,
-      expected: partialTokenTransaction.tokenOutputs.length
-    });
-  }
-  for (let i = 0; i < finalTokenTransaction.tokenOutputs.length; i++) {
-    const finalOutput = finalTokenTransaction.tokenOutputs[i];
-    const partialOutput = partialTokenTransaction.tokenOutputs[i];
-    if (!finalOutput) {
-      throw new InternalValidationError(
-        "Token output missing in final transaction",
-        {
-          outputIndex: i,
-          value: finalOutput
-        }
-      );
-    }
-    if (!partialOutput) {
-      throw new InternalValidationError(
-        "Token output missing in partial transaction",
-        {
-          outputIndex: i,
-          value: partialOutput
-        }
-      );
-    }
-    if (!areByteArraysEqual(
-      finalOutput.ownerPublicKey,
-      partialOutput.ownerPublicKey
-    )) {
-      throw new InternalValidationError(
-        "Owner public key mismatch in token output",
-        {
-          outputIndex: i,
-          value: finalOutput.ownerPublicKey.toString(),
-          expected: partialOutput.ownerPublicKey.toString()
-        }
-      );
-    }
-    if (finalOutput.tokenPublicKey !== void 0 && partialOutput.tokenPublicKey !== void 0 && !areByteArraysEqual(
-      finalOutput.tokenPublicKey,
-      partialOutput.tokenPublicKey
-    )) {
-      throw new InternalValidationError(
-        "Token public key mismatch in token output",
-        {
-          outputIndex: i,
-          value: finalOutput.tokenPublicKey?.toString(),
-          expected: partialOutput.tokenPublicKey?.toString()
-        }
-      );
-    }
-    if (!areByteArraysEqual(finalOutput.tokenAmount, partialOutput.tokenAmount)) {
-      throw new InternalValidationError(
-        "Token amount mismatch in token output",
-        {
-          outputIndex: i,
-          value: finalOutput.tokenAmount.toString(),
-          expected: partialOutput.tokenAmount.toString()
-        }
-      );
-    }
-    if (finalOutput.withdrawBondSats !== void 0) {
-      if (finalOutput.withdrawBondSats !== expectedWithdrawBondSats) {
-        throw new InternalValidationError(
-          "Withdraw bond sats mismatch in token output",
-          {
-            outputIndex: i,
-            value: finalOutput.withdrawBondSats,
-            expected: expectedWithdrawBondSats
-          }
-        );
-      }
-    }
-    if (finalOutput.withdrawRelativeBlockLocktime !== void 0) {
-      if (finalOutput.withdrawRelativeBlockLocktime !== expectedWithdrawRelativeBlockLocktime) {
-        throw new InternalValidationError(
-          "Withdraw relative block locktime mismatch in token output",
-          {
-            outputIndex: i,
-            value: finalOutput.withdrawRelativeBlockLocktime,
-            expected: expectedWithdrawRelativeBlockLocktime
-          }
-        );
-      }
-    }
-    if (keyshareInfo.threshold !== expectedThreshold) {
-      throw new InternalValidationError(
-        "Threshold mismatch: expected " + expectedThreshold + " but got " + keyshareInfo.threshold,
-        {
-          field: "threshold",
-          value: keyshareInfo.threshold,
-          expected: expectedThreshold
-        }
-      );
-    }
-  }
-  if (keyshareInfo.ownerIdentifiers.length !== Object.keys(signingOperators).length) {
-    throw new InternalValidationError(
-      `Keyshare operator count (${keyshareInfo.ownerIdentifiers.length}) does not match signing operator count (${Object.keys(signingOperators).length})`,
-      {
-        keyshareInfo: keyshareInfo.ownerIdentifiers.length,
-        signingOperators: Object.keys(signingOperators).length
-      }
-    );
-  }
-  if (hasDuplicates(keyshareInfo.ownerIdentifiers)) {
-    throw new InternalValidationError(
-      "Duplicate ownerIdentifiers found in keyshareInfo",
-      {
-        keyshareInfo: keyshareInfo.ownerIdentifiers
-      }
-    );
-  }
-  for (const identifier of keyshareInfo.ownerIdentifiers) {
-    if (!signingOperators[identifier]) {
-      throw new InternalValidationError(
-        `Keyshare operator ${identifier} not found in signing operator list`,
-        {
-          keyshareInfo: identifier,
-          signingOperators: Object.keys(signingOperators)
-        }
-      );
-    }
-  }
-}
 function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction, signingOperators, keyshareInfo, expectedWithdrawBondSats, expectedWithdrawRelativeBlockLocktime, expectedThreshold) {
   if (finalTokenTransaction.network !== partialTokenTransaction.network) {
     throw new InternalValidationError(
@@ -29864,16 +29893,6 @@ var TokenTransactionService = class {
       tokenIdentifier,
       this.config.getNetworkType()
     ).tokenIdentifier;
-    let tokenPublicKey;
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      const tokenClient = await this.connectionManager.createSparkTokenClient(
-        this.config.getCoordinatorAddress()
-      );
-      const tokenMetadata = await tokenClient.query_token_metadata({
-        tokenIdentifiers: [rawTokenIdentifier]
-      });
-      tokenPublicKey = tokenMetadata.tokenMetadata[0].issuerPublicKey;
-    }
     let sparkInvoices = [];
     const tokenOutputData = receiverOutputs.map((transfer) => {
       const receiverAddress = decodeSparkAddress(
@@ -29883,7 +29902,7 @@ var TokenTransactionService = class {
       if (receiverAddress.sparkInvoiceFields) {
         sparkInvoices.push(transfer.receiverSparkAddress);
       }
-      if (this.config.getTokenTransactionVersion() !== "V0" && receiverAddress.sparkInvoiceFields) {
+      if (receiverAddress.sparkInvoiceFields) {
         return {
           receiverPublicKey: (0, import_utils17.hexToBytes)(receiverAddress.identityPublicKey),
           rawTokenIdentifier,
@@ -29894,24 +29913,14 @@ var TokenTransactionService = class {
       return {
         receiverPublicKey: (0, import_utils17.hexToBytes)(receiverAddress.identityPublicKey),
         rawTokenIdentifier,
-        tokenPublicKey,
-        // Remove for full v0 deprecation
         tokenAmount: transfer.tokenAmount
       };
     });
-    let tokenTransaction;
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      tokenTransaction = await this.constructTransferTokenTransactionV0(
-        outputsToUse,
-        tokenOutputData
-      );
-    } else {
-      tokenTransaction = await this.constructTransferTokenTransaction(
-        outputsToUse,
-        tokenOutputData,
-        sparkInvoices
-      );
-    }
+    const tokenTransaction = await this.constructTransferTokenTransaction(
+      outputsToUse,
+      tokenOutputData,
+      sparkInvoices
+    );
     const txId = await this.broadcastTokenTransaction(
       tokenTransaction,
       outputsToUse.map((output) => output.output.ownerPublicKey),
@@ -29919,44 +29928,6 @@ var TokenTransactionService = class {
     );
     return txId;
   }
-  async constructTransferTokenTransactionV0(selectedOutputs, tokenOutputData) {
-    selectedOutputs.sort(
-      (a, b) => a.previousTransactionVout - b.previousTransactionVout
-    );
-    const availableTokenAmount = sumAvailableTokens(selectedOutputs);
-    const totalRequestedAmount = tokenOutputData.reduce(
-      (sum, output) => sum + output.tokenAmount,
-      0n
-    );
-    const tokenOutputs = tokenOutputData.map((output) => ({
-      ownerPublicKey: output.receiverPublicKey,
-      tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: (0, import_utils16.numberToBytesBE)(output.tokenAmount, 16)
-    }));
-    if (availableTokenAmount > totalRequestedAmount) {
-      const changeAmount = availableTokenAmount - totalRequestedAmount;
-      const firstTokenPublicKey = tokenOutputData[0].tokenPublicKey;
-      tokenOutputs.push({
-        ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
-        tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils16.numberToBytesBE)(changeAmount, 16)
-      });
-    }
-    return {
-      network: this.config.getNetworkProto(),
-      tokenInputs: {
-        $case: "transferInput",
-        transferInput: {
-          outputsToSpend: selectedOutputs.map((output) => ({
-            prevTokenTransactionHash: output.previousTransactionHash,
-            prevTokenTransactionVout: output.previousTransactionVout
-          }))
-        }
-      },
-      tokenOutputs,
-      sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys()
-    };
-  }
   async constructTransferTokenTransaction(selectedOutputs, tokenOutputData, sparkInvoices) {
     selectedOutputs.sort(
       (a, b) => a.previousTransactionVout - b.previousTransactionVout
@@ -30012,113 +29983,6 @@ var TokenTransactionService = class {
   }
   async broadcastTokenTransaction(tokenTransaction, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const signingOperators = this.config.getSigningOperators();
-    if (!isTokenTransaction(tokenTransaction)) {
-      return this.broadcastTokenTransactionV0(
-        tokenTransaction,
-        signingOperators,
-        outputsToSpendSigningPublicKeys,
-        outputsToSpendCommitments
-      );
-    } else {
-      return this.broadcastTokenTransactionV1(
-        tokenTransaction,
-        signingOperators,
-        outputsToSpendSigningPublicKeys,
-        outputsToSpendCommitments
-      );
-    }
-  }
-  async broadcastTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
-    const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransactionV0(
-      tokenTransaction,
-      signingOperators,
-      outputsToSpendSigningPublicKeys,
-      outputsToSpendCommitments
-    );
-    const { successfulSignatures } = await this.signTokenTransactionV0(
-      finalTokenTransaction,
-      finalTokenTransactionHash,
-      signingOperators
-    );
-    if (finalTokenTransaction.tokenInputs.$case === "transferInput") {
-      const outputsToSpend = finalTokenTransaction.tokenInputs.transferInput.outputsToSpend;
-      const errors = [];
-      const revocationSecrets = [];
-      for (let outputIndex = 0; outputIndex < outputsToSpend.length; outputIndex++) {
-        const outputKeyshares = successfulSignatures.map(({ identifier, response }) => ({
-          operatorIndex: parseInt(identifier, 16),
-          keyshare: response.revocationKeyshares[outputIndex]
-        }));
-        if (outputKeyshares.length < threshold) {
-          errors.push(
-            new ValidationError("Insufficient keyshares", {
-              field: "outputKeyshares",
-              value: outputKeyshares.length,
-              expected: threshold,
-              index: outputIndex
-            })
-          );
-        }
-        const seenIndices = /* @__PURE__ */ new Set();
-        for (const { operatorIndex } of outputKeyshares) {
-          if (seenIndices.has(operatorIndex)) {
-            errors.push(
-              new ValidationError("Duplicate operator index", {
-                field: "outputKeyshares",
-                value: operatorIndex,
-                expected: "Unique operator index",
-                index: outputIndex
-              })
-            );
-          }
-          seenIndices.add(operatorIndex);
-        }
-        const revocationSecret = recoverRevocationSecretFromKeyshares(
-          outputKeyshares,
-          threshold
-        );
-        const derivedRevocationCommitment = import_secp256k112.secp256k1.getPublicKey(
-          revocationSecret,
-          true
-        );
-        if (!outputsToSpendCommitments || !outputsToSpendCommitments[outputIndex] || !derivedRevocationCommitment.every(
-          (byte, i) => byte === outputsToSpendCommitments[outputIndex][i]
-        )) {
-          errors.push(
-            new InternalValidationError(
-              "Revocation commitment verification failed",
-              {
-                field: "revocationCommitment",
-                value: derivedRevocationCommitment,
-                expected: (0, import_utils16.bytesToHex)(outputsToSpendCommitments[outputIndex]),
-                outputIndex
-              }
-            )
-          );
-        }
-        revocationSecrets.push({
-          inputIndex: outputIndex,
-          revocationSecret
-        });
-      }
-      if (errors.length > 0) {
-        throw new ValidationError(
-          "Multiple validation errors occurred across outputs",
-          {
-            field: "outputValidation",
-            value: errors
-          }
-        );
-      }
-      await this.finalizeTokenTransaction(
-        finalTokenTransaction,
-        revocationSecrets,
-        threshold
-      );
-    }
-    return (0, import_utils16.bytesToHex)(finalTokenTransactionHash);
-  }
-  async broadcastTokenTransactionV1(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
       tokenTransaction,
       signingOperators,
@@ -30132,101 +29996,6 @@ var TokenTransactionService = class {
     );
     return (0, import_utils16.bytesToHex)(finalTokenTransactionHash);
   }
-  async startTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    const partialTokenTransactionHash = hashTokenTransactionV0(
-      tokenTransaction,
-      true
-    );
-    const ownerSignaturesWithIndex = [];
-    if (tokenTransaction.tokenInputs.$case === "mintInput") {
-      const issuerPublicKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-      if (!issuerPublicKey) {
-        throw new ValidationError("Invalid mint input", {
-          field: "issuerPublicKey",
-          value: null,
-          expected: "Non-null issuer public key"
-        });
-      }
-      const ownerSignature = await this.signMessageWithKey(
-        partialTokenTransactionHash,
-        issuerPublicKey
-      );
-      ownerSignaturesWithIndex.push({
-        signature: ownerSignature,
-        inputIndex: 0
-      });
-    } else if (tokenTransaction.tokenInputs.$case === "transferInput") {
-      if (!outputsToSpendSigningPublicKeys || !outputsToSpendCommitments) {
-        throw new ValidationError("Invalid transfer input", {
-          field: "outputsToSpend",
-          value: {
-            signingPublicKeys: outputsToSpendSigningPublicKeys,
-            revocationPublicKeys: outputsToSpendCommitments
-          },
-          expected: "Non-null signing and revocation public keys"
-        });
-      }
-      for (const [i, key] of outputsToSpendSigningPublicKeys.entries()) {
-        if (!key) {
-          throw new ValidationError("Invalid signing key", {
-            field: "outputsToSpendSigningPublicKeys",
-            value: i,
-            expected: "Non-null signing key"
-          });
-        }
-        const ownerSignature = await this.signMessageWithKey(
-          partialTokenTransactionHash,
-          key
-        );
-        ownerSignaturesWithIndex.push({
-          signature: ownerSignature,
-          inputIndex: i
-        });
-      }
-    }
-    const startResponse = await sparkClient.start_token_transaction(
-      {
-        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        partialTokenTransaction: tokenTransaction,
-        tokenTransactionSignatures: {
-          ownerSignatures: ownerSignaturesWithIndex
-        }
-      },
-      {
-        retry: true,
-        retryableStatuses: ["UNKNOWN", "UNAVAILABLE", "CANCELLED", "INTERNAL"],
-        retryMaxAttempts: 3
-      }
-    );
-    if (!startResponse.finalTokenTransaction) {
-      throw new Error("Final token transaction missing in start response");
-    }
-    if (!startResponse.keyshareInfo) {
-      throw new Error("Keyshare info missing in start response");
-    }
-    validateTokenTransactionV0(
-      startResponse.finalTokenTransaction,
-      tokenTransaction,
-      signingOperators,
-      startResponse.keyshareInfo,
-      this.config.getExpectedWithdrawBondSats(),
-      this.config.getExpectedWithdrawRelativeBlockLocktime(),
-      this.config.getThreshold()
-    );
-    const finalTokenTransaction = startResponse.finalTokenTransaction;
-    const finalTokenTransactionHash = hashTokenTransactionV0(
-      finalTokenTransaction,
-      false
-    );
-    return {
-      finalTokenTransaction,
-      finalTokenTransactionHash,
-      threshold: startResponse.keyshareInfo.threshold
-    };
-  }
   async startTokenTransaction(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkTokenClient(
       this.config.getCoordinatorAddress()
@@ -30346,103 +30115,6 @@ var TokenTransactionService = class {
       threshold: startResponse.keyshareInfo.threshold
     };
   }
-  async signTokenTransactionV0(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
-    const soSignatures = await Promise.allSettled(
-      Object.entries(signingOperators).map(
-        async ([identifier, operator], index) => {
-          const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
-          const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-          const payload = {
-            finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
-          };
-          const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
-          let operatorSpecificSignatures = [];
-          if (finalTokenTransaction.tokenInputs.$case === "mintInput") {
-            const issuerPublicKey = finalTokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-            if (!issuerPublicKey) {
-              throw new ValidationError("Invalid mint input", {
-                field: "issuerPublicKey",
-                value: null,
-                expected: "Non-null issuer public key"
-              });
-            }
-            const ownerSignature = await this.signMessageWithKey(
-              payloadHash,
-              issuerPublicKey
-            );
-            operatorSpecificSignatures.push({
-              ownerSignature: {
-                signature: ownerSignature,
-                inputIndex: 0
-              },
-              payload
-            });
-          }
-          if (finalTokenTransaction.tokenInputs.$case === "transferInput") {
-            const transferInput = finalTokenTransaction.tokenInputs.transferInput;
-            for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
-              let ownerSignature;
-              if (this.config.getTokenSignatures() === "SCHNORR") {
-                ownerSignature = await this.config.signer.signSchnorrWithIdentityKey(
-                  payloadHash
-                );
-              } else {
-                ownerSignature = await this.config.signer.signMessageWithIdentityKey(
-                  payloadHash
-                );
-              }
-              operatorSpecificSignatures.push({
-                ownerSignature: {
-                  signature: ownerSignature,
-                  inputIndex: i
-                },
-                payload
-              });
-            }
-          }
-          try {
-            const response = await internalSparkClient.sign_token_transaction(
-              {
-                finalTokenTransaction,
-                operatorSpecificSignatures,
-                identityPublicKey
-              },
-              {
-                retry: true,
-                retryableStatuses: [
-                  "UNKNOWN",
-                  "UNAVAILABLE",
-                  "CANCELLED",
-                  "INTERNAL"
-                ],
-                retryMaxAttempts: 3
-              }
-            );
-            return {
-              index,
-              identifier,
-              response
-            };
-          } catch (error) {
-            throw new NetworkError(
-              "Failed to sign token transaction",
-              {
-                operation: "sign_token_transaction",
-                errorCount: 1,
-                errors: error instanceof Error ? error.message : String(error)
-              },
-              error
-            );
-          }
-        }
-      )
-    );
-    const successfulSignatures = collectResponses(soSignatures);
-    return {
-      successfulSignatures
-    };
-  }
   async signTokenTransaction(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
     const coordinatorClient = await this.connectionManager.createSparkTokenClient(
       this.config.getCoordinatorAddress()
@@ -30514,54 +30186,6 @@ var TokenTransactionService = class {
         );
       }
     }
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      return this.fetchOwnedTokenOutputsV0(params);
-    } else {
-      return this.fetchOwnedTokenOutputsV1(params);
-    }
-  }
-  async queryTokenTransactions(params) {
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      return this.queryTokenTransactionsV0(params);
-    } else {
-      return this.queryTokenTransactionsV1(params);
-    }
-  }
-  async fetchOwnedTokenOutputsV0(params) {
-    const {
-      ownerPublicKeys,
-      issuerPublicKeys: tokenPublicKeys = [],
-      tokenIdentifiers = []
-    } = params;
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    try {
-      const result = await sparkClient.query_token_outputs({
-        ownerPublicKeys,
-        tokenPublicKeys,
-        tokenIdentifiers,
-        network: this.config.getNetworkProto()
-      });
-      return result.outputsWithPreviousTransactionData;
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to fetch owned token outputs",
-        {
-          operation: "spark.query_token_outputs",
-          errorCount: 1,
-          errors: error instanceof Error ? error.message : String(error)
-        },
-        error
-      );
-    }
-  }
-  async fetchOwnedTokenOutputsV1(params) {
-    const {
-      ownerPublicKeys,
-      issuerPublicKeys = [],
-      tokenIdentifiers = []
-    } = params;
     const tokenClient = await this.connectionManager.createSparkTokenClient(
       this.config.getCoordinatorAddress()
     );
@@ -30602,75 +30226,7 @@ var TokenTransactionService = class {
       );
     }
   }
-  async queryTokenTransactionsV0(params) {
-    const {
-      ownerPublicKeys,
-      issuerPublicKeys,
-      tokenTransactionHashes,
-      tokenIdentifiers,
-      outputIds,
-      pageSize,
-      offset
-    } = params;
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    let queryParams = {
-      tokenPublicKeys: issuerPublicKeys?.map(import_utils17.hexToBytes),
-      ownerPublicKeys: ownerPublicKeys?.map(import_utils17.hexToBytes),
-      tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
-        const { tokenIdentifier } = decodeBech32mTokenIdentifier(
-          identifier,
-          this.config.getNetworkType()
-        );
-        return tokenIdentifier;
-      }),
-      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils17.hexToBytes),
-      outputIds: outputIds || [],
-      limit: pageSize,
-      offset
-    };
-    try {
-      const response = await sparkClient.query_token_transactions(queryParams);
-      return {
-        tokenTransactionsWithStatus: response.tokenTransactionsWithStatus.map(
-          (tx) => {
-            const v1TokenTransaction = {
-              version: 1,
-              network: tx.tokenTransaction.network,
-              tokenInputs: tx.tokenTransaction.tokenInputs,
-              tokenOutputs: tx.tokenTransaction.tokenOutputs,
-              sparkOperatorIdentityPublicKeys: tx.tokenTransaction.sparkOperatorIdentityPublicKeys,
-              expiryTime: void 0,
-              // V0 doesn't have expiry time
-              clientCreatedTimestamp: tx.tokenTransaction?.tokenInputs?.$case === "mintInput" ? new Date(
-                tx.tokenTransaction.tokenInputs.mintInput.issuerProvidedTimestamp * 1e3
-              ) : /* @__PURE__ */ new Date(),
-              invoiceAttachments: []
-            };
-            return {
-              tokenTransaction: v1TokenTransaction,
-              status: tx.status,
-              confirmationMetadata: tx.confirmationMetadata,
-              tokenTransactionHash: tx.tokenTransactionHash
-            };
-          }
-        ),
-        offset: response.offset
-      };
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to query token transactions",
-        {
-          operation: "spark.query_token_transactions",
-          errorCount: 1,
-          errors: error instanceof Error ? error.message : String(error)
-        },
-        error
-      );
-    }
-  }
-  async queryTokenTransactionsV1(params) {
+  async queryTokenTransactions(params) {
     const {
       ownerPublicKeys,
       issuerPublicKeys,
@@ -30783,50 +30339,6 @@ var TokenTransactionService = class {
       });
     }
   }
-  async finalizeTokenTransaction(finalTokenTransaction, revocationSecrets, threshold) {
-    const signingOperators = this.config.getSigningOperators();
-    const soResponses = await Promise.allSettled(
-      Object.entries(signingOperators).map(async ([identifier, operator]) => {
-        const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
-        const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-        try {
-          const response = await internalSparkClient.finalize_token_transaction(
-            {
-              finalTokenTransaction,
-              revocationSecrets,
-              identityPublicKey
-            },
-            {
-              retry: true,
-              retryableStatuses: [
-                "UNKNOWN",
-                "UNAVAILABLE",
-                "CANCELLED",
-                "INTERNAL"
-              ],
-              retryMaxAttempts: 3
-            }
-          );
-          return {
-            identifier,
-            response
-          };
-        } catch (error) {
-          throw new NetworkError(
-            "Failed to finalize token transaction",
-            {
-              operation: "finalize_token_transaction",
-              errorCount: 1,
-              errors: error instanceof Error ? error.message : String(error)
-            },
-            error
-          );
-        }
-      })
-    );
-    collectResponses(soResponses);
-    return finalTokenTransaction;
-  }
   async createSignaturesForOperators(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
     const inputTtxoSignaturesPerOperator = [];
     for (const [_, operator] of Object.entries(signingOperators)) {
@@ -30903,29 +30415,26 @@ var TokenTransactionService = class {
     return inputTtxoSignaturesPerOperator;
   }
 };
-function isTokenTransaction(tokenTransaction) {
-  return "version" in tokenTransaction && "expiryTime" in tokenTransaction;
-}
 
 // src/utils/adaptor-signature.ts
 init_buffer();
 var import_modular = require("@noble/curves/abstract/modular");
-var import_secp256k113 = require("@noble/curves/secp256k1");
+var import_secp256k111 = require("@noble/curves/secp256k1");
 var import_utils18 = require("@noble/curves/utils");
 function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
   const { r, s: s2 } = parseSignature(signature);
   const sBigInt = (0, import_utils18.bytesToNumberBE)(s2);
   const tBigInt = (0, import_utils18.bytesToNumberBE)(adaptorPrivateKeyBytes);
-  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k113.secp256k1.CURVE.n);
+  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k111.secp256k1.CURVE.n);
   const newSignature = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(newS, 32)]);
   return newSignature;
 }
 function generateAdaptorFromSignature(signature) {
-  const adaptorPrivateKey = import_secp256k113.secp256k1.utils.randomPrivateKey();
+  const adaptorPrivateKey = import_secp256k111.secp256k1.utils.randomPrivateKey();
   const { r, s: s2 } = parseSignature(signature);
   const sBigInt = (0, import_utils18.bytesToNumberBE)(s2);
   const tBigInt = (0, import_utils18.bytesToNumberBE)(adaptorPrivateKey);
-  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k113.secp256k1.CURVE.n);
+  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k111.secp256k1.CURVE.n);
   const newSignature = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(newS, 32)]);
   return {
     adaptorSignature: newSignature,
@@ -30945,19 +30454,19 @@ function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes
   const { r, s: s2 } = parseSignature(signature);
   const sBigInt = (0, import_utils18.bytesToNumberBE)(s2);
   const adaptorPrivateKey = (0, import_utils18.bytesToNumberBE)(adaptorPrivateKeyBytes);
-  const newS = (0, import_modular.mod)(sBigInt + adaptorPrivateKey, import_secp256k113.secp256k1.CURVE.n);
+  const newS = (0, import_modular.mod)(sBigInt + adaptorPrivateKey, import_secp256k111.secp256k1.CURVE.n);
   const newSig = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(newS, 32)]);
   try {
-    if (import_secp256k113.schnorr.verify(newSig, hash, pubkey)) {
+    if (import_secp256k111.schnorr.verify(newSig, hash, pubkey)) {
       return newSig;
     }
   } catch (e) {
     console.error("[applyAdaptorToSignature] Addition verification failed:", e);
   }
-  const altS = (0, import_modular.mod)(sBigInt - adaptorPrivateKey, import_secp256k113.secp256k1.CURVE.n);
+  const altS = (0, import_modular.mod)(sBigInt - adaptorPrivateKey, import_secp256k111.secp256k1.CURVE.n);
   const altSig = new Uint8Array([...r, ...(0, import_utils18.numberToBytesBE)(altS, 32)]);
   try {
-    if (import_secp256k113.schnorr.verify(altSig, hash, pubkey)) {
+    if (import_secp256k111.schnorr.verify(altSig, hash, pubkey)) {
       return altSig;
     }
   } catch (e) {
@@ -30972,10 +30481,10 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   if (hash.length !== 32) {
     throw new Error(`wrong size for message (got ${hash.length}, want 32)`);
   }
-  const pubKey = import_secp256k113.schnorr.utils.lift_x((0, import_utils18.bytesToNumberBE)(pubKeyBytes));
+  const pubKey = import_secp256k111.schnorr.utils.lift_x((0, import_utils18.bytesToNumberBE)(pubKeyBytes));
   pubKey.assertValidity();
   const { r, s: s2 } = parseSignature(signature);
-  const commitmenet = import_secp256k113.schnorr.utils.taggedHash(
+  const commitmenet = import_secp256k111.schnorr.utils.taggedHash(
     "BIP0340/challenge",
     r,
     pubKey.toBytes().slice(1),
@@ -30984,18 +30493,18 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   if (commitmenet.length > 32) {
     throw new Error("hash of (r || P || m) too big");
   }
-  const e = (0, import_modular.mod)((0, import_utils18.bytesToNumberBE)(commitmenet), import_secp256k113.secp256k1.CURVE.n);
-  const negE = (0, import_modular.mod)(-e, import_secp256k113.secp256k1.CURVE.n);
-  const sG = import_secp256k113.secp256k1.Point.BASE.multiplyUnsafe((0, import_utils18.bytesToNumberBE)(s2));
+  const e = (0, import_modular.mod)((0, import_utils18.bytesToNumberBE)(commitmenet), import_secp256k111.secp256k1.CURVE.n);
+  const negE = (0, import_modular.mod)(-e, import_secp256k111.secp256k1.CURVE.n);
+  const sG = import_secp256k111.secp256k1.Point.BASE.multiplyUnsafe((0, import_utils18.bytesToNumberBE)(s2));
   const eP = pubKey.multiplyUnsafe(negE);
   const R = sG.add(eP);
   if (R.is0()) {
     throw new Error("R is zero");
   }
   R.assertValidity();
-  const adaptorPoint = import_secp256k113.secp256k1.Point.fromHex(adaptorPubkey);
+  const adaptorPoint = import_secp256k111.secp256k1.Point.fromHex(adaptorPubkey);
   const newR = R.add(adaptorPoint);
-  if (!inbound && newR.equals(import_secp256k113.secp256k1.Point.ZERO)) {
+  if (!inbound && newR.equals(import_secp256k111.secp256k1.Point.ZERO)) {
     throw new Error("calculated R point is the point at infinity");
   }
   newR.assertValidity();
@@ -31023,16 +30532,16 @@ function parseSignature(signature) {
   }
   const r = signature.slice(0, 32);
   const s2 = signature.slice(32, 64);
-  if ((0, import_utils18.bytesToNumberBE)(r) >= import_secp256k113.secp256k1.CURVE.Fp.ORDER) {
+  if ((0, import_utils18.bytesToNumberBE)(r) >= import_secp256k111.secp256k1.CURVE.Fp.ORDER) {
     throw new ValidationError("Invalid signature: r >= field prime", {
       rValue: (0, import_utils18.bytesToNumberBE)(r),
-      fieldPrime: import_secp256k113.secp256k1.CURVE.Fp.ORDER
+      fieldPrime: import_secp256k111.secp256k1.CURVE.Fp.ORDER
     });
   }
-  if ((0, import_utils18.bytesToNumberBE)(s2) >= import_secp256k113.secp256k1.CURVE.n) {
+  if ((0, import_utils18.bytesToNumberBE)(s2) >= import_secp256k111.secp256k1.CURVE.n) {
     throw new ValidationError("Invalid signature: s >= group order", {
       sValue: (0, import_utils18.bytesToNumberBE)(s2),
-      groupOrder: import_secp256k113.secp256k1.CURVE.n
+      groupOrder: import_secp256k111.secp256k1.CURVE.n
     });
   }
   return { r, s: s2 };
@@ -31213,7 +30722,7 @@ var SigningService = class {
 
 // src/tests/utils/test-faucet.ts
 init_buffer();
-var import_secp256k114 = require("@noble/curves/secp256k1");
+var import_secp256k112 = 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");
@@ -31234,7 +30743,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     this.username = username;
     this.password = password;
     this.miningAddress = getP2TRAddressFromPublicKey(
-      import_secp256k114.secp256k1.getPublicKey(STATIC_MINING_KEY),
+      import_secp256k112.secp256k1.getPublicKey(STATIC_MINING_KEY),
       4 /* LOCAL */
     );
   }
@@ -31273,7 +30782,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     });
   }
   async refill() {
-    const minerPubKey = import_secp256k114.secp256k1.getPublicKey(STATIC_MINING_KEY);
+    const minerPubKey = import_secp256k112.secp256k1.getPublicKey(STATIC_MINING_KEY);
     const address2 = getP2TRAddressFromPublicKey(minerPubKey, 4 /* LOCAL */);
     const scanResult = await this.call("scantxoutset", [
       "start",
@@ -31322,7 +30831,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       txid: selectedUtxo.txid,
       index: selectedUtxo.vout
     });
-    const faucetPubKey = import_secp256k114.secp256k1.getPublicKey(STATIC_FAUCET_KEY);
+    const faucetPubKey = import_secp256k112.secp256k1.getPublicKey(STATIC_FAUCET_KEY);
     const script = getP2TRScriptFromPublicKey(faucetPubKey, 4 /* LOCAL */);
     for (let i = 0; i < numCoinsToCreate; i++) {
       splitTx.addOutput({
@@ -31383,7 +30892,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     await this.broadcastTx((0, import_utils20.bytesToHex)(signedTx.extract()));
   }
   async signFaucetCoin(unsignedTx, fundingTxOut, key) {
-    const pubKey = import_secp256k114.secp256k1.getPublicKey(key);
+    const pubKey = import_secp256k112.secp256k1.getPublicKey(key);
     const internalKey = pubKey.slice(1);
     const script = getP2TRScriptFromPublicKey(pubKey, 4 /* LOCAL */);
     unsignedTx.updateInput(0, {
@@ -31403,7 +30912,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     const tweakedKey = (0, import_utils21.taprootTweakPrivKey)(key, merkleRoot);
     if (!tweakedKey)
       throw new Error("Invalid private key for taproot tweaking");
-    const signature = import_secp256k114.schnorr.sign(sighash, tweakedKey);
+    const signature = import_secp256k112.schnorr.sign(sighash, tweakedKey);
     unsignedTx.updateInput(0, {
       tapKeySig: signature
     });
@@ -31466,8 +30975,8 @@ var BitcoinFaucet = class _BitcoinFaucet {
     return response;
   }
   async getNewAddress() {
-    const key = import_secp256k114.secp256k1.utils.randomPrivateKey();
-    const pubKey = import_secp256k114.secp256k1.getPublicKey(key);
+    const key = import_secp256k112.secp256k1.utils.randomPrivateKey();
+    const pubKey = import_secp256k112.secp256k1.getPublicKey(key);
     return getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */);
   }
   async sendToAddress(address2, amount, blocksToGenerate = 1) {
@@ -31488,8 +30997,8 @@ var BitcoinFaucet = class _BitcoinFaucet {
     });
     const changeAmount = availableAmount - amount;
     if (changeAmount > 0) {
-      const changeKey = import_secp256k114.secp256k1.utils.randomPrivateKey();
-      const changePubKey = import_secp256k114.secp256k1.getPublicKey(changeKey);
+      const changeKey = import_secp256k112.secp256k1.utils.randomPrivateKey();
+      const changePubKey = import_secp256k112.secp256k1.getPublicKey(changeKey);
       const changeScript = getP2TRScriptFromPublicKey(
         changePubKey,
         4 /* LOCAL */
@@ -31502,8 +31011,8 @@ var BitcoinFaucet = class _BitcoinFaucet {
     const signedTx = await this.signFaucetCoin(tx, coin.txout, coin.key);
     const txHex = (0, import_utils20.bytesToHex)(signedTx.extract());
     await this.broadcastTx(txHex);
-    const randomKey = import_secp256k114.secp256k1.utils.randomPrivateKey();
-    const randomPubKey = import_secp256k114.secp256k1.getPublicKey(randomKey);
+    const randomKey = import_secp256k112.secp256k1.utils.randomPrivateKey();
+    const randomPubKey = import_secp256k112.secp256k1.getPublicKey(randomKey);
     const randomAddress = getP2TRAddressFromPublicKey(
       randomPubKey,
       4 /* LOCAL */
@@ -32170,47 +31679,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     senderPublicKey,
     expiryTime
   }) {
-    const MAX_SATS_AMOUNT = 21e14;
-    if (amount && (amount < 0 || amount > MAX_SATS_AMOUNT)) {
-      throw new ValidationError(
-        `Amount must be between 0 and ${MAX_SATS_AMOUNT} sats`,
-        {
-          field: "amount",
-          value: amount,
-          expected: `less than or equal to ${MAX_SATS_AMOUNT}`
-        }
-      );
-    }
-    const protoPayment = {
-      $case: "satsPayment",
-      satsPayment: {
-        amount
-      }
-    };
-    const invoiceFields = {
-      version: 1,
-      id: (0, import_uuidv75.uuidv7obj)().bytes,
-      paymentType: protoPayment,
-      memo,
-      senderPublicKey: senderPublicKey ? (0, import_utils23.hexToBytes)(senderPublicKey) : void 0,
-      expiryTime: expiryTime ?? void 0
-    };
-    validateSparkInvoiceFields(invoiceFields);
-    const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const hash = HashSparkInvoice(
-      invoiceFields,
-      identityPublicKey,
-      this.config.getNetworkType()
-    );
-    const signature = await this.config.signer.signSchnorrWithIdentityKey(hash);
-    return encodeSparkAddressWithSignature(
-      {
-        identityPublicKey: (0, import_utils23.bytesToHex)(identityPublicKey),
-        network: this.config.getNetworkType(),
-        sparkInvoiceFields: invoiceFields
-      },
-      signature
-    );
+    throw new NotImplementedError("Invoice functionality is not enabled");
   }
   /**
    * Creates a Spark invoice for a tokens payment on Spark.
@@ -32230,52 +31699,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     senderPublicKey,
     expiryTime
   }) {
-    const MAX_UINT128 = BigInt(2 ** 128 - 1);
-    if (amount && (amount < 0 || amount > MAX_UINT128)) {
-      throw new ValidationError(`Amount must be between 0 and ${MAX_UINT128}`, {
-        field: "amount",
-        value: amount,
-        expected: `greater than or equal to 0 and less than or equal to ${MAX_UINT128}`
-      });
-    }
-    let decodedTokenIdentifier = void 0;
-    if (tokenIdentifier) {
-      decodedTokenIdentifier = decodeBech32mTokenIdentifier(
-        tokenIdentifier,
-        this.config.getNetworkType()
-      ).tokenIdentifier;
-    }
-    const protoPayment = {
-      $case: "tokensPayment",
-      tokensPayment: {
-        tokenIdentifier: decodedTokenIdentifier ?? void 0,
-        amount: amount ? (0, import_utils23.numberToVarBytesBE)(amount) : void 0
-      }
-    };
-    const invoiceFields = {
-      version: 1,
-      id: (0, import_uuidv75.uuidv7obj)().bytes,
-      paymentType: protoPayment,
-      memo: memo ?? void 0,
-      senderPublicKey: senderPublicKey ? (0, import_utils23.hexToBytes)(senderPublicKey) : void 0,
-      expiryTime: expiryTime ?? void 0
-    };
-    validateSparkInvoiceFields(invoiceFields);
-    const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const hash = HashSparkInvoice(
-      invoiceFields,
-      identityPublicKey,
-      this.config.getNetworkType()
-    );
-    const signature = await this.config.signer.signSchnorrWithIdentityKey(hash);
-    return encodeSparkAddressWithSignature(
-      {
-        identityPublicKey: (0, import_utils23.bytesToHex)(identityPublicKey),
-        network: this.config.getNetworkType(),
-        sparkInvoiceFields: invoiceFields
-      },
-      signature
-    );
+    throw new NotImplementedError("Invoice functionality is not enabled");
   }
   /**
    * Initializes the wallet using either a mnemonic phrase or a raw seed.
@@ -32600,7 +32024,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       }
       const sspClient = this.getSspClient();
       const cpfpAdaptorPubkey = (0, import_utils23.bytesToHex)(
-        import_secp256k115.secp256k1.getPublicKey(cpfpAdaptorPrivateKey)
+        import_secp256k113.secp256k1.getPublicKey(cpfpAdaptorPrivateKey)
       );
       if (!cpfpAdaptorPubkey) {
         throw new Error("Failed to generate CPFP adaptor pubkey");
@@ -32608,13 +32032,13 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       let directAdaptorPubkey;
       if (directAdaptorPrivateKey.length > 0) {
         directAdaptorPubkey = (0, import_utils23.bytesToHex)(
-          import_secp256k115.secp256k1.getPublicKey(directAdaptorPrivateKey)
+          import_secp256k113.secp256k1.getPublicKey(directAdaptorPrivateKey)
         );
       }
       let directFromCpfpAdaptorPubkey;
       if (directFromCpfpAdaptorPrivateKey.length > 0) {
         directFromCpfpAdaptorPubkey = (0, import_utils23.bytesToHex)(
-          import_secp256k115.secp256k1.getPublicKey(directFromCpfpAdaptorPrivateKey)
+          import_secp256k113.secp256k1.getPublicKey(directFromCpfpAdaptorPrivateKey)
         );
       }
       let request = null;
@@ -34229,10 +33653,23 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       if (!invoice2) {
         throw new Error("Failed to create lightning invoice");
       }
+      const decodedInvoice = decodeInvoice(invoice2.invoice.encodedInvoice);
+      if (invoice2.invoice.paymentHash !== (0, import_utils23.bytesToHex)(paymentHash) || decodedInvoice.paymentHash !== (0, import_utils23.bytesToHex)(paymentHash)) {
+        throw new ValidationError("Payment hash mismatch", {
+          field: "paymentHash",
+          value: invoice2.invoice.paymentHash,
+          expected: (0, import_utils23.bytesToHex)(paymentHash)
+        });
+      }
+      if (decodedInvoice.amountMSats !== BigInt(amountSats2 * 1e3)) {
+        throw new ValidationError("Amount mismatch", {
+          field: "amountMSats",
+          value: decodedInvoice.amountMSats,
+          expected: amountSats2 * 1e3
+        });
+      }
       if (includeSparkAddress) {
-        const sparkFallbackAddress = decodeInvoice(
-          invoice2.invoice.encodedInvoice
-        ).fallbackAddress;
+        const sparkFallbackAddress = decodedInvoice.fallbackAddress;
         if (!sparkFallbackAddress) {
           throw new ValidationError(
             "No spark fallback address found in lightning invoice",
@@ -34254,6 +33691,14 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
             }
           );
         }
+      } else if (decodedInvoice.fallbackAddress !== void 0) {
+        throw new ValidationError(
+          "Spark fallback address found in lightning invoice but includeSparkAddress is false",
+          {
+            field: "sparkFallbackAddress",
+            value: decodedInvoice.fallbackAddress
+          }
+        );
       }
       return invoice2;
     };
@@ -34421,91 +33866,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     });
   }
   async fulfillSparkInvoice(sparkInvoices) {
-    if (!Array.isArray(sparkInvoices) || sparkInvoices.length === 0) {
-      throw new ValidationError("No Spark invoices provided", {
-        field: "sparkInvoices",
-        value: sparkInvoices,
-        expected: "Non-empty array"
-      });
-    }
-    const satsTransactionSuccess = [];
-    const satsTransactionErrors = [];
-    const tokenTransactionSuccess = [];
-    const tokenTransactionErrors = [];
-    const { satsInvoices, tokenInvoices, invalidInvoices } = await this.groupSparkInvoicesByPaymentType(sparkInvoices);
-    if (invalidInvoices.length > 0) {
-      return {
-        satsTransactionSuccess,
-        satsTransactionErrors,
-        tokenTransactionSuccess,
-        tokenTransactionErrors,
-        invalidInvoices
-      };
-    }
-    if (tokenInvoices.size > 0) {
-      await this.syncTokenOutputs();
-      const tokenTransferTasks = [];
-      for (const [identifierHex, decodedInvoices] of tokenInvoices.entries()) {
-        const tokenIdentifier = (0, import_utils23.hexToBytes)(identifierHex);
-        const tokenIdB32 = encodeBech32mTokenIdentifier({
-          tokenIdentifier,
-          network: this.config.getNetworkType()
-        });
-        const receiverOutputs = decodedInvoices.map((d) => ({
-          tokenIdentifier: tokenIdB32,
-          tokenAmount: d.amount,
-          receiverSparkAddress: d.invoice
-        }));
-        tokenTransferTasks.push(
-          this.tokenTransactionService.tokenTransfer({ tokenOutputs: this.tokenOutputs, receiverOutputs }).then((txid) => ({
-            ok: true,
-            tokenIdentifier: tokenIdB32,
-            txid
-          })).catch((e) => ({
-            ok: false,
-            tokenIdentifier: tokenIdB32,
-            error: e instanceof Error ? e : new Error(String(e))
-          }))
-        );
-      }
-      const results = await Promise.all(tokenTransferTasks);
-      for (const r of results) {
-        if (r.ok) {
-          tokenTransactionSuccess.push({
-            tokenIdentifier: r.tokenIdentifier,
-            txid: r.txid
-          });
-        } else {
-          tokenTransactionErrors.push({
-            tokenIdentifier: r.tokenIdentifier,
-            error: r.error
-          });
-        }
-      }
-    }
-    if (satsInvoices.length > 0) {
-      const transfers = await this.transferWithInvoice(satsInvoices);
-      for (const transfer of transfers) {
-        if (transfer.ok) {
-          satsTransactionSuccess.push({
-            invoice: transfer.param.sparkInvoice ?? "",
-            transferResponse: transfer.transfer
-          });
-        } else {
-          satsTransactionErrors.push({
-            invoice: transfer.param.sparkInvoice ?? "",
-            error: transfer.error
-          });
-        }
-      }
-    }
-    return {
-      satsTransactionSuccess,
-      satsTransactionErrors,
-      tokenTransactionSuccess,
-      tokenTransactionErrors,
-      invalidInvoices
-    };
+    throw new NotImplementedError("Invoice functionality is not enabled");
   }
   async groupSparkInvoicesByPaymentType(sparkInvoices) {
     const satsInvoices = [];
@@ -34642,6 +34003,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     });
     return { satsInvoices, tokenInvoices, invalidInvoices };
   }
+  async querySparkInvoices(invoices) {
+    throw new NotImplementedError("Invoice functionality is not enabled");
+  }
   /**
    * Gets fee estimate for sending Lightning payments.
    *
@@ -35674,6 +35038,7 @@ __export(utils_exports, {
   addPublicKeys: () => addPublicKeys,
   applyAdaptorToSignature: () => applyAdaptorToSignature,
   applyAdditiveTweakToPublicKey: () => applyAdditiveTweakToPublicKey,
+  assertBech32: () => assertBech32,
   bech32mDecode: () => bech32mDecode,
   bigIntToPrivateKey: () => bigIntToPrivateKey,
   checkIfSelectedOutputsAreAvailable: () => checkIfSelectedOutputsAreAvailable,
@@ -35736,6 +35101,7 @@ __export(utils_exports, {
   getTxId: () => getTxId,
   getTxIdNoReverse: () => getTxIdNoReverse,
   isEphemeralAnchorOutput: () => isEphemeralAnchorOutput,
+  isLegacySparkAddress: () => isLegacySparkAddress,
   isSafeForNumber: () => isSafeForNumber,
   isTxBroadcast: () => isTxBroadcast,
   isValidPublicKey: () => isValidPublicKey,
@@ -35813,6 +35179,28 @@ async function isTxBroadcast(txid, baseUrl, network) {
   return true;
 }
 
+// src/utils/response-validation.ts
+init_buffer();
+function collectResponses(responses) {
+  const successfulResponses = responses.filter(
+    (result) => result.status === "fulfilled"
+  ).map((result) => result.value);
+  const failedResponses = responses.filter(
+    (result) => result.status === "rejected"
+  );
+  if (failedResponses.length > 0) {
+    const errors = failedResponses.map((result) => result.reason).join("\n");
+    throw new NetworkError(
+      `${failedResponses.length} out of ${responses.length} requests failed, please try again`,
+      {
+        errorCount: failedResponses.length,
+        errors
+      }
+    );
+  }
+  return successfulResponses;
+}
+
 // src/utils/unilateral-exit.ts
 init_buffer();
 var import_utils24 = require("@noble/curves/utils");