@buildonspark/spark-sdk 0.1.39 → 0.1.41

package/dist/services/index.cjs

@@ -1663,11 +1663,10 @@ function getSigningCommitmentFromNonce(nonce) {
 }
 
 // src/signer/signer.ts
-var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
-var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
 var import_secp256k16 = require("@bitcoinerlab/secp256k1");
+var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
 var import_sha2 = require("@noble/hashes/sha2");
-var import_lrc20_sdk3 = require("@buildonspark/lrc20-sdk");
+var import_utils5 = require("@scure/btc-signer/utils");
 var sparkFrostModule = void 0;
 var getSparkFrostModule = async () => {
   if (isReactNative) {
@@ -1679,8 +1678,8 @@ var getSparkFrostModule = async () => {
   return sparkFrostModule;
 };
 var HARDENED_OFFSET = 2147483648;
-var DefaultHDKeyGenerator = class {
-  async deriveHDKeysFromSeed(seed, accountNumber) {
+var DefaultSparkKeysGenerator = class {
+  async deriveKeysFromSeed(seed, accountNumber) {
     const hdkey = import_bip32.HDKey.fromMasterSeed(seed);
     if (!hdkey.privateKey || !hdkey.publicKey) {
       throw new ValidationError("Failed to derive keys from seed", {
@@ -1701,27 +1700,21 @@ var DefaultHDKeyGenerator = class {
       );
     }
     return {
-      masterKey: {
-        hdKey: hdkey,
-        privateKey: hdkey.privateKey,
-        publicKey: hdkey.publicKey
-      },
+      masterPublicKey: hdkey.publicKey,
       identityKey: {
-        hdKey: identityKey,
         privateKey: identityKey.privateKey,
         publicKey: identityKey.publicKey
       },
-      signingKey: {
+      signingHDKey: {
         hdKey: signingKey,
         privateKey: signingKey.privateKey,
         publicKey: signingKey.publicKey
       },
       depositKey: {
-        hdKey: depositKey,
         privateKey: depositKey.privateKey,
         publicKey: depositKey.publicKey
       },
-      staticDepositKey: {
+      staticDepositHDKey: {
         hdKey: staticDepositKey,
         privateKey: staticDepositKey.privateKey,
         publicKey: staticDepositKey.publicKey
@@ -1730,7 +1723,7 @@ var DefaultHDKeyGenerator = class {
   }
 };
 var DefaultSparkSigner = class {
-  masterKey = null;
+  masterPublicKey = null;
   identityKey = null;
   signingKey = null;
   depositKey = null;
@@ -1739,14 +1732,16 @@ var DefaultSparkSigner = class {
   // <hex, hex>
   publicKeyToPrivateKeyMap = /* @__PURE__ */ new Map();
   commitmentToNonceMap = /* @__PURE__ */ new Map();
-  hdKeyGenerator;
-  constructor({ hdKeyGenerator } = {}) {
-    this.hdKeyGenerator = hdKeyGenerator ?? new DefaultHDKeyGenerator();
+  keysGenerator;
+  constructor({
+    sparkKeysGenerator
+  } = {}) {
+    this.keysGenerator = sparkKeysGenerator ?? new DefaultSparkKeysGenerator();
   }
   deriveSigningKey(hash) {
-    if (!this.masterKey) {
+    if (!this.signingKey) {
       throw new ValidationError("Private key not initialized", {
-        field: "masterKey"
+        field: "signingKey"
       });
     }
     const view = new DataView(hash.buffer);
@@ -1760,9 +1755,9 @@ var DefaultSparkSigner = class {
     return newPrivateKey;
   }
   async restoreSigningKeysFromLeafs(leafs) {
-    if (!this.masterKey) {
-      throw new ValidationError("Master key is not set", {
-        field: "masterKey"
+    if (!this.signingKey) {
+      throw new ValidationError("Signing key is not set", {
+        field: "signingKey"
       });
     }
     for (const leaf of leafs) {
@@ -1882,9 +1877,9 @@ var DefaultSparkSigner = class {
     return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(import_utils4.hexToBytes);
   }
   async generatePublicKey(hash) {
-    if (!this.masterKey) {
+    if (!this.signingKey) {
       throw new ValidationError("Private key is not set", {
-        field: "masterKey"
+        field: "signingKey"
       });
     }
     let newPrivateKey = null;
@@ -2020,10 +2015,16 @@ var DefaultSparkSigner = class {
     if (typeof seed === "string") {
       seed = (0, import_utils4.hexToBytes)(seed);
     }
-    const { masterKey, identityKey, signingKey, depositKey, staticDepositKey } = await this.hdKeyGenerator.deriveHDKeysFromSeed(seed, accountNumber ?? 0);
-    this.masterKey = masterKey.hdKey;
-    this.identityKey = identityKey.hdKey;
-    this.depositKey = depositKey.hdKey;
+    const {
+      masterPublicKey,
+      identityKey,
+      signingHDKey: signingKey,
+      depositKey,
+      staticDepositHDKey: staticDepositKey
+    } = await this.keysGenerator.deriveKeysFromSeed(seed, accountNumber ?? 0);
+    this.masterPublicKey = masterPublicKey;
+    this.identityKey = identityKey;
+    this.depositKey = depositKey;
     this.signingKey = signingKey.hdKey;
     this.staticDepositKey = staticDepositKey.hdKey;
     this.publicKeyToPrivateKeyMap.set(
@@ -2112,10 +2113,10 @@ var DefaultSparkSigner = class {
     };
   }
   async getMasterPublicKey() {
-    if (!this.masterKey?.publicKey) {
+    if (!this.masterPublicKey) {
       throw new Error("Private key is not set");
     }
-    return this.masterKey.publicKey;
+    return this.masterPublicKey;
   }
   async validateMessageWithIdentityKey(message, signature) {
     if (!this.identityKey?.publicKey) {
@@ -2133,16 +2134,16 @@ var DefaultSparkSigner = class {
     }
     if (receipt) {
       const receiptPrivateKey = this.getReceiptPrivateKey(receipt);
-      const tweakedKeyPair = (0, import_lrc20_sdk3.fromPrivateKey)(import_buffer.Buffer.from(receiptPrivateKey));
+      const tweakedKeyPair = (0, import_lrc20_sdk.fromPrivateKey)(import_buffer.Buffer.from(receiptPrivateKey));
       psbt.signInput(input, tweakedKeyPair, sighashTypes);
       return psbt;
     }
-    const keypair = (0, import_lrc20_sdk3.fromPrivateKey)(import_buffer.Buffer.from(this.identityKey.privateKey));
+    const keypair = (0, import_lrc20_sdk.fromPrivateKey)(import_buffer.Buffer.from(this.identityKey.privateKey));
     psbt.signInput(input, keypair, sighashTypes);
     return psbt;
   }
   getReceiptPrivateKey(receipt) {
-    const pxh = import_lrc20_sdk2.Receipt.receiptHash(receipt);
+    const pxh = import_lrc20_sdk.Receipt.receiptHash(receipt);
     let innerKey = this.identityKey.publicKey;
     let privateKey = this.identityKey.privateKey;
     if (innerKey[0] === 3) {
@@ -2153,11 +2154,30 @@ var DefaultSparkSigner = class {
     const receiptProof = (0, import_secp256k16.privateAdd)(privateKey, pxhPubkey);
     return import_buffer.Buffer.from(receiptProof);
   }
+  signTransactionIndex(tx, index, publicKey) {
+    let privateKey;
+    if ((0, import_utils4.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.identityKey?.privateKey;
+    } else if ((0, import_utils4.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.depositKey?.privateKey;
+    } else {
+      privateKey = (0, import_utils4.hexToBytes)(
+        this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey)) ?? ""
+      );
+    }
+    if (!privateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey",
+        value: (0, import_utils4.bytesToHex)(publicKey)
+      });
+    }
+    tx.signIdx(privateKey, index);
+  }
 };
 
 // src/utils/network.ts
 init_buffer();
-var import_lrc20_sdk4 = require("@buildonspark/lrc20-sdk");
+var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
 var btc = __toESM(require("@scure/btc-signer"), 1);
 var bitcoin = __toESM(require("bitcoinjs-lib"), 1);
 
@@ -2478,6 +2498,9 @@ function tokenTransactionStatusFromJSON(object) {
     case 1:
     case "TOKEN_TRANSACTION_SIGNED":
       return 1 /* TOKEN_TRANSACTION_SIGNED */;
+    case 5:
+    case "TOKEN_TRANSACTION_REVEALED":
+      return 5 /* TOKEN_TRANSACTION_REVEALED */;
     case 2:
     case "TOKEN_TRANSACTION_FINALIZED":
       return 2 /* TOKEN_TRANSACTION_FINALIZED */;
@@ -2502,6 +2525,8 @@ function tokenTransactionStatusToJSON(object) {
       return "TOKEN_TRANSACTION_STARTED";
     case 1 /* TOKEN_TRANSACTION_SIGNED */:
       return "TOKEN_TRANSACTION_SIGNED";
+    case 5 /* TOKEN_TRANSACTION_REVEALED */:
+      return "TOKEN_TRANSACTION_REVEALED";
     case 2 /* TOKEN_TRANSACTION_FINALIZED */:
       return "TOKEN_TRANSACTION_FINALIZED";
     case 3 /* TOKEN_TRANSACTION_STARTED_CANCELLED */:
@@ -7177,59 +7202,6 @@ var SecretShare = {
     return message;
   }
 };
-function createBaseSecretProof() {
-  return { proofs: [] };
-}
-var SecretProof = {
-  encode(message, writer = new import_wire4.BinaryWriter()) {
-    for (const v of message.proofs) {
-      writer.uint32(10).bytes(v);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
-    let end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseSecretProof();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.proofs.push(reader.bytes());
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      proofs: globalThis.Array.isArray(object?.proofs) ? object.proofs.map((e) => bytesFromBase642(e)) : []
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.proofs?.length) {
-      obj.proofs = message.proofs.map((e) => base64FromBytes2(e));
-    }
-    return obj;
-  },
-  create(base) {
-    return SecretProof.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseSecretProof();
-    message.proofs = object.proofs?.map((e) => e) || [];
-    return message;
-  }
-};
 function createBaseLeafRefundTxSigningJob() {
   return { leafId: "", refundTxSigningJob: void 0 };
 }
@@ -7642,7 +7614,6 @@ function createBaseStartTransferRequest() {
     leavesToSend: [],
     receiverIdentityPublicKey: new Uint8Array(0),
     expiryTime: void 0,
-    keyTweakProofs: {},
     transferPackage: void 0
   };
 }
@@ -7663,9 +7634,6 @@ var StartTransferRequest = {
     if (message.expiryTime !== void 0) {
       Timestamp.encode(toTimestamp(message.expiryTime), writer.uint32(42).fork()).join();
     }
-    Object.entries(message.keyTweakProofs).forEach(([key, value]) => {
-      StartTransferRequest_KeyTweakProofsEntry.encode({ key, value }, writer.uint32(50).fork()).join();
-    });
     if (message.transferPackage !== void 0) {
       TransferPackage.encode(message.transferPackage, writer.uint32(58).fork()).join();
     }
@@ -7713,16 +7681,6 @@ var StartTransferRequest = {
           message.expiryTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           continue;
         }
-        case 6: {
-          if (tag !== 50) {
-            break;
-          }
-          const entry6 = StartTransferRequest_KeyTweakProofsEntry.decode(reader, reader.uint32());
-          if (entry6.value !== void 0) {
-            message.keyTweakProofs[entry6.key] = entry6.value;
-          }
-          continue;
-        }
         case 7: {
           if (tag !== 58) {
             break;
@@ -7745,10 +7703,6 @@ var StartTransferRequest = {
       leavesToSend: globalThis.Array.isArray(object?.leavesToSend) ? object.leavesToSend.map((e) => LeafRefundTxSigningJob.fromJSON(e)) : [],
       receiverIdentityPublicKey: isSet3(object.receiverIdentityPublicKey) ? bytesFromBase642(object.receiverIdentityPublicKey) : new Uint8Array(0),
       expiryTime: isSet3(object.expiryTime) ? fromJsonTimestamp(object.expiryTime) : void 0,
-      keyTweakProofs: isObject(object.keyTweakProofs) ? Object.entries(object.keyTweakProofs).reduce((acc, [key, value]) => {
-        acc[key] = SecretProof.fromJSON(value);
-        return acc;
-      }, {}) : {},
       transferPackage: isSet3(object.transferPackage) ? TransferPackage.fromJSON(object.transferPackage) : void 0
     };
   },
@@ -7769,15 +7723,6 @@ var StartTransferRequest = {
     if (message.expiryTime !== void 0) {
       obj.expiryTime = message.expiryTime.toISOString();
     }
-    if (message.keyTweakProofs) {
-      const entries = Object.entries(message.keyTweakProofs);
-      if (entries.length > 0) {
-        obj.keyTweakProofs = {};
-        entries.forEach(([k, v]) => {
-          obj.keyTweakProofs[k] = SecretProof.toJSON(v);
-        });
-      }
-    }
     if (message.transferPackage !== void 0) {
       obj.transferPackage = TransferPackage.toJSON(message.transferPackage);
     }
@@ -7793,87 +7738,10 @@ var StartTransferRequest = {
     message.leavesToSend = object.leavesToSend?.map((e) => LeafRefundTxSigningJob.fromPartial(e)) || [];
     message.receiverIdentityPublicKey = object.receiverIdentityPublicKey ?? new Uint8Array(0);
     message.expiryTime = object.expiryTime ?? void 0;
-    message.keyTweakProofs = Object.entries(object.keyTweakProofs ?? {}).reduce(
-      (acc, [key, value]) => {
-        if (value !== void 0) {
-          acc[key] = SecretProof.fromPartial(value);
-        }
-        return acc;
-      },
-      {}
-    );
     message.transferPackage = object.transferPackage !== void 0 && object.transferPackage !== null ? TransferPackage.fromPartial(object.transferPackage) : void 0;
     return message;
   }
 };
-function createBaseStartTransferRequest_KeyTweakProofsEntry() {
-  return { key: "", value: void 0 };
-}
-var StartTransferRequest_KeyTweakProofsEntry = {
-  encode(message, writer = new import_wire4.BinaryWriter()) {
-    if (message.key !== "") {
-      writer.uint32(10).string(message.key);
-    }
-    if (message.value !== void 0) {
-      SecretProof.encode(message.value, writer.uint32(18).fork()).join();
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
-    let end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseStartTransferRequest_KeyTweakProofsEntry();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.key = reader.string();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-          message.value = SecretProof.decode(reader, reader.uint32());
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      key: isSet3(object.key) ? globalThis.String(object.key) : "",
-      value: isSet3(object.value) ? SecretProof.fromJSON(object.value) : void 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.key !== "") {
-      obj.key = message.key;
-    }
-    if (message.value !== void 0) {
-      obj.value = SecretProof.toJSON(message.value);
-    }
-    return obj;
-  },
-  create(base) {
-    return StartTransferRequest_KeyTweakProofsEntry.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseStartTransferRequest_KeyTweakProofsEntry();
-    message.key = object.key ?? "";
-    message.value = object.value !== void 0 && object.value !== null ? SecretProof.fromPartial(object.value) : void 0;
-    return message;
-  }
-};
 function createBaseStartTransferResponse() {
   return { transfer: void 0, signingResults: [] };
 }
@@ -8420,12 +8288,7 @@ var FinalizeTransferRequest = {
   }
 };
 function createBaseFinalizeTransferWithTransferPackageRequest() {
-  return {
-    transferId: "",
-    ownerIdentityPublicKey: new Uint8Array(0),
-    transferPackage: void 0,
-    refundSignatures: {}
-  };
+  return { transferId: "", ownerIdentityPublicKey: new Uint8Array(0), transferPackage: void 0 };
 }
 var FinalizeTransferWithTransferPackageRequest = {
   encode(message, writer = new import_wire4.BinaryWriter()) {
@@ -8438,12 +8301,6 @@ var FinalizeTransferWithTransferPackageRequest = {
     if (message.transferPackage !== void 0) {
       TransferPackage.encode(message.transferPackage, writer.uint32(26).fork()).join();
     }
-    Object.entries(message.refundSignatures).forEach(([key, value]) => {
-      FinalizeTransferWithTransferPackageRequest_RefundSignaturesEntry.encode(
-        { key, value },
-        writer.uint32(34).fork()
-      ).join();
-    });
     return writer;
   },
   decode(input, length) {
@@ -8474,19 +8331,6 @@ var FinalizeTransferWithTransferPackageRequest = {
           message.transferPackage = TransferPackage.decode(reader, reader.uint32());
           continue;
         }
-        case 4: {
-          if (tag !== 34) {
-            break;
-          }
-          const entry4 = FinalizeTransferWithTransferPackageRequest_RefundSignaturesEntry.decode(
-            reader,
-            reader.uint32()
-          );
-          if (entry4.value !== void 0) {
-            message.refundSignatures[entry4.key] = entry4.value;
-          }
-          continue;
-        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -8499,11 +8343,7 @@ var FinalizeTransferWithTransferPackageRequest = {
     return {
       transferId: isSet3(object.transferId) ? globalThis.String(object.transferId) : "",
       ownerIdentityPublicKey: isSet3(object.ownerIdentityPublicKey) ? bytesFromBase642(object.ownerIdentityPublicKey) : new Uint8Array(0),
-      transferPackage: isSet3(object.transferPackage) ? TransferPackage.fromJSON(object.transferPackage) : void 0,
-      refundSignatures: isObject(object.refundSignatures) ? Object.entries(object.refundSignatures).reduce((acc, [key, value]) => {
-        acc[key] = bytesFromBase642(value);
-        return acc;
-      }, {}) : {}
+      transferPackage: isSet3(object.transferPackage) ? TransferPackage.fromJSON(object.transferPackage) : void 0
     };
   },
   toJSON(message) {
@@ -8517,15 +8357,6 @@ var FinalizeTransferWithTransferPackageRequest = {
     if (message.transferPackage !== void 0) {
       obj.transferPackage = TransferPackage.toJSON(message.transferPackage);
     }
-    if (message.refundSignatures) {
-      const entries = Object.entries(message.refundSignatures);
-      if (entries.length > 0) {
-        obj.refundSignatures = {};
-        entries.forEach(([k, v]) => {
-          obj.refundSignatures[k] = base64FromBytes2(v);
-        });
-      }
-    }
     return obj;
   },
   create(base) {
@@ -8536,83 +8367,6 @@ var FinalizeTransferWithTransferPackageRequest = {
     message.transferId = object.transferId ?? "";
     message.ownerIdentityPublicKey = object.ownerIdentityPublicKey ?? new Uint8Array(0);
     message.transferPackage = object.transferPackage !== void 0 && object.transferPackage !== null ? TransferPackage.fromPartial(object.transferPackage) : void 0;
-    message.refundSignatures = Object.entries(object.refundSignatures ?? {}).reduce(
-      (acc, [key, value]) => {
-        if (value !== void 0) {
-          acc[key] = value;
-        }
-        return acc;
-      },
-      {}
-    );
-    return message;
-  }
-};
-function createBaseFinalizeTransferWithTransferPackageRequest_RefundSignaturesEntry() {
-  return { key: "", value: new Uint8Array(0) };
-}
-var FinalizeTransferWithTransferPackageRequest_RefundSignaturesEntry = {
-  encode(message, writer = new import_wire4.BinaryWriter()) {
-    if (message.key !== "") {
-      writer.uint32(10).string(message.key);
-    }
-    if (message.value.length !== 0) {
-      writer.uint32(18).bytes(message.value);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
-    let end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseFinalizeTransferWithTransferPackageRequest_RefundSignaturesEntry();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.key = reader.string();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-          message.value = reader.bytes();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      key: isSet3(object.key) ? globalThis.String(object.key) : "",
-      value: isSet3(object.value) ? bytesFromBase642(object.value) : new Uint8Array(0)
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.key !== "") {
-      obj.key = message.key;
-    }
-    if (message.value.length !== 0) {
-      obj.value = base64FromBytes2(message.value);
-    }
-    return obj;
-  },
-  create(base) {
-    return FinalizeTransferWithTransferPackageRequest_RefundSignaturesEntry.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseFinalizeTransferWithTransferPackageRequest_RefundSignaturesEntry();
-    message.key = object.key ?? "";
-    message.value = object.value ?? new Uint8Array(0);
     return message;
   }
 };
@@ -13812,13 +13566,16 @@ var QueryBalanceResponse_NodeBalancesEntry = {
   }
 };
 function createBaseSparkAddress() {
-  return { identityPublicKey: new Uint8Array(0) };
+  return { identityPublicKey: new Uint8Array(0), paymentIntentFields: void 0 };
 }
 var SparkAddress = {
   encode(message, writer = new import_wire4.BinaryWriter()) {
     if (message.identityPublicKey.length !== 0) {
       writer.uint32(10).bytes(message.identityPublicKey);
     }
+    if (message.paymentIntentFields !== void 0) {
+      PaymentIntentFields.encode(message.paymentIntentFields, writer.uint32(18).fork()).join();
+    }
     return writer;
   },
   decode(input, length) {
@@ -13835,6 +13592,13 @@ var SparkAddress = {
           message.identityPublicKey = reader.bytes();
           continue;
         }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.paymentIntentFields = PaymentIntentFields.decode(reader, reader.uint32());
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -13845,7 +13609,8 @@ var SparkAddress = {
   },
   fromJSON(object) {
     return {
-      identityPublicKey: isSet3(object.identityPublicKey) ? bytesFromBase642(object.identityPublicKey) : new Uint8Array(0)
+      identityPublicKey: isSet3(object.identityPublicKey) ? bytesFromBase642(object.identityPublicKey) : new Uint8Array(0),
+      paymentIntentFields: isSet3(object.paymentIntentFields) ? PaymentIntentFields.fromJSON(object.paymentIntentFields) : void 0
     };
   },
   toJSON(message) {
@@ -13853,6 +13618,9 @@ var SparkAddress = {
     if (message.identityPublicKey.length !== 0) {
       obj.identityPublicKey = base64FromBytes2(message.identityPublicKey);
     }
+    if (message.paymentIntentFields !== void 0) {
+      obj.paymentIntentFields = PaymentIntentFields.toJSON(message.paymentIntentFields);
+    }
     return obj;
   },
   create(base) {
@@ -13861,16 +13629,115 @@ var SparkAddress = {
   fromPartial(object) {
     const message = createBaseSparkAddress();
     message.identityPublicKey = object.identityPublicKey ?? new Uint8Array(0);
+    message.paymentIntentFields = object.paymentIntentFields !== void 0 && object.paymentIntentFields !== null ? PaymentIntentFields.fromPartial(object.paymentIntentFields) : void 0;
     return message;
   }
 };
-function createBaseInitiateUtxoSwapRequest() {
-  return {
-    onChainUtxo: void 0,
-    requestType: 0,
-    amount: void 0,
-    sspSignature: new Uint8Array(0),
-    userSignature: new Uint8Array(0),
+function createBasePaymentIntentFields() {
+  return { id: new Uint8Array(0), assetIdentifier: void 0, assetAmount: new Uint8Array(0), memo: void 0 };
+}
+var PaymentIntentFields = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.id.length !== 0) {
+      writer.uint32(10).bytes(message.id);
+    }
+    if (message.assetIdentifier !== void 0) {
+      writer.uint32(18).bytes(message.assetIdentifier);
+    }
+    if (message.assetAmount.length !== 0) {
+      writer.uint32(26).bytes(message.assetAmount);
+    }
+    if (message.memo !== void 0) {
+      writer.uint32(34).string(message.memo);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBasePaymentIntentFields();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.id = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.assetIdentifier = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.assetAmount = reader.bytes();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.memo = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      id: isSet3(object.id) ? bytesFromBase642(object.id) : new Uint8Array(0),
+      assetIdentifier: isSet3(object.assetIdentifier) ? bytesFromBase642(object.assetIdentifier) : void 0,
+      assetAmount: isSet3(object.assetAmount) ? bytesFromBase642(object.assetAmount) : new Uint8Array(0),
+      memo: isSet3(object.memo) ? globalThis.String(object.memo) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id.length !== 0) {
+      obj.id = base64FromBytes2(message.id);
+    }
+    if (message.assetIdentifier !== void 0) {
+      obj.assetIdentifier = base64FromBytes2(message.assetIdentifier);
+    }
+    if (message.assetAmount.length !== 0) {
+      obj.assetAmount = base64FromBytes2(message.assetAmount);
+    }
+    if (message.memo !== void 0) {
+      obj.memo = message.memo;
+    }
+    return obj;
+  },
+  create(base) {
+    return PaymentIntentFields.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBasePaymentIntentFields();
+    message.id = object.id ?? new Uint8Array(0);
+    message.assetIdentifier = object.assetIdentifier ?? void 0;
+    message.assetAmount = object.assetAmount ?? new Uint8Array(0);
+    message.memo = object.memo ?? void 0;
+    return message;
+  }
+};
+function createBaseInitiateUtxoSwapRequest() {
+  return {
+    onChainUtxo: void 0,
+    requestType: 0,
+    amount: void 0,
+    sspSignature: new Uint8Array(0),
+    userSignature: new Uint8Array(0),
     transfer: void 0,
     spendTxSigningJob: void 0
   };
@@ -15385,13 +15252,13 @@ function isSet3(value) {
 }
 
 // src/utils/network.ts
-var Network2 = /* @__PURE__ */ ((Network3) => {
-  Network3[Network3["MAINNET"] = 0] = "MAINNET";
-  Network3[Network3["TESTNET"] = 1] = "TESTNET";
-  Network3[Network3["SIGNET"] = 2] = "SIGNET";
-  Network3[Network3["REGTEST"] = 3] = "REGTEST";
-  Network3[Network3["LOCAL"] = 4] = "LOCAL";
-  return Network3;
+var Network2 = /* @__PURE__ */ ((Network4) => {
+  Network4[Network4["MAINNET"] = 0] = "MAINNET";
+  Network4[Network4["TESTNET"] = 1] = "TESTNET";
+  Network4[Network4["SIGNET"] = 2] = "SIGNET";
+  Network4[Network4["REGTEST"] = 3] = "REGTEST";
+  Network4[Network4["LOCAL"] = 4] = "LOCAL";
+  return Network4;
 })(Network2 || {});
 var NetworkToProto = {
   [0 /* MAINNET */]: 1 /* MAINNET */,
@@ -15415,11 +15282,11 @@ var LRC_WALLET_NETWORK = Object.freeze({
   [4 /* LOCAL */]: bitcoin.networks.regtest
 });
 var LRC_WALLET_NETWORK_TYPE = Object.freeze({
-  [0 /* MAINNET */]: import_lrc20_sdk4.NetworkType.MAINNET,
-  [1 /* TESTNET */]: import_lrc20_sdk4.NetworkType.TESTNET,
-  [2 /* SIGNET */]: import_lrc20_sdk4.NetworkType.TESTNET,
-  [3 /* REGTEST */]: import_lrc20_sdk4.NetworkType.REGTEST,
-  [4 /* LOCAL */]: import_lrc20_sdk4.NetworkType.LOCAL
+  [0 /* MAINNET */]: import_lrc20_sdk2.NetworkType.MAINNET,
+  [1 /* TESTNET */]: import_lrc20_sdk2.NetworkType.TESTNET,
+  [2 /* SIGNET */]: import_lrc20_sdk2.NetworkType.TESTNET,
+  [3 /* REGTEST */]: import_lrc20_sdk2.NetworkType.REGTEST,
+  [4 /* LOCAL */]: import_lrc20_sdk2.NetworkType.LOCAL
 });
 
 // src/services/wallet-config.ts
@@ -15557,6 +15424,7 @@ var BASE_CONFIG = {
   threshold: 2,
   signingOperators: getLocalSigningOperators(),
   tokenSignatures: "SCHNORR",
+  tokenTransactionVersion: "V0",
   electrsUrl: getElectrsUrl("LOCAL"),
   expectedWithdrawBondSats: 1e4,
   expectedWithdrawRelativeBlockLocktime: 1e3,
@@ -15764,6 +15632,9 @@ var WalletConfigService = class {
   getTokenSignatures() {
     return this.config.tokenSignatures;
   }
+  getTokenTransactionVersion() {
+    return this.config.tokenTransactionVersion;
+  }
   getElectrsUrl() {
     return this.config.electrsUrl;
   }
@@ -15774,31 +15645,9 @@ var WalletConfigService = class {
 
 // src/services/token-transactions.ts
 init_buffer();
-var import_utils7 = require("@noble/curves/abstract/utils");
+var import_utils9 = require("@noble/curves/abstract/utils");
 var import_secp256k19 = require("@noble/curves/secp256k1");
 
-// 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_sha22 = require("@noble/hashes/sha2");
@@ -16099,35 +15948,17 @@ function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
   return finalHashObj.digest();
 }
 
-// src/utils/token-keyshares.ts
-init_buffer();
-var import_secp256k17 = require("@noble/curves/secp256k1");
-function recoverRevocationSecretFromKeyshares(keyshares, threshold) {
-  const shares = keyshares.map((keyshare) => ({
-    fieldModulus: BigInt("0x" + import_secp256k17.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-transactions.ts
 init_buffer();
-var import_utils5 = require("@noble/curves/abstract/utils");
+var import_utils6 = require("@noble/curves/abstract/utils");
 function calculateAvailableTokenAmount(outputLeaves) {
   return outputLeaves.reduce(
-    (sum, output) => sum + BigInt((0, import_utils5.bytesToNumberBE)(output.output.tokenAmount)),
+    (sum, output) => sum + BigInt((0, import_utils6.bytesToNumberBE)(output.output.tokenAmount)),
     BigInt(0)
   );
 }
 function checkIfSelectedOutputsAreAvailable(selectedOutputs, tokenOutputs, tokenPublicKey) {
-  const tokenPubKeyHex = (0, import_utils5.bytesToHex)(tokenPublicKey);
+  const tokenPubKeyHex = (0, import_utils6.bytesToHex)(tokenPublicKey);
   const tokenOutputsAvailable = tokenOutputs.get(tokenPubKeyHex);
   if (!tokenOutputsAvailable) {
     return false;
@@ -16403,16 +16234,18 @@ function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction
 }
 
 // src/services/token-transactions.ts
-var import_utils8 = require("@noble/hashes/utils");
+var import_utils10 = require("@noble/hashes/utils");
 
 // src/address/index.ts
 init_buffer();
 
 // src/address/address.ts
 init_buffer();
-var import_secp256k18 = require("@noble/curves/secp256k1");
-var import_utils6 = require("@noble/hashes/utils");
+var import_secp256k17 = require("@noble/curves/secp256k1");
+var import_utils7 = require("@noble/hashes/utils");
 var import_base2 = require("@scure/base");
+var import_uuidv7 = require("uuidv7");
+var import_utils8 = require("@noble/curves/abstract/utils");
 var AddressNetwork = {
   MAINNET: "sp",
   TESTNET: "spt",
@@ -16422,7 +16255,7 @@ var AddressNetwork = {
 };
 function decodeSparkAddress(address2, network) {
   try {
-    const decoded = import_base2.bech32m.decode(address2, 200);
+    const decoded = import_base2.bech32m.decode(address2, 500);
     if (decoded.prefix !== AddressNetwork[network]) {
       throw new ValidationError("Invalid Spark address prefix", {
         field: "address",
@@ -16431,9 +16264,19 @@ function decodeSparkAddress(address2, network) {
       });
     }
     const payload = SparkAddress.decode(import_base2.bech32m.fromWords(decoded.words));
-    const publicKey = (0, import_utils6.bytesToHex)(payload.identityPublicKey);
+    const publicKey = (0, import_utils7.bytesToHex)(payload.identityPublicKey);
     isValidPublicKey(publicKey);
-    return publicKey;
+    const paymentIntentFields = payload.paymentIntentFields;
+    return {
+      identityPublicKey: publicKey,
+      network,
+      paymentIntentFields: paymentIntentFields && {
+        id: import_uuidv7.UUID.ofInner(paymentIntentFields.id).toString(),
+        assetIdentifier: paymentIntentFields.assetIdentifier ? (0, import_utils7.bytesToHex)(paymentIntentFields.assetIdentifier) : void 0,
+        assetAmount: (0, import_utils8.bytesToNumberBE)(paymentIntentFields.assetAmount),
+        memo: paymentIntentFields.memo
+      }
+    };
   } catch (error) {
     if (error instanceof ValidationError) {
       throw error;
@@ -16450,7 +16293,7 @@ function decodeSparkAddress(address2, network) {
 }
 function isValidPublicKey(publicKey) {
   try {
-    const point = import_secp256k18.secp256k1.ProjectivePoint.fromHex(publicKey);
+    const point = import_secp256k17.secp256k1.ProjectivePoint.fromHex(publicKey);
     point.assertValidity();
   } catch (error) {
     throw new ValidationError(
@@ -16464,8 +16307,48 @@ function isValidPublicKey(publicKey) {
   }
 }
 
+// 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-keyshares.ts
+init_buffer();
+var import_secp256k18 = require("@noble/curves/secp256k1");
+function recoverRevocationSecretFromKeyshares(keyshares, threshold) {
+  const shares = keyshares.map((keyshare) => ({
+    fieldModulus: BigInt("0x" + import_secp256k18.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/services/token-transactions.ts
-var MAX_TOKEN_OUTPUTS = 1e3;
+var MAX_TOKEN_OUTPUTS = 500;
 var TokenTransactionService = class {
   config;
   connectionManager;
@@ -16491,7 +16374,7 @@ var TokenTransactionService = class {
       if (!checkIfSelectedOutputsAreAvailable(
         outputsToUse,
         tokenOutputs,
-        (0, import_utils8.hexToBytes)(receiverOutputs[0].tokenPublicKey)
+        (0, import_utils10.hexToBytes)(receiverOutputs[0].tokenPublicKey)
       )) {
         throw new ValidationError(
           "One or more selected TTXOs are not available",
@@ -16532,15 +16415,23 @@ var TokenTransactionService = class {
         this.config.getNetworkType()
       );
       return {
-        receiverSparkAddress: (0, import_utils8.hexToBytes)(receiverAddress),
-        tokenPublicKey: (0, import_utils8.hexToBytes)(transfer.tokenPublicKey),
+        receiverSparkAddress: (0, import_utils10.hexToBytes)(receiverAddress.identityPublicKey),
+        tokenPublicKey: (0, import_utils10.hexToBytes)(transfer.tokenPublicKey),
         tokenAmount: transfer.tokenAmount
       };
     });
-    const tokenTransaction = await this.constructTransferTokenTransaction(
-      outputsToUse,
-      tokenOutputData
-    );
+    let tokenTransaction;
+    if (this.config.getTokenTransactionVersion() === "V0") {
+      tokenTransaction = await this.constructTransferTokenTransactionV0(
+        outputsToUse,
+        tokenOutputData
+      );
+    } else {
+      tokenTransaction = await this.constructTransferTokenTransaction(
+        outputsToUse,
+        tokenOutputData
+      );
+    }
     const txId = await this.broadcastTokenTransaction(
       tokenTransaction,
       outputsToUse.map((output) => output.output.ownerPublicKey),
@@ -16548,7 +16439,7 @@ var TokenTransactionService = class {
     );
     return txId;
   }
-  async constructTransferTokenTransaction(selectedOutputs, tokenOutputData) {
+  async constructTransferTokenTransactionV0(selectedOutputs, tokenOutputData) {
     const availableTokenAmount = calculateAvailableTokenAmount(selectedOutputs);
     const totalRequestedAmount = tokenOutputData.reduce(
       (sum, output) => sum + output.tokenAmount,
@@ -16557,7 +16448,7 @@ var TokenTransactionService = class {
     const tokenOutputs = tokenOutputData.map((output) => ({
       ownerPublicKey: output.receiverSparkAddress,
       tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: (0, import_utils7.numberToBytesBE)(output.tokenAmount, 16)
+      tokenAmount: (0, import_utils9.numberToBytesBE)(output.tokenAmount, 16)
     }));
     if (availableTokenAmount > totalRequestedAmount) {
       const changeAmount = availableTokenAmount - totalRequestedAmount;
@@ -16565,7 +16456,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils7.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils9.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -16583,24 +16474,78 @@ var TokenTransactionService = class {
       sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys()
     };
   }
+  async constructTransferTokenTransaction(selectedOutputs, tokenOutputData) {
+    const availableTokenAmount = calculateAvailableTokenAmount(selectedOutputs);
+    const totalRequestedAmount = tokenOutputData.reduce(
+      (sum, output) => sum + output.tokenAmount,
+      0n
+    );
+    const tokenOutputs = tokenOutputData.map((output) => ({
+      ownerPublicKey: output.receiverSparkAddress,
+      tokenPublicKey: output.tokenPublicKey,
+      tokenAmount: (0, import_utils9.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_utils9.numberToBytesBE)(changeAmount, 16)
+      });
+    }
+    return {
+      version: 1,
+      network: this.config.getNetworkProto(),
+      tokenInputs: {
+        $case: "transferInput",
+        transferInput: {
+          outputsToSpend: selectedOutputs.map((output) => ({
+            prevTokenTransactionHash: output.previousTransactionHash,
+            prevTokenTransactionVout: output.previousTransactionVout
+          }))
+        }
+      },
+      tokenOutputs,
+      sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys(),
+      expiryTime: void 0
+    };
+  }
   collectOperatorIdentityPublicKeys() {
     const operatorKeys = [];
     for (const [_, operator] of Object.entries(
       this.config.getSigningOperators()
     )) {
-      operatorKeys.push((0, import_utils8.hexToBytes)(operator.identityPublicKey));
+      operatorKeys.push((0, import_utils10.hexToBytes)(operator.identityPublicKey));
     }
     return operatorKeys;
   }
   async broadcastTokenTransaction(tokenTransaction, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const signingOperators = this.config.getSigningOperators();
-    const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
+    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.signTokenTransaction(
+    const { successfulSignatures } = await this.signTokenTransactionV0(
       finalTokenTransaction,
       finalTokenTransactionHash,
       signingOperators
@@ -16655,7 +16600,7 @@ var TokenTransactionService = class {
               {
                 field: "revocationCommitment",
                 value: derivedRevocationCommitment,
-                expected: (0, import_utils7.bytesToHex)(outputsToSpendCommitments[outputIndex]),
+                expected: (0, import_utils9.bytesToHex)(outputsToSpendCommitments[outputIndex]),
                 outputIndex
               }
             )
@@ -16681,9 +16626,23 @@ var TokenTransactionService = class {
         threshold
       );
     }
-    return (0, import_utils7.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils9.bytesToHex)(finalTokenTransactionHash);
   }
-  async startTokenTransaction(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
+  async broadcastTokenTransactionV1(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
+    const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
+      tokenTransaction,
+      signingOperators,
+      outputsToSpendSigningPublicKeys,
+      outputsToSpendCommitments
+    );
+    await this.signTokenTransaction(
+      finalTokenTransaction,
+      finalTokenTransactionHash,
+      signingOperators
+    );
+    return (0, import_utils9.bytesToHex)(finalTokenTransactionHash);
+  }
+  async startTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
@@ -16778,49 +16737,141 @@ var TokenTransactionService = class {
       threshold: startResponse.keyshareInfo.threshold
     };
   }
-  async signTokenTransaction(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_utils8.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(
+  async startTokenTransaction(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
+    const sparkClient = await this.connectionManager.createSparkTokenClient(
+      this.config.getCoordinatorAddress()
+    );
+    const partialTokenTransactionHash = hashTokenTransaction(
+      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_transaction(
+      {
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        partialTokenTransaction: tokenTransaction
+      },
+      {
+        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");
+    }
+    validateTokenTransaction(
+      startResponse.finalTokenTransaction,
+      tokenTransaction,
+      signingOperators,
+      startResponse.keyshareInfo,
+      this.config.getExpectedWithdrawBondSats(),
+      this.config.getExpectedWithdrawRelativeBlockLocktime(),
+      this.config.getThreshold()
+    );
+    const finalTokenTransaction = startResponse.finalTokenTransaction;
+    const finalTokenTransactionHash = hashTokenTransaction(
+      finalTokenTransaction,
+      false
+    );
+    return {
+      finalTokenTransaction,
+      finalTokenTransactionHash,
+      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_utils10.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
                 );
               }
@@ -16875,49 +16926,44 @@ var TokenTransactionService = class {
       successfulSignatures
     };
   }
-  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
-          );
-        }
-      })
+  async signTokenTransaction(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
+    const coordinatorClient = await this.connectionManager.createSparkTokenClient(
+      this.config.getCoordinatorAddress()
     );
-    collectResponses(soResponses);
-    return finalTokenTransaction;
+    const inputTtxoSignaturesPerOperator = await this.createSignaturesForOperators(
+      finalTokenTransaction,
+      finalTokenTransactionHash,
+      signingOperators
+    );
+    try {
+      await coordinatorClient.commit_transaction(
+        {
+          finalTokenTransaction,
+          inputTtxoSignaturesPerOperator,
+          ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
+        },
+        {
+          retry: true,
+          retryableStatuses: [
+            "UNKNOWN",
+            "UNAVAILABLE",
+            "CANCELLED",
+            "INTERNAL"
+          ],
+          retryMaxAttempts: 3
+        }
+      );
+    } 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
+      );
+    }
   }
   async fetchOwnedTokenOutputs(ownerPublicKeys, tokenPublicKeys) {
     const sparkClient = await this.connectionManager.createSparkClient(
@@ -16948,7 +16994,7 @@ var TokenTransactionService = class {
       []
     );
     unsortedTokenOutputs.forEach((output) => {
-      const tokenKey = (0, import_utils7.bytesToHex)(output.output.tokenPublicKey);
+      const tokenKey = (0, import_utils9.bytesToHex)(output.output.tokenPublicKey);
       const index = output.previousTransactionVout;
       tokenOutputs.set(tokenKey, [
         { ...output, previousTransactionVout: index }
@@ -16964,7 +17010,7 @@ var TokenTransactionService = class {
       });
     }
     const exactMatch = tokenOutputs.find(
-      (item) => (0, import_utils7.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
+      (item) => (0, import_utils9.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
     );
     if (exactMatch) {
       return [exactMatch];
@@ -16975,7 +17021,7 @@ var TokenTransactionService = class {
     for (const outputWithPreviousTransactionData of tokenOutputs) {
       if (remainingAmount <= 0n) break;
       selectedOutputs.push(outputWithPreviousTransactionData);
-      remainingAmount -= (0, import_utils7.bytesToNumberBE)(
+      remainingAmount -= (0, import_utils9.bytesToNumberBE)(
         outputWithPreviousTransactionData.output.tokenAmount
       );
     }
@@ -16991,13 +17037,13 @@ var TokenTransactionService = class {
     if (strategy === "SMALL_FIRST") {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils7.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils7.bytesToNumberBE)(b.output.tokenAmount)
+          (0, import_utils9.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils9.bytesToNumberBE)(b.output.tokenAmount)
         );
       });
     } else {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils7.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils7.bytesToNumberBE)(a.output.tokenAmount)
+          (0, import_utils9.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils9.bytesToNumberBE)(a.output.tokenAmount)
         );
       });
     }
@@ -17005,7 +17051,7 @@ var TokenTransactionService = class {
   // Helper function for deciding if the signer public key is the identity public key
   async signMessageWithKey(message, publicKey) {
     const tokenSignatures = this.config.getTokenSignatures();
-    if ((0, import_utils7.bytesToHex)(publicKey) === (0, import_utils7.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
+    if ((0, import_utils9.bytesToHex)(publicKey) === (0, import_utils9.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
       if (tokenSignatures === "SCHNORR") {
         return await this.config.signer.signSchnorrWithIdentityKey(message);
       } else {
@@ -17022,7 +17068,107 @@ 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)) {
+      let ttxoSignatures = [];
+      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 payload = {
+          finalTokenTransactionHash,
+          operatorIdentityPublicKey: (0, import_utils10.hexToBytes)(operator.identityPublicKey)
+        };
+        const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
+        const ownerSignature = await this.signMessageWithKey(
+          payloadHash,
+          issuerPublicKey
+        );
+        ttxoSignatures.push({
+          signature: ownerSignature,
+          inputIndex: 0
+        });
+      } else if (finalTokenTransaction.tokenInputs.$case === "transferInput") {
+        const transferInput = finalTokenTransaction.tokenInputs.transferInput;
+        for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
+          const payload = {
+            finalTokenTransactionHash,
+            operatorIdentityPublicKey: (0, import_utils10.hexToBytes)(operator.identityPublicKey)
+          };
+          const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
+          let ownerSignature;
+          if (this.config.getTokenSignatures() === "SCHNORR") {
+            ownerSignature = await this.config.signer.signSchnorrWithIdentityKey(payloadHash);
+          } else {
+            ownerSignature = await this.config.signer.signMessageWithIdentityKey(payloadHash);
+          }
+          ttxoSignatures.push({
+            signature: ownerSignature,
+            inputIndex: i
+          });
+        }
+      }
+      inputTtxoSignaturesPerOperator.push({
+        ttxoSignatures,
+        operatorIdentityPublicKey: (0, import_utils10.hexToBytes)(operator.identityPublicKey)
+      });
+    }
+    return inputTtxoSignaturesPerOperator;
+  }
 };
+function isTokenTransaction(tokenTransaction) {
+  return "version" in tokenTransaction && "expiryTime" in tokenTransaction;
+}
 
 // src/services/connection.ts
 init_buffer();
@@ -17793,10 +17939,1062 @@ function isSet5(value) {
   return value !== null && value !== void 0;
 }
 
+// src/proto/spark_token.ts
+init_buffer();
+var import_wire7 = require("@bufbuild/protobuf/wire");
+function createBaseTokenOutputToSpend2() {
+  return { prevTokenTransactionHash: new Uint8Array(0), prevTokenTransactionVout: 0 };
+}
+var TokenOutputToSpend2 = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.prevTokenTransactionHash.length !== 0) {
+      writer.uint32(10).bytes(message.prevTokenTransactionHash);
+    }
+    if (message.prevTokenTransactionVout !== 0) {
+      writer.uint32(16).uint32(message.prevTokenTransactionVout);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTokenOutputToSpend2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.prevTokenTransactionHash = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.prevTokenTransactionVout = reader.uint32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      prevTokenTransactionHash: isSet6(object.prevTokenTransactionHash) ? bytesFromBase645(object.prevTokenTransactionHash) : new Uint8Array(0),
+      prevTokenTransactionVout: isSet6(object.prevTokenTransactionVout) ? globalThis.Number(object.prevTokenTransactionVout) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.prevTokenTransactionHash.length !== 0) {
+      obj.prevTokenTransactionHash = base64FromBytes5(message.prevTokenTransactionHash);
+    }
+    if (message.prevTokenTransactionVout !== 0) {
+      obj.prevTokenTransactionVout = Math.round(message.prevTokenTransactionVout);
+    }
+    return obj;
+  },
+  create(base) {
+    return TokenOutputToSpend2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTokenOutputToSpend2();
+    message.prevTokenTransactionHash = object.prevTokenTransactionHash ?? new Uint8Array(0);
+    message.prevTokenTransactionVout = object.prevTokenTransactionVout ?? 0;
+    return message;
+  }
+};
+function createBaseTokenTransferInput2() {
+  return { outputsToSpend: [] };
+}
+var TokenTransferInput2 = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    for (const v of message.outputsToSpend) {
+      TokenOutputToSpend2.encode(v, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTokenTransferInput2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.outputsToSpend.push(TokenOutputToSpend2.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      outputsToSpend: globalThis.Array.isArray(object?.outputsToSpend) ? object.outputsToSpend.map((e) => TokenOutputToSpend2.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.outputsToSpend?.length) {
+      obj.outputsToSpend = message.outputsToSpend.map((e) => TokenOutputToSpend2.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return TokenTransferInput2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTokenTransferInput2();
+    message.outputsToSpend = object.outputsToSpend?.map((e) => TokenOutputToSpend2.fromPartial(e)) || [];
+    return message;
+  }
+};
+function createBaseTokenMintInput2() {
+  return { issuerPublicKey: new Uint8Array(0), issuerProvidedTimestamp: 0 };
+}
+var TokenMintInput2 = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.issuerPublicKey.length !== 0) {
+      writer.uint32(10).bytes(message.issuerPublicKey);
+    }
+    if (message.issuerProvidedTimestamp !== 0) {
+      writer.uint32(16).uint64(message.issuerProvidedTimestamp);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTokenMintInput2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.issuerPublicKey = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.issuerProvidedTimestamp = longToNumber4(reader.uint64());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      issuerPublicKey: isSet6(object.issuerPublicKey) ? bytesFromBase645(object.issuerPublicKey) : new Uint8Array(0),
+      issuerProvidedTimestamp: isSet6(object.issuerProvidedTimestamp) ? globalThis.Number(object.issuerProvidedTimestamp) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.issuerPublicKey.length !== 0) {
+      obj.issuerPublicKey = base64FromBytes5(message.issuerPublicKey);
+    }
+    if (message.issuerProvidedTimestamp !== 0) {
+      obj.issuerProvidedTimestamp = Math.round(message.issuerProvidedTimestamp);
+    }
+    return obj;
+  },
+  create(base) {
+    return TokenMintInput2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTokenMintInput2();
+    message.issuerPublicKey = object.issuerPublicKey ?? new Uint8Array(0);
+    message.issuerProvidedTimestamp = object.issuerProvidedTimestamp ?? 0;
+    return message;
+  }
+};
+function createBaseTokenOutput2() {
+  return {
+    id: void 0,
+    ownerPublicKey: new Uint8Array(0),
+    revocationCommitment: void 0,
+    withdrawBondSats: void 0,
+    withdrawRelativeBlockLocktime: void 0,
+    tokenPublicKey: new Uint8Array(0),
+    tokenAmount: new Uint8Array(0)
+  };
+}
+var TokenOutput2 = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.id !== void 0) {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.ownerPublicKey.length !== 0) {
+      writer.uint32(18).bytes(message.ownerPublicKey);
+    }
+    if (message.revocationCommitment !== void 0) {
+      writer.uint32(26).bytes(message.revocationCommitment);
+    }
+    if (message.withdrawBondSats !== void 0) {
+      writer.uint32(32).uint64(message.withdrawBondSats);
+    }
+    if (message.withdrawRelativeBlockLocktime !== void 0) {
+      writer.uint32(40).uint64(message.withdrawRelativeBlockLocktime);
+    }
+    if (message.tokenPublicKey.length !== 0) {
+      writer.uint32(50).bytes(message.tokenPublicKey);
+    }
+    if (message.tokenAmount.length !== 0) {
+      writer.uint32(58).bytes(message.tokenAmount);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTokenOutput2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.ownerPublicKey = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.revocationCommitment = reader.bytes();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.withdrawBondSats = longToNumber4(reader.uint64());
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.withdrawRelativeBlockLocktime = longToNumber4(reader.uint64());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.tokenPublicKey = reader.bytes();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.tokenAmount = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      id: isSet6(object.id) ? globalThis.String(object.id) : void 0,
+      ownerPublicKey: isSet6(object.ownerPublicKey) ? bytesFromBase645(object.ownerPublicKey) : new Uint8Array(0),
+      revocationCommitment: isSet6(object.revocationCommitment) ? bytesFromBase645(object.revocationCommitment) : void 0,
+      withdrawBondSats: isSet6(object.withdrawBondSats) ? globalThis.Number(object.withdrawBondSats) : void 0,
+      withdrawRelativeBlockLocktime: isSet6(object.withdrawRelativeBlockLocktime) ? globalThis.Number(object.withdrawRelativeBlockLocktime) : void 0,
+      tokenPublicKey: isSet6(object.tokenPublicKey) ? bytesFromBase645(object.tokenPublicKey) : new Uint8Array(0),
+      tokenAmount: isSet6(object.tokenAmount) ? bytesFromBase645(object.tokenAmount) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id !== void 0) {
+      obj.id = message.id;
+    }
+    if (message.ownerPublicKey.length !== 0) {
+      obj.ownerPublicKey = base64FromBytes5(message.ownerPublicKey);
+    }
+    if (message.revocationCommitment !== void 0) {
+      obj.revocationCommitment = base64FromBytes5(message.revocationCommitment);
+    }
+    if (message.withdrawBondSats !== void 0) {
+      obj.withdrawBondSats = Math.round(message.withdrawBondSats);
+    }
+    if (message.withdrawRelativeBlockLocktime !== void 0) {
+      obj.withdrawRelativeBlockLocktime = Math.round(message.withdrawRelativeBlockLocktime);
+    }
+    if (message.tokenPublicKey.length !== 0) {
+      obj.tokenPublicKey = base64FromBytes5(message.tokenPublicKey);
+    }
+    if (message.tokenAmount.length !== 0) {
+      obj.tokenAmount = base64FromBytes5(message.tokenAmount);
+    }
+    return obj;
+  },
+  create(base) {
+    return TokenOutput2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTokenOutput2();
+    message.id = object.id ?? void 0;
+    message.ownerPublicKey = object.ownerPublicKey ?? new Uint8Array(0);
+    message.revocationCommitment = object.revocationCommitment ?? void 0;
+    message.withdrawBondSats = object.withdrawBondSats ?? void 0;
+    message.withdrawRelativeBlockLocktime = object.withdrawRelativeBlockLocktime ?? void 0;
+    message.tokenPublicKey = object.tokenPublicKey ?? new Uint8Array(0);
+    message.tokenAmount = object.tokenAmount ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseTokenTransaction2() {
+  return {
+    version: 0,
+    tokenInputs: void 0,
+    tokenOutputs: [],
+    sparkOperatorIdentityPublicKeys: [],
+    expiryTime: void 0,
+    network: 0
+  };
+}
+var TokenTransaction2 = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.version !== 0) {
+      writer.uint32(8).uint32(message.version);
+    }
+    switch (message.tokenInputs?.$case) {
+      case "mintInput":
+        TokenMintInput2.encode(message.tokenInputs.mintInput, writer.uint32(18).fork()).join();
+        break;
+      case "transferInput":
+        TokenTransferInput2.encode(message.tokenInputs.transferInput, writer.uint32(26).fork()).join();
+        break;
+    }
+    for (const v of message.tokenOutputs) {
+      TokenOutput2.encode(v, writer.uint32(34).fork()).join();
+    }
+    for (const v of message.sparkOperatorIdentityPublicKeys) {
+      writer.uint32(42).bytes(v);
+    }
+    if (message.expiryTime !== void 0) {
+      Timestamp.encode(toTimestamp2(message.expiryTime), writer.uint32(50).fork()).join();
+    }
+    if (message.network !== 0) {
+      writer.uint32(56).int32(message.network);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTokenTransaction2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.version = reader.uint32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.tokenInputs = { $case: "mintInput", mintInput: TokenMintInput2.decode(reader, reader.uint32()) };
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.tokenInputs = {
+            $case: "transferInput",
+            transferInput: TokenTransferInput2.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.tokenOutputs.push(TokenOutput2.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.sparkOperatorIdentityPublicKeys.push(reader.bytes());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.expiryTime = fromTimestamp2(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+          message.network = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      version: isSet6(object.version) ? globalThis.Number(object.version) : 0,
+      tokenInputs: isSet6(object.mintInput) ? { $case: "mintInput", mintInput: TokenMintInput2.fromJSON(object.mintInput) } : isSet6(object.transferInput) ? { $case: "transferInput", transferInput: TokenTransferInput2.fromJSON(object.transferInput) } : void 0,
+      tokenOutputs: globalThis.Array.isArray(object?.tokenOutputs) ? object.tokenOutputs.map((e) => TokenOutput2.fromJSON(e)) : [],
+      sparkOperatorIdentityPublicKeys: globalThis.Array.isArray(object?.sparkOperatorIdentityPublicKeys) ? object.sparkOperatorIdentityPublicKeys.map((e) => bytesFromBase645(e)) : [],
+      expiryTime: isSet6(object.expiryTime) ? fromJsonTimestamp2(object.expiryTime) : void 0,
+      network: isSet6(object.network) ? networkFromJSON(object.network) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.version !== 0) {
+      obj.version = Math.round(message.version);
+    }
+    if (message.tokenInputs?.$case === "mintInput") {
+      obj.mintInput = TokenMintInput2.toJSON(message.tokenInputs.mintInput);
+    } else if (message.tokenInputs?.$case === "transferInput") {
+      obj.transferInput = TokenTransferInput2.toJSON(message.tokenInputs.transferInput);
+    }
+    if (message.tokenOutputs?.length) {
+      obj.tokenOutputs = message.tokenOutputs.map((e) => TokenOutput2.toJSON(e));
+    }
+    if (message.sparkOperatorIdentityPublicKeys?.length) {
+      obj.sparkOperatorIdentityPublicKeys = message.sparkOperatorIdentityPublicKeys.map((e) => base64FromBytes5(e));
+    }
+    if (message.expiryTime !== void 0) {
+      obj.expiryTime = message.expiryTime.toISOString();
+    }
+    if (message.network !== 0) {
+      obj.network = networkToJSON(message.network);
+    }
+    return obj;
+  },
+  create(base) {
+    return TokenTransaction2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseTokenTransaction2();
+    message.version = object.version ?? 0;
+    switch (object.tokenInputs?.$case) {
+      case "mintInput": {
+        if (object.tokenInputs?.mintInput !== void 0 && object.tokenInputs?.mintInput !== null) {
+          message.tokenInputs = {
+            $case: "mintInput",
+            mintInput: TokenMintInput2.fromPartial(object.tokenInputs.mintInput)
+          };
+        }
+        break;
+      }
+      case "transferInput": {
+        if (object.tokenInputs?.transferInput !== void 0 && object.tokenInputs?.transferInput !== null) {
+          message.tokenInputs = {
+            $case: "transferInput",
+            transferInput: TokenTransferInput2.fromPartial(object.tokenInputs.transferInput)
+          };
+        }
+        break;
+      }
+    }
+    message.tokenOutputs = object.tokenOutputs?.map((e) => TokenOutput2.fromPartial(e)) || [];
+    message.sparkOperatorIdentityPublicKeys = object.sparkOperatorIdentityPublicKeys?.map((e) => e) || [];
+    message.expiryTime = object.expiryTime ?? void 0;
+    message.network = object.network ?? 0;
+    return message;
+  }
+};
+function createBaseSignatureWithIndex2() {
+  return { signature: new Uint8Array(0), inputIndex: 0 };
+}
+var SignatureWithIndex2 = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.signature.length !== 0) {
+      writer.uint32(10).bytes(message.signature);
+    }
+    if (message.inputIndex !== 0) {
+      writer.uint32(16).uint32(message.inputIndex);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSignatureWithIndex2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.signature = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.inputIndex = reader.uint32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      signature: isSet6(object.signature) ? bytesFromBase645(object.signature) : new Uint8Array(0),
+      inputIndex: isSet6(object.inputIndex) ? globalThis.Number(object.inputIndex) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.signature.length !== 0) {
+      obj.signature = base64FromBytes5(message.signature);
+    }
+    if (message.inputIndex !== 0) {
+      obj.inputIndex = Math.round(message.inputIndex);
+    }
+    return obj;
+  },
+  create(base) {
+    return SignatureWithIndex2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseSignatureWithIndex2();
+    message.signature = object.signature ?? new Uint8Array(0);
+    message.inputIndex = object.inputIndex ?? 0;
+    return message;
+  }
+};
+function createBaseInputTtxoSignaturesPerOperator() {
+  return { ttxoSignatures: [], operatorIdentityPublicKey: new Uint8Array(0) };
+}
+var InputTtxoSignaturesPerOperator = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    for (const v of message.ttxoSignatures) {
+      SignatureWithIndex2.encode(v, writer.uint32(10).fork()).join();
+    }
+    if (message.operatorIdentityPublicKey.length !== 0) {
+      writer.uint32(18).bytes(message.operatorIdentityPublicKey);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseInputTtxoSignaturesPerOperator();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.ttxoSignatures.push(SignatureWithIndex2.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.operatorIdentityPublicKey = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      ttxoSignatures: globalThis.Array.isArray(object?.ttxoSignatures) ? object.ttxoSignatures.map((e) => SignatureWithIndex2.fromJSON(e)) : [],
+      operatorIdentityPublicKey: isSet6(object.operatorIdentityPublicKey) ? bytesFromBase645(object.operatorIdentityPublicKey) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.ttxoSignatures?.length) {
+      obj.ttxoSignatures = message.ttxoSignatures.map((e) => SignatureWithIndex2.toJSON(e));
+    }
+    if (message.operatorIdentityPublicKey.length !== 0) {
+      obj.operatorIdentityPublicKey = base64FromBytes5(message.operatorIdentityPublicKey);
+    }
+    return obj;
+  },
+  create(base) {
+    return InputTtxoSignaturesPerOperator.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseInputTtxoSignaturesPerOperator();
+    message.ttxoSignatures = object.ttxoSignatures?.map((e) => SignatureWithIndex2.fromPartial(e)) || [];
+    message.operatorIdentityPublicKey = object.operatorIdentityPublicKey ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseStartTransactionRequest() {
+  return {
+    identityPublicKey: new Uint8Array(0),
+    partialTokenTransaction: void 0,
+    partialTokenTransactionOwnerSignatures: [],
+    validityDurationSeconds: 0
+  };
+}
+var StartTransactionRequest = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.identityPublicKey.length !== 0) {
+      writer.uint32(10).bytes(message.identityPublicKey);
+    }
+    if (message.partialTokenTransaction !== void 0) {
+      TokenTransaction2.encode(message.partialTokenTransaction, writer.uint32(18).fork()).join();
+    }
+    for (const v of message.partialTokenTransactionOwnerSignatures) {
+      SignatureWithIndex2.encode(v, writer.uint32(26).fork()).join();
+    }
+    if (message.validityDurationSeconds !== 0) {
+      writer.uint32(32).uint64(message.validityDurationSeconds);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStartTransactionRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.identityPublicKey = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.partialTokenTransaction = TokenTransaction2.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.partialTokenTransactionOwnerSignatures.push(SignatureWithIndex2.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.validityDurationSeconds = longToNumber4(reader.uint64());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      identityPublicKey: isSet6(object.identityPublicKey) ? bytesFromBase645(object.identityPublicKey) : new Uint8Array(0),
+      partialTokenTransaction: isSet6(object.partialTokenTransaction) ? TokenTransaction2.fromJSON(object.partialTokenTransaction) : void 0,
+      partialTokenTransactionOwnerSignatures: globalThis.Array.isArray(object?.partialTokenTransactionOwnerSignatures) ? object.partialTokenTransactionOwnerSignatures.map((e) => SignatureWithIndex2.fromJSON(e)) : [],
+      validityDurationSeconds: isSet6(object.validityDurationSeconds) ? globalThis.Number(object.validityDurationSeconds) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.identityPublicKey.length !== 0) {
+      obj.identityPublicKey = base64FromBytes5(message.identityPublicKey);
+    }
+    if (message.partialTokenTransaction !== void 0) {
+      obj.partialTokenTransaction = TokenTransaction2.toJSON(message.partialTokenTransaction);
+    }
+    if (message.partialTokenTransactionOwnerSignatures?.length) {
+      obj.partialTokenTransactionOwnerSignatures = message.partialTokenTransactionOwnerSignatures.map(
+        (e) => SignatureWithIndex2.toJSON(e)
+      );
+    }
+    if (message.validityDurationSeconds !== 0) {
+      obj.validityDurationSeconds = Math.round(message.validityDurationSeconds);
+    }
+    return obj;
+  },
+  create(base) {
+    return StartTransactionRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseStartTransactionRequest();
+    message.identityPublicKey = object.identityPublicKey ?? new Uint8Array(0);
+    message.partialTokenTransaction = object.partialTokenTransaction !== void 0 && object.partialTokenTransaction !== null ? TokenTransaction2.fromPartial(object.partialTokenTransaction) : void 0;
+    message.partialTokenTransactionOwnerSignatures = object.partialTokenTransactionOwnerSignatures?.map((e) => SignatureWithIndex2.fromPartial(e)) || [];
+    message.validityDurationSeconds = object.validityDurationSeconds ?? 0;
+    return message;
+  }
+};
+function createBaseStartTransactionResponse() {
+  return { finalTokenTransaction: void 0, keyshareInfo: void 0 };
+}
+var StartTransactionResponse = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.finalTokenTransaction !== void 0) {
+      TokenTransaction2.encode(message.finalTokenTransaction, writer.uint32(10).fork()).join();
+    }
+    if (message.keyshareInfo !== void 0) {
+      SigningKeyshare.encode(message.keyshareInfo, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStartTransactionResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.finalTokenTransaction = TokenTransaction2.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.keyshareInfo = SigningKeyshare.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      finalTokenTransaction: isSet6(object.finalTokenTransaction) ? TokenTransaction2.fromJSON(object.finalTokenTransaction) : void 0,
+      keyshareInfo: isSet6(object.keyshareInfo) ? SigningKeyshare.fromJSON(object.keyshareInfo) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.finalTokenTransaction !== void 0) {
+      obj.finalTokenTransaction = TokenTransaction2.toJSON(message.finalTokenTransaction);
+    }
+    if (message.keyshareInfo !== void 0) {
+      obj.keyshareInfo = SigningKeyshare.toJSON(message.keyshareInfo);
+    }
+    return obj;
+  },
+  create(base) {
+    return StartTransactionResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseStartTransactionResponse();
+    message.finalTokenTransaction = object.finalTokenTransaction !== void 0 && object.finalTokenTransaction !== null ? TokenTransaction2.fromPartial(object.finalTokenTransaction) : void 0;
+    message.keyshareInfo = object.keyshareInfo !== void 0 && object.keyshareInfo !== null ? SigningKeyshare.fromPartial(object.keyshareInfo) : void 0;
+    return message;
+  }
+};
+function createBaseCommitTransactionRequest() {
+  return {
+    finalTokenTransaction: void 0,
+    finalTokenTransactionHash: new Uint8Array(0),
+    inputTtxoSignaturesPerOperator: [],
+    ownerIdentityPublicKey: new Uint8Array(0)
+  };
+}
+var CommitTransactionRequest = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.finalTokenTransaction !== void 0) {
+      TokenTransaction2.encode(message.finalTokenTransaction, writer.uint32(10).fork()).join();
+    }
+    if (message.finalTokenTransactionHash.length !== 0) {
+      writer.uint32(18).bytes(message.finalTokenTransactionHash);
+    }
+    for (const v of message.inputTtxoSignaturesPerOperator) {
+      InputTtxoSignaturesPerOperator.encode(v, writer.uint32(26).fork()).join();
+    }
+    if (message.ownerIdentityPublicKey.length !== 0) {
+      writer.uint32(34).bytes(message.ownerIdentityPublicKey);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseCommitTransactionRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.finalTokenTransaction = TokenTransaction2.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.finalTokenTransactionHash = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.inputTtxoSignaturesPerOperator.push(InputTtxoSignaturesPerOperator.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.ownerIdentityPublicKey = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      finalTokenTransaction: isSet6(object.finalTokenTransaction) ? TokenTransaction2.fromJSON(object.finalTokenTransaction) : void 0,
+      finalTokenTransactionHash: isSet6(object.finalTokenTransactionHash) ? bytesFromBase645(object.finalTokenTransactionHash) : new Uint8Array(0),
+      inputTtxoSignaturesPerOperator: globalThis.Array.isArray(object?.inputTtxoSignaturesPerOperator) ? object.inputTtxoSignaturesPerOperator.map((e) => InputTtxoSignaturesPerOperator.fromJSON(e)) : [],
+      ownerIdentityPublicKey: isSet6(object.ownerIdentityPublicKey) ? bytesFromBase645(object.ownerIdentityPublicKey) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.finalTokenTransaction !== void 0) {
+      obj.finalTokenTransaction = TokenTransaction2.toJSON(message.finalTokenTransaction);
+    }
+    if (message.finalTokenTransactionHash.length !== 0) {
+      obj.finalTokenTransactionHash = base64FromBytes5(message.finalTokenTransactionHash);
+    }
+    if (message.inputTtxoSignaturesPerOperator?.length) {
+      obj.inputTtxoSignaturesPerOperator = message.inputTtxoSignaturesPerOperator.map(
+        (e) => InputTtxoSignaturesPerOperator.toJSON(e)
+      );
+    }
+    if (message.ownerIdentityPublicKey.length !== 0) {
+      obj.ownerIdentityPublicKey = base64FromBytes5(message.ownerIdentityPublicKey);
+    }
+    return obj;
+  },
+  create(base) {
+    return CommitTransactionRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseCommitTransactionRequest();
+    message.finalTokenTransaction = object.finalTokenTransaction !== void 0 && object.finalTokenTransaction !== null ? TokenTransaction2.fromPartial(object.finalTokenTransaction) : void 0;
+    message.finalTokenTransactionHash = object.finalTokenTransactionHash ?? new Uint8Array(0);
+    message.inputTtxoSignaturesPerOperator = object.inputTtxoSignaturesPerOperator?.map((e) => InputTtxoSignaturesPerOperator.fromPartial(e)) || [];
+    message.ownerIdentityPublicKey = object.ownerIdentityPublicKey ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseCommitTransactionResponse() {
+  return {};
+}
+var CommitTransactionResponse = {
+  encode(_, writer = new import_wire7.BinaryWriter()) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseCommitTransactionResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(_) {
+    return {};
+  },
+  toJSON(_) {
+    const obj = {};
+    return obj;
+  },
+  create(base) {
+    return CommitTransactionResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseCommitTransactionResponse();
+    return message;
+  }
+};
+var SparkTokenServiceDefinition = {
+  name: "SparkTokenService",
+  fullName: "spark_token.SparkTokenService",
+  methods: {
+    /**
+     * Start process to create final token transaction with all inputs required
+     * from user and SOs (including revocation secret commitment)
+     */
+    start_transaction: {
+      name: "start_transaction",
+      requestType: StartTransactionRequest,
+      requestStream: false,
+      responseType: StartTransactionResponse,
+      responseStream: false,
+      options: {}
+    },
+    /**
+     * Complete the transaction and commit it with all SOs. This will be
+     * coordinated by one SO.
+     */
+    commit_transaction: {
+      name: "commit_transaction",
+      requestType: CommitTransactionRequest,
+      requestStream: false,
+      responseType: CommitTransactionResponse,
+      responseStream: false,
+      options: {}
+    }
+  }
+};
+function bytesFromBase645(b64) {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+function base64FromBytes5(arr) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+function toTimestamp2(date) {
+  const seconds = Math.trunc(date.getTime() / 1e3);
+  const nanos = date.getTime() % 1e3 * 1e6;
+  return { seconds, nanos };
+}
+function fromTimestamp2(t) {
+  let millis = (t.seconds || 0) * 1e3;
+  millis += (t.nanos || 0) / 1e6;
+  return new globalThis.Date(millis);
+}
+function fromJsonTimestamp2(o) {
+  if (o instanceof globalThis.Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new globalThis.Date(o);
+  } else {
+    return fromTimestamp2(Timestamp.fromJSON(o));
+  }
+}
+function longToNumber4(int64) {
+  const num = globalThis.Number(int64.toString());
+  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+  }
+  return num;
+}
+function isSet6(value) {
+  return value !== null && value !== void 0;
+}
+
 // src/services/connection.ts
 var ConnectionManager = class {
   config;
   clients = /* @__PURE__ */ new Map();
+  tokenClients = /* @__PURE__ */ new Map();
   // We are going to .unref() the underlying channels for stream clients
   // to prevent the stream from keeping the process alive
   // Using a different map to avoid unforeseen problems with unary calls
@@ -17920,6 +19118,22 @@ var ConnectionManager = class {
     this.clients.set(address2, { client, authToken });
     return client;
   }
+  async createSparkTokenClient(address2, certPath) {
+    if (this.tokenClients.has(address2)) {
+      return this.tokenClients.get(address2).client;
+    }
+    const authToken = await this.authenticate(address2);
+    const channel = await this.createChannelWithTLS(address2, certPath);
+    const middleware = this.createMiddleware(address2, authToken);
+    const tokenClient = await this.createGrpcClient(
+      SparkTokenServiceDefinition,
+      channel,
+      true,
+      middleware
+    );
+    this.tokenClients.set(address2, { client: tokenClient, authToken });
+    return tokenClient;
+  }
   async getStreamChannel(address2) {
     return this.streamClients.get(address2)?.channel;
   }