@buildonspark/spark-sdk 0.1.41 → 0.1.43

package/dist/index.cjs

@@ -1374,6 +1374,7 @@ init_buffer();
 
 // src/errors/base.ts
 init_buffer();
+var import_utils = require("@noble/hashes/utils");
 var SparkSDKError = class extends Error {
   context;
   originalError;
@@ -1405,12 +1406,42 @@ var SparkSDKError = class extends Error {
   }
 };
 function getMessage(message, context = {}, originalError) {
-  const contextStr = Object.entries(context).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+  const contextStr = Object.entries(context).map(([key, value]) => `${key}: ${safeStringify(value)}`).join(", ");
   const originalErrorStr = originalError ? `
 Original Error: ${originalError.message}` : "";
   return `SparkSDKError: ${message}${contextStr ? `
 Context: ${contextStr}` : ""}${originalErrorStr}`;
 }
+function safeStringify(value) {
+  const replacer = (_, v) => {
+    if (typeof v === "bigint") {
+      return v.toString();
+    }
+    if (v instanceof Uint8Array) {
+      return formatUint8Array(v);
+    }
+    return v;
+  };
+  if (typeof value === "bigint") {
+    return `"${value.toString()}"`;
+  }
+  if (value instanceof Uint8Array) {
+    return `"${formatUint8Array(value)}"`;
+  }
+  try {
+    const result = JSON.stringify(value, replacer);
+    return result === void 0 ? String(value) : result;
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return "[Unserializable]";
+    }
+  }
+}
+function formatUint8Array(arr) {
+  return `Uint8Array(0x${(0, import_utils.bytesToHex)(arr)})`;
+}
 
 // src/errors/types.ts
 init_buffer();
@@ -1452,8 +1483,8 @@ var NotImplementedError = class extends SparkSDKError {
 
 // src/spark-wallet/spark-wallet.ts
 init_buffer();
-var import_core12 = require("@lightsparkdev/core");
-var import_utils22 = require("@noble/curves/abstract/utils");
+var import_core14 = require("@lightsparkdev/core");
+var import_utils23 = require("@noble/curves/abstract/utils");
 var import_secp256k116 = require("@noble/curves/secp256k1");
 var import_bip392 = require("@scure/bip39");
 var import_english2 = require("@scure/bip39/wordlists/english");
@@ -1572,11 +1603,23 @@ var CurrencyAmountToJson = (obj) => {
   };
 };
 
+// src/graphql/objects/ExitSpeed.ts
+init_buffer();
+var ExitSpeed = /* @__PURE__ */ ((ExitSpeed2) => {
+  ExitSpeed2["FUTURE_VALUE"] = "FUTURE_VALUE";
+  ExitSpeed2["FAST"] = "FAST";
+  ExitSpeed2["MEDIUM"] = "MEDIUM";
+  ExitSpeed2["SLOW"] = "SLOW";
+  return ExitSpeed2;
+})(ExitSpeed || {});
+var ExitSpeed_default = ExitSpeed;
+
 // src/graphql/objects/SparkCoopExitRequestStatus.ts
 init_buffer();
 var SparkCoopExitRequestStatus = /* @__PURE__ */ ((SparkCoopExitRequestStatus2) => {
   SparkCoopExitRequestStatus2["FUTURE_VALUE"] = "FUTURE_VALUE";
   SparkCoopExitRequestStatus2["INITIATED"] = "INITIATED";
+  SparkCoopExitRequestStatus2["INBOUND_TRANSFER_CHECKED"] = "INBOUND_TRANSFER_CHECKED";
   SparkCoopExitRequestStatus2["TX_SIGNED"] = "TX_SIGNED";
   SparkCoopExitRequestStatus2["TX_BROADCASTED"] = "TX_BROADCASTED";
   SparkCoopExitRequestStatus2["WAITING_ON_TX_CONFIRMATIONS"] = "WAITING_ON_TX_CONFIRMATIONS";
@@ -1761,6 +1804,8 @@ var CoopExitRequestFromJson = (obj) => {
     rawCoopExitTransaction: obj["coop_exit_request_raw_coop_exit_transaction"],
     coopExitTxid: obj["coop_exit_request_coop_exit_txid"],
     typename: "CoopExitRequest",
+    feeQuoteId: obj["coop_exit_request_fee_quote"]?.id ?? void 0,
+    exitSpeed: !!obj["coop_exit_request_exit_speed"] ? ExitSpeed_default[obj["coop_exit_request_exit_speed"]] ?? ExitSpeed_default.FUTURE_VALUE : null,
     transfer: !!obj["coop_exit_request_transfer"] ? TransferFromJson(obj["coop_exit_request_transfer"]) : void 0
   };
 };
@@ -1787,6 +1832,10 @@ fragment CoopExitRequestFragment on CoopExitRequest {
         currency_amount_preferred_currency_value_rounded: preferred_currency_value_rounded
         currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
     }
+    coop_exit_request_fee_quote: fee_quote {
+        id
+    }
+    coop_exit_request_exit_speed: exit_speed
     coop_exit_request_status: status
     coop_exit_request_expires_at: expires_at
     coop_exit_request_raw_connector_transaction: raw_connector_transaction
@@ -1803,6 +1852,9 @@ fragment CoopExitRequestFragment on CoopExitRequest {
             currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
         }
         transfer_spark_id: spark_id
+        transfer_user_request: user_request {
+            id
+        }
     }
 }`;
 
@@ -1927,6 +1979,9 @@ fragment LeavesSwapRequestFragment on LeavesSwapRequest {
             currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
         }
         transfer_spark_id: spark_id
+        transfer_user_request: user_request {
+            id
+        }
     }
     leaves_swap_request_outbound_transfer: outbound_transfer {
         __typename
@@ -1939,6 +1994,9 @@ fragment LeavesSwapRequestFragment on LeavesSwapRequest {
             currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
         }
         transfer_spark_id: spark_id
+        transfer_user_request: user_request {
+            id
+        }
     }
     leaves_swap_request_expires_at: expires_at
     leaves_swap_request_swap_leaves: swap_leaves {
@@ -2072,7 +2130,8 @@ var LightningReceiveRequestFromJson = (obj) => {
     status: LightningReceiveRequestStatus_default[obj["lightning_receive_request_status"]] ?? LightningReceiveRequestStatus_default.FUTURE_VALUE,
     typename: "LightningReceiveRequest",
     transfer: !!obj["lightning_receive_request_transfer"] ? TransferFromJson(obj["lightning_receive_request_transfer"]) : void 0,
-    paymentPreimage: obj["lightning_receive_request_payment_preimage"]
+    paymentPreimage: obj["lightning_receive_request_payment_preimage"],
+    receiverIdentityPublicKey: obj["lightning_receive_request_receiver_identity_public_key"]
   };
 };
 var FRAGMENT6 = `
@@ -2111,8 +2170,12 @@ fragment LightningReceiveRequestFragment on LightningReceiveRequest {
             currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
         }
         transfer_spark_id: spark_id
+        transfer_user_request: user_request {
+            id
+        }
     }
     lightning_receive_request_payment_preimage: payment_preimage
+    lightning_receive_request_receiver_identity_public_key: receiver_identity_public_key
 }`;
 
 // src/graphql/mutations/RequestLightningReceive.ts
@@ -2214,6 +2277,9 @@ fragment LightningSendRequestFragment on LightningSendRequest {
             currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
         }
         transfer_spark_id: spark_id
+        transfer_user_request: user_request {
+            id
+        }
     }
     lightning_send_request_payment_preimage: payment_preimage
 }`;
@@ -2223,10 +2289,12 @@ var RequestLightningSend = `
   mutation RequestLightningSend(
     $encoded_invoice: String!
     $idempotency_key: String!
+    $amount_sats: Long
   ) {
     request_lightning_send(input: {
       encoded_invoice: $encoded_invoice
       idempotency_key: $idempotency_key
+      amount_sats: $amount_sats
     }) {
       request {
         ...LightningSendRequestFragment
@@ -2517,10 +2585,12 @@ init_buffer();
 var LightningSendFeeEstimate = `
   query LightningSendFeeEstimate(
     $encoded_invoice: String!
+    $amount_sats: Long
   ) {
     lightning_send_fee_estimate(
       input: {
         encoded_invoice: $encoded_invoice
+        amount_sats: $amount_sats
       }
     ) {
       ...LightningSendFeeEstimateOutputFragment
@@ -2604,6 +2674,10 @@ fragment UserRequestFragment on UserRequest {
             currency_amount_preferred_currency_value_rounded: preferred_currency_value_rounded
             currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
         }
+        coop_exit_request_fee_quote: fee_quote {
+            id
+        }
+        coop_exit_request_exit_speed: exit_speed
         coop_exit_request_status: status
         coop_exit_request_expires_at: expires_at
         coop_exit_request_raw_connector_transaction: raw_connector_transaction
@@ -2620,6 +2694,9 @@ fragment UserRequestFragment on UserRequest {
                 currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
             }
             transfer_spark_id: spark_id
+            transfer_user_request: user_request {
+                id
+            }
         }
     }
     ... on LeavesSwapRequest {
@@ -2664,6 +2741,9 @@ fragment UserRequestFragment on UserRequest {
                 currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
             }
             transfer_spark_id: spark_id
+            transfer_user_request: user_request {
+                id
+            }
         }
         leaves_swap_request_outbound_transfer: outbound_transfer {
             __typename
@@ -2676,6 +2756,9 @@ fragment UserRequestFragment on UserRequest {
                 currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
             }
             transfer_spark_id: spark_id
+            transfer_user_request: user_request {
+                id
+            }
         }
         leaves_swap_request_expires_at: expires_at
         leaves_swap_request_swap_leaves: swap_leaves {
@@ -2720,8 +2803,12 @@ fragment UserRequestFragment on UserRequest {
                 currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
             }
             transfer_spark_id: spark_id
+            transfer_user_request: user_request {
+                id
+            }
         }
         lightning_receive_request_payment_preimage: payment_preimage
+        lightning_receive_request_receiver_identity_public_key: receiver_identity_public_key
     }
     ... on LightningSendRequest {
         __typename
@@ -2751,6 +2838,9 @@ fragment UserRequestFragment on UserRequest {
                 currency_amount_preferred_currency_value_approx: preferred_currency_value_approx
             }
             transfer_spark_id: spark_id
+            transfer_user_request: user_request {
+                id
+            }
         }
         lightning_send_request_payment_preimage: payment_preimage
     }
@@ -2831,11 +2921,12 @@ var SspClient = class {
       }
     });
   }
-  async getLightningSendFeeEstimate(encodedInvoice) {
+  async getLightningSendFeeEstimate(encodedInvoice, amountSats) {
     return await this.executeRawQuery({
       queryPayload: LightningSendFeeEstimate,
       variables: {
-        encoded_invoice: encodedInvoice
+        encoded_invoice: encodedInvoice,
+        amount_sats: amountSats
       },
       constructObject: (response) => {
         return LightningSendFeeEstimateOutputFromJson(
@@ -2931,13 +3022,15 @@ var SspClient = class {
   }
   async requestLightningSend({
     encodedInvoice,
-    idempotencyKey
+    idempotencyKey,
+    amountSats
   }) {
     return await this.executeRawQuery({
       queryPayload: RequestLightningSend,
       variables: {
         encoded_invoice: encodedInvoice,
-        idempotency_key: idempotencyKey
+        idempotency_key: idempotencyKey,
+        amount_sats: amountSats
       },
       constructObject: (response) => {
         return LightningSendRequestFromJson(
@@ -3197,16 +3290,9 @@ init_buffer();
 init_buffer();
 var import_core7 = require("@lightsparkdev/core");
 
-// src/graphql/objects/ExitSpeed.ts
+// src/graphql/objects/CoopExitFeeQuote.ts
 init_buffer();
-var ExitSpeed = /* @__PURE__ */ ((ExitSpeed2) => {
-  ExitSpeed2["FUTURE_VALUE"] = "FUTURE_VALUE";
-  ExitSpeed2["FAST"] = "FAST";
-  ExitSpeed2["MEDIUM"] = "MEDIUM";
-  ExitSpeed2["SLOW"] = "SLOW";
-  return ExitSpeed2;
-})(ExitSpeed || {});
-var ExitSpeed_default = ExitSpeed;
+var import_core8 = require("@lightsparkdev/core");
 
 // src/graphql/objects/SparkUserRequestStatus.ts
 init_buffer();
@@ -3216,7 +3302,7 @@ init_buffer();
 
 // src/graphql/objects/SparkWalletUser.ts
 init_buffer();
-var import_core8 = require("@lightsparkdev/core");
+var import_core9 = require("@lightsparkdev/core");
 
 // src/graphql/objects/SparkWalletUserToUserRequestsConnection.ts
 init_buffer();
@@ -4121,7 +4207,7 @@ var DepositAddressProof = {
   },
   fromJSON(object) {
     return {
-      addressSignatures: isObject8(object.addressSignatures) ? Object.entries(object.addressSignatures).reduce((acc, [key, value]) => {
+      addressSignatures: isObject9(object.addressSignatures) ? Object.entries(object.addressSignatures).reduce((acc, [key, value]) => {
         acc[key] = bytesFromBase642(value);
         return acc;
       }, {}) : {},
@@ -4903,18 +4989,18 @@ var SigningResult = {
   },
   fromJSON(object) {
     return {
-      publicKeys: isObject8(object.publicKeys) ? Object.entries(object.publicKeys).reduce((acc, [key, value]) => {
+      publicKeys: isObject9(object.publicKeys) ? Object.entries(object.publicKeys).reduce((acc, [key, value]) => {
         acc[key] = bytesFromBase642(value);
         return acc;
       }, {}) : {},
-      signingNonceCommitments: isObject8(object.signingNonceCommitments) ? Object.entries(object.signingNonceCommitments).reduce(
+      signingNonceCommitments: isObject9(object.signingNonceCommitments) ? Object.entries(object.signingNonceCommitments).reduce(
         (acc, [key, value]) => {
           acc[key] = SigningCommitment.fromJSON(value);
           return acc;
         },
         {}
       ) : {},
-      signatureShares: isObject8(object.signatureShares) ? Object.entries(object.signatureShares).reduce((acc, [key, value]) => {
+      signatureShares: isObject9(object.signatureShares) ? Object.entries(object.signatureShares).reduce((acc, [key, value]) => {
         acc[key] = bytesFromBase642(value);
         return acc;
       }, {}) : {},
@@ -8942,7 +9028,7 @@ var TransferPackage = {
   fromJSON(object) {
     return {
       leavesToSend: globalThis.Array.isArray(object?.leavesToSend) ? object.leavesToSend.map((e) => UserSignedTxSigningJob.fromJSON(e)) : [],
-      keyTweakPackage: isObject8(object.keyTweakPackage) ? Object.entries(object.keyTweakPackage).reduce((acc, [key, value]) => {
+      keyTweakPackage: isObject9(object.keyTweakPackage) ? Object.entries(object.keyTweakPackage).reduce((acc, [key, value]) => {
         acc[key] = bytesFromBase642(value);
         return acc;
       }, {}) : {},
@@ -9204,7 +9290,7 @@ var SendLeafKeyTweak = {
     return {
       leafId: isSet3(object.leafId) ? globalThis.String(object.leafId) : "",
       secretShareTweak: isSet3(object.secretShareTweak) ? SecretShare.fromJSON(object.secretShareTweak) : void 0,
-      pubkeySharesTweak: isObject8(object.pubkeySharesTweak) ? Object.entries(object.pubkeySharesTweak).reduce((acc, [key, value]) => {
+      pubkeySharesTweak: isObject9(object.pubkeySharesTweak) ? Object.entries(object.pubkeySharesTweak).reduce((acc, [key, value]) => {
         acc[key] = bytesFromBase642(value);
         return acc;
       }, {}) : {},
@@ -10177,7 +10263,7 @@ var ClaimLeafKeyTweak = {
     return {
       leafId: isSet3(object.leafId) ? globalThis.String(object.leafId) : "",
       secretShareTweak: isSet3(object.secretShareTweak) ? SecretShare.fromJSON(object.secretShareTweak) : void 0,
-      pubkeySharesTweak: isObject8(object.pubkeySharesTweak) ? Object.entries(object.pubkeySharesTweak).reduce((acc, [key, value]) => {
+      pubkeySharesTweak: isObject9(object.pubkeySharesTweak) ? Object.entries(object.pubkeySharesTweak).reduce((acc, [key, value]) => {
         acc[key] = bytesFromBase642(value);
         return acc;
       }, {}) : {}
@@ -10853,7 +10939,7 @@ var RequestedSigningCommitments = {
   },
   fromJSON(object) {
     return {
-      signingNonceCommitments: isObject8(object.signingNonceCommitments) ? Object.entries(object.signingNonceCommitments).reduce(
+      signingNonceCommitments: isObject9(object.signingNonceCommitments) ? Object.entries(object.signingNonceCommitments).reduce(
         (acc, [key, value]) => {
           acc[key] = SigningCommitment.fromJSON(value);
           return acc;
@@ -11100,7 +11186,7 @@ var SigningCommitments = {
   },
   fromJSON(object) {
     return {
-      signingCommitments: isObject8(object.signingCommitments) ? Object.entries(object.signingCommitments).reduce(
+      signingCommitments: isObject9(object.signingCommitments) ? Object.entries(object.signingCommitments).reduce(
         (acc, [key, value]) => {
           acc[key] = SigningCommitment.fromJSON(value);
           return acc;
@@ -13201,7 +13287,7 @@ var GetSigningOperatorListResponse = {
   },
   fromJSON(object) {
     return {
-      signingOperators: isObject8(object.signingOperators) ? Object.entries(object.signingOperators).reduce(
+      signingOperators: isObject9(object.signingOperators) ? Object.entries(object.signingOperators).reduce(
         (acc, [key, value]) => {
           acc[key] = SigningOperatorInfo.fromJSON(value);
           return acc;
@@ -13868,7 +13954,7 @@ var QueryNodesResponse = {
   },
   fromJSON(object) {
     return {
-      nodes: isObject8(object.nodes) ? Object.entries(object.nodes).reduce((acc, [key, value]) => {
+      nodes: isObject9(object.nodes) ? Object.entries(object.nodes).reduce((acc, [key, value]) => {
         acc[key] = TreeNode.fromJSON(value);
         return acc;
       }, {}) : {},
@@ -14584,7 +14670,7 @@ var QueryBalanceResponse = {
   fromJSON(object) {
     return {
       balance: isSet3(object.balance) ? globalThis.Number(object.balance) : 0,
-      nodeBalances: isObject8(object.nodeBalances) ? Object.entries(object.nodeBalances).reduce((acc, [key, value]) => {
+      nodeBalances: isObject9(object.nodeBalances) ? Object.entries(object.nodeBalances).reduce((acc, [key, value]) => {
         acc[key] = Number(value);
         return acc;
       }, {}) : {}
@@ -15594,7 +15680,7 @@ var QueryNodesDistributionResponse = {
   },
   fromJSON(object) {
     return {
-      nodeDistribution: isObject8(object.nodeDistribution) ? Object.entries(object.nodeDistribution).reduce((acc, [key, value]) => {
+      nodeDistribution: isObject9(object.nodeDistribution) ? Object.entries(object.nodeDistribution).reduce((acc, [key, value]) => {
         acc[globalThis.Number(key)] = Number(value);
         return acc;
       }, {}) : {}
@@ -15843,7 +15929,7 @@ var QueryNodesByValueResponse = {
   },
   fromJSON(object) {
     return {
-      nodes: isObject8(object.nodes) ? Object.entries(object.nodes).reduce((acc, [key, value]) => {
+      nodes: isObject9(object.nodes) ? Object.entries(object.nodes).reduce((acc, [key, value]) => {
         acc[key] = TreeNode.fromJSON(value);
         return acc;
       }, {}) : {},
@@ -16371,7 +16457,7 @@ function longToNumber2(int64) {
   }
   return num;
 }
-function isObject8(value) {
+function isObject9(value) {
   return typeof value === "object" && value !== null;
 }
 function isSet3(value) {
@@ -16383,7 +16469,7 @@ init_buffer();
 
 // src/signer/signer.ts
 init_buffer();
-var import_utils4 = require("@noble/curves/abstract/utils");
+var import_utils5 = require("@noble/curves/abstract/utils");
 var import_secp256k15 = require("@noble/curves/secp256k1");
 var import_bip32 = require("@scure/bip32");
 var import_bip39 = require("@scure/bip39");
@@ -16392,29 +16478,41 @@ var ecies = __toESM(require("eciesjs"), 1);
 
 // src/constants.ts
 init_buffer();
+var import_core10 = require("@lightsparkdev/core");
 var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 var isBun = globalThis.Bun !== void 0;
+var packageVersion = true ? "0.1.43" : "unknown";
+var baseEnvStr = "unknown";
+if (import_core10.isNode) {
+  baseEnvStr = `node/${process.version}`;
+} else if (isReactNative) {
+  baseEnvStr = "react-native";
+} else {
+  const userAgent = typeof navigator !== "undefined" && navigator.userAgent || "unknown-user-agent";
+  baseEnvStr = `browser/${userAgent}`;
+}
+var clientEnv = `js-spark-sdk/${packageVersion} ${baseEnvStr}`;
 
 // src/utils/adaptor-signature.ts
 init_buffer();
 var import_modular = require("@noble/curves/abstract/modular");
-var import_utils = require("@noble/curves/abstract/utils");
+var import_utils2 = require("@noble/curves/abstract/utils");
 var import_secp256k1 = require("@noble/curves/secp256k1");
 function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
   const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils.bytesToNumberBE)(s);
-  const tBigInt = (0, import_utils.bytesToNumberBE)(adaptorPrivateKeyBytes);
+  const sBigInt = (0, import_utils2.bytesToNumberBE)(s);
+  const tBigInt = (0, import_utils2.bytesToNumberBE)(adaptorPrivateKeyBytes);
   const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k1.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils.numberToBytesBE)(newS, 32)]);
+  const newSignature = new Uint8Array([...r, ...(0, import_utils2.numberToBytesBE)(newS, 32)]);
   return newSignature;
 }
 function generateAdaptorFromSignature(signature) {
   const adaptorPrivateKey = import_secp256k1.secp256k1.utils.randomPrivateKey();
   const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils.bytesToNumberBE)(s);
-  const tBigInt = (0, import_utils.bytesToNumberBE)(adaptorPrivateKey);
+  const sBigInt = (0, import_utils2.bytesToNumberBE)(s);
+  const tBigInt = (0, import_utils2.bytesToNumberBE)(adaptorPrivateKey);
   const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k1.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils.numberToBytesBE)(newS, 32)]);
+  const newSignature = new Uint8Array([...r, ...(0, import_utils2.numberToBytesBE)(newS, 32)]);
   return {
     adaptorSignature: newSignature,
     adaptorPrivateKey
@@ -16431,15 +16529,15 @@ function validateOutboundAdaptorSignature(pubkey, hash, signature, adaptorPubkey
 }
 function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes) {
   const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils.bytesToNumberBE)(s);
-  const adaptorPrivateKey = (0, import_utils.bytesToNumberBE)(adaptorPrivateKeyBytes);
+  const sBigInt = (0, import_utils2.bytesToNumberBE)(s);
+  const adaptorPrivateKey = (0, import_utils2.bytesToNumberBE)(adaptorPrivateKeyBytes);
   const newS = (0, import_modular.mod)(sBigInt + adaptorPrivateKey, import_secp256k1.secp256k1.CURVE.n);
-  const newSig = new Uint8Array([...r, ...(0, import_utils.numberToBytesBE)(newS, 32)]);
+  const newSig = new Uint8Array([...r, ...(0, import_utils2.numberToBytesBE)(newS, 32)]);
   if (import_secp256k1.schnorr.verify(newSig, hash, pubkey)) {
     return newSig;
   }
   const altS = (0, import_modular.mod)(sBigInt - adaptorPrivateKey, import_secp256k1.secp256k1.CURVE.n);
-  const altSig = new Uint8Array([...r, ...(0, import_utils.numberToBytesBE)(altS, 32)]);
+  const altSig = new Uint8Array([...r, ...(0, import_utils2.numberToBytesBE)(altS, 32)]);
   if (import_secp256k1.schnorr.verify(altSig, hash, pubkey)) {
     return altSig;
   }
@@ -16449,7 +16547,7 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   if (hash.length !== 32) {
     throw new Error(`wrong size for message (got ${hash.length}, want 32)`);
   }
-  const pubKey = import_secp256k1.schnorr.utils.lift_x((0, import_utils.bytesToNumberBE)(pubKeyBytes));
+  const pubKey = import_secp256k1.schnorr.utils.lift_x((0, import_utils2.bytesToNumberBE)(pubKeyBytes));
   pubKey.assertValidity();
   const { r, s } = parseSignature(signature);
   const commitmenet = import_secp256k1.schnorr.utils.taggedHash(
@@ -16461,11 +16559,11 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   if (commitmenet.length > 32) {
     throw new Error("hash of (r || P || m) too big");
   }
-  const e = (0, import_modular.mod)((0, import_utils.bytesToNumberBE)(commitmenet), import_secp256k1.secp256k1.CURVE.n);
+  const e = (0, import_modular.mod)((0, import_utils2.bytesToNumberBE)(commitmenet), import_secp256k1.secp256k1.CURVE.n);
   const negE = (0, import_modular.mod)(-e, import_secp256k1.secp256k1.CURVE.n);
   const R = import_secp256k1.secp256k1.ProjectivePoint.BASE.multiplyAndAddUnsafe(
     pubKey,
-    (0, import_utils.bytesToNumberBE)(s),
+    (0, import_utils2.bytesToNumberBE)(s),
     negE
   );
   if (!R) {
@@ -16481,7 +16579,7 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   if (!newR.hasEvenY()) {
     throw new Error("calculated R y-value is odd");
   }
-  const rNum = (0, import_utils.bytesToNumberBE)(r);
+  const rNum = (0, import_utils2.bytesToNumberBE)(r);
   if (newR.toAffine().x !== rNum) {
     throw new Error("calculated R point was not given R");
   }
@@ -16502,15 +16600,15 @@ function parseSignature(signature) {
   }
   const r = signature.slice(0, 32);
   const s = signature.slice(32, 64);
-  if ((0, import_utils.bytesToNumberBE)(r) >= import_secp256k1.secp256k1.CURVE.Fp.ORDER) {
+  if ((0, import_utils2.bytesToNumberBE)(r) >= import_secp256k1.secp256k1.CURVE.Fp.ORDER) {
     throw new ValidationError("Invalid signature: r >= field prime", {
-      rValue: (0, import_utils.bytesToNumberBE)(r),
+      rValue: (0, import_utils2.bytesToNumberBE)(r),
       fieldPrime: import_secp256k1.secp256k1.CURVE.Fp.ORDER
     });
   }
-  if ((0, import_utils.bytesToNumberBE)(s) >= import_secp256k1.secp256k1.CURVE.n) {
+  if ((0, import_utils2.bytesToNumberBE)(s) >= import_secp256k1.secp256k1.CURVE.n) {
     throw new ValidationError("Invalid signature: s >= group order", {
-      sValue: (0, import_utils.bytesToNumberBE)(s),
+      sValue: (0, import_utils2.bytesToNumberBE)(s),
       groupOrder: import_secp256k1.secp256k1.CURVE.n
     });
   }
@@ -16519,7 +16617,7 @@ function parseSignature(signature) {
 
 // src/utils/keys.ts
 init_buffer();
-var import_utils2 = require("@noble/curves/abstract/utils");
+var import_utils3 = require("@noble/curves/abstract/utils");
 var import_secp256k12 = require("@noble/curves/secp256k1");
 function addPublicKeys(a, b) {
   if (a.length !== 33 || b.length !== 33) {
@@ -16577,7 +16675,7 @@ function addPrivateKeys(a, b) {
   const privA = import_secp256k12.secp256k1.utils.normPrivateKeyToScalar(a);
   const privB = import_secp256k12.secp256k1.utils.normPrivateKeyToScalar(b);
   const sum = (privA + privB) % import_secp256k12.secp256k1.CURVE.n;
-  return (0, import_utils2.numberToBytesBE)(sum, 32);
+  return (0, import_utils3.numberToBytesBE)(sum, 32);
 }
 function subtractPrivateKeys(a, b) {
   if (a.length !== 32 || b.length !== 32) {
@@ -16590,7 +16688,7 @@ function subtractPrivateKeys(a, b) {
   const privA = import_secp256k12.secp256k1.utils.normPrivateKeyToScalar(a);
   const privB = import_secp256k12.secp256k1.utils.normPrivateKeyToScalar(b);
   const sum = (import_secp256k12.secp256k1.CURVE.n - privB + privA) % import_secp256k12.secp256k1.CURVE.n;
-  return (0, import_utils2.numberToBytesBE)(sum, 32);
+  return (0, import_utils3.numberToBytesBE)(sum, 32);
 }
 function sumOfPrivateKeys(keys) {
   return keys.reduce((sum, key) => {
@@ -16618,7 +16716,7 @@ function lastKeyWithTarget(target, keys) {
 
 // src/utils/secret-sharing.ts
 init_buffer();
-var import_utils3 = require("@noble/curves/abstract/utils");
+var import_utils4 = require("@noble/curves/abstract/utils");
 var import_secp256k13 = require("@noble/curves/secp256k1");
 
 // src/utils/crypto.ts
@@ -16637,7 +16735,7 @@ function getRandomBigInt(max) {
   const mask = (1n << BigInt(max.toString(2).length)) - 1n;
   while (true) {
     const randBytes = crypto.getRandomValues(new Uint8Array(byteLength + 1));
-    const randValue = BigInt("0x" + (0, import_utils3.bytesToHex)(randBytes)) & mask;
+    const randValue = BigInt("0x" + (0, import_utils4.bytesToHex)(randBytes)) & mask;
     if (randValue < maxBigInt) {
       return randValue;
     }
@@ -16815,7 +16913,7 @@ function validateShare(share) {
     const scaledPoint = import_secp256k13.secp256k1.ProjectivePoint.fromHex(pubkey).multiply(value);
     resultPubkey = import_secp256k13.secp256k1.ProjectivePoint.fromHex(resultPubkey).add(scaledPoint).toRawBytes(true);
   }
-  if (!(0, import_utils3.equalBytes)(resultPubkey, targetPubkey)) {
+  if (!(0, import_utils4.equalBytes)(resultPubkey, targetPubkey)) {
     throw new ValidationError("Share is not valid", {
       field: "share",
       value: "Invalid proof",
@@ -16918,7 +17016,9 @@ function decodeBytesToSigningCommitment(bytes2) {
 var import_secp256k16 = require("@bitcoinerlab/secp256k1");
 var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
 var import_sha22 = require("@noble/hashes/sha2");
-var import_utils5 = require("@scure/btc-signer/utils");
+var import_utils6 = require("@scure/btc-signer/utils");
+var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
+var import_types2 = require("@buildonspark/lrc20-sdk/lrc/types");
 var sparkFrostModule = void 0;
 var getSparkFrostModule = async () => {
   if (isReactNative) {
@@ -17017,28 +17117,28 @@ var DefaultSparkSigner = class {
       const privateKey = this.deriveSigningKey(hash);
       const publicKey = import_secp256k15.secp256k1.getPublicKey(privateKey);
       this.publicKeyToPrivateKeyMap.set(
-        (0, import_utils4.bytesToHex)(publicKey),
-        (0, import_utils4.bytesToHex)(privateKey)
+        (0, import_utils5.bytesToHex)(publicKey),
+        (0, import_utils5.bytesToHex)(privateKey)
       );
     }
   }
   async getSchnorrPublicKey(publicKey) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey));
+    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils5.bytesToHex)(publicKey));
     if (!privateKey) {
       throw new ValidationError("Private key is not set", {
         field: "privateKey"
       });
     }
-    return import_secp256k15.schnorr.getPublicKey((0, import_utils4.hexToBytes)(privateKey));
+    return import_secp256k15.schnorr.getPublicKey((0, import_utils5.hexToBytes)(privateKey));
   }
   async signSchnorr(message, publicKey) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey));
+    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils5.bytesToHex)(publicKey));
     if (!privateKey) {
       throw new ValidationError("Private key is not set", {
         field: "privateKey"
       });
     }
-    return import_secp256k15.schnorr.sign(message, (0, import_utils4.hexToBytes)(privateKey));
+    return import_secp256k15.schnorr.sign(message, (0, import_utils5.hexToBytes)(privateKey));
   }
   async signSchnorrWithIdentityKey(message) {
     if (!this.identityKey?.privateKey) {
@@ -17080,8 +17180,8 @@ var DefaultSparkSigner = class {
     );
     this.staticDepositKeyMap.set(idx, staticDepositKey);
     this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(staticDepositKey.publicKey),
-      (0, import_utils4.bytesToHex)(staticDepositKey.privateKey)
+      (0, import_utils5.bytesToHex)(staticDepositKey.publicKey),
+      (0, import_utils5.bytesToHex)(staticDepositKey.privateKey)
     );
     return staticDepositKey.publicKey;
   }
@@ -17126,7 +17226,7 @@ var DefaultSparkSigner = class {
     return await (0, import_bip39.mnemonicToSeed)(mnemonic);
   }
   async getTrackedPublicKeys() {
-    return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(import_utils4.hexToBytes);
+    return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(import_utils5.hexToBytes);
   }
   async generatePublicKey(hash) {
     if (!this.signingKey) {
@@ -17146,31 +17246,31 @@ var DefaultSparkSigner = class {
       });
     }
     const publicKey = import_secp256k15.secp256k1.getPublicKey(newPrivateKey);
-    const pubKeyHex = (0, import_utils4.bytesToHex)(publicKey);
-    const privKeyHex = (0, import_utils4.bytesToHex)(newPrivateKey);
+    const pubKeyHex = (0, import_utils5.bytesToHex)(publicKey);
+    const privKeyHex = (0, import_utils5.bytesToHex)(newPrivateKey);
     this.publicKeyToPrivateKeyMap.set(pubKeyHex, privKeyHex);
     return publicKey;
   }
   async removePublicKey(publicKey) {
-    this.publicKeyToPrivateKeyMap.delete((0, import_utils4.bytesToHex)(publicKey));
+    this.publicKeyToPrivateKeyMap.delete((0, import_utils5.bytesToHex)(publicKey));
   }
   async subtractPrivateKeysGivenPublicKeys(first, second) {
-    const firstPubKeyHex = (0, import_utils4.bytesToHex)(first);
-    const secondPubKeyHex = (0, import_utils4.bytesToHex)(second);
+    const firstPubKeyHex = (0, import_utils5.bytesToHex)(first);
+    const secondPubKeyHex = (0, import_utils5.bytesToHex)(second);
     const firstPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(firstPubKeyHex);
     const secondPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(secondPubKeyHex);
     if (!firstPrivateKeyHex || !secondPrivateKeyHex) {
       throw new Error("Private key is not set");
     }
-    const firstPrivateKey = (0, import_utils4.hexToBytes)(firstPrivateKeyHex);
-    const secondPrivateKey = (0, import_utils4.hexToBytes)(secondPrivateKeyHex);
+    const firstPrivateKey = (0, import_utils5.hexToBytes)(firstPrivateKeyHex);
+    const secondPrivateKey = (0, import_utils5.hexToBytes)(secondPrivateKeyHex);
     const resultPrivKey = subtractPrivateKeys(
       firstPrivateKey,
       secondPrivateKey
     );
     const resultPubKey = import_secp256k15.secp256k1.getPublicKey(resultPrivKey);
-    const resultPrivKeyHex = (0, import_utils4.bytesToHex)(resultPrivKey);
-    const resultPubKeyHex = (0, import_utils4.bytesToHex)(resultPubKey);
+    const resultPrivKeyHex = (0, import_utils5.bytesToHex)(resultPrivKey);
+    const resultPubKeyHex = (0, import_utils5.bytesToHex)(resultPubKey);
     this.publicKeyToPrivateKeyMap.set(resultPubKeyHex, resultPrivKeyHex);
     return resultPubKey;
   }
@@ -17182,14 +17282,14 @@ var DefaultSparkSigner = class {
     isSecretPubkey = false
   }) {
     if (isSecretPubkey) {
-      const pubKeyHex = (0, import_utils4.bytesToHex)(secret);
+      const pubKeyHex = (0, import_utils5.bytesToHex)(secret);
       const privateKey = this.publicKeyToPrivateKeyMap.get(pubKeyHex);
       if (!privateKey) {
         throw new Error("Private key is not set");
       }
-      secret = (0, import_utils4.hexToBytes)(privateKey);
+      secret = (0, import_utils5.hexToBytes)(privateKey);
     }
-    const secretAsInt = (0, import_utils4.bytesToNumberBE)(secret);
+    const secretAsInt = (0, import_utils5.bytesToNumberBE)(secret);
     return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
   }
   async signFrost({
@@ -17207,7 +17307,7 @@ var DefaultSparkSigner = class {
         field: "SparkFrost"
       });
     }
-    const privateAsPubKeyHex = (0, import_utils4.bytesToHex)(privateAsPubKey);
+    const privateAsPubKeyHex = (0, import_utils5.bytesToHex)(privateAsPubKey);
     const signingPrivateKey = this.publicKeyToPrivateKeyMap.get(privateAsPubKeyHex);
     if (!signingPrivateKey) {
       throw new ValidationError("Private key not found for public key", {
@@ -17221,7 +17321,7 @@ var DefaultSparkSigner = class {
       });
     }
     const keyPackage = {
-      secretKey: (0, import_utils4.hexToBytes)(signingPrivateKey),
+      secretKey: (0, import_utils5.hexToBytes)(signingPrivateKey),
       publicKey,
       verifyingKey
     };
@@ -17265,7 +17365,7 @@ var DefaultSparkSigner = class {
   }
   async createSparkWalletFromSeed(seed, accountNumber) {
     if (typeof seed === "string") {
-      seed = (0, import_utils4.hexToBytes)(seed);
+      seed = (0, import_utils5.hexToBytes)(seed);
     }
     const {
       masterPublicKey,
@@ -17280,28 +17380,28 @@ var DefaultSparkSigner = class {
     this.signingKey = signingKey.hdKey;
     this.staticDepositKey = staticDepositKey.hdKey;
     this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(identityKey.publicKey),
-      (0, import_utils4.bytesToHex)(identityKey.privateKey)
+      (0, import_utils5.bytesToHex)(identityKey.publicKey),
+      (0, import_utils5.bytesToHex)(identityKey.privateKey)
     );
     this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(depositKey.publicKey),
-      (0, import_utils4.bytesToHex)(depositKey.privateKey)
+      (0, import_utils5.bytesToHex)(depositKey.publicKey),
+      (0, import_utils5.bytesToHex)(depositKey.privateKey)
     );
     this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(staticDepositKey.publicKey),
-      (0, import_utils4.bytesToHex)(staticDepositKey.privateKey)
+      (0, import_utils5.bytesToHex)(staticDepositKey.publicKey),
+      (0, import_utils5.bytesToHex)(staticDepositKey.privateKey)
     );
-    return (0, import_utils4.bytesToHex)(identityKey.publicKey);
+    return (0, import_utils5.bytesToHex)(identityKey.publicKey);
   }
   async signMessageWithPublicKey(message, publicKey, compact) {
-    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey));
+    const privateKey = this.publicKeyToPrivateKeyMap.get((0, import_utils5.bytesToHex)(publicKey));
     if (!privateKey) {
       throw new ValidationError("Private key not found for public key", {
         field: "privateKey",
-        value: (0, import_utils4.bytesToHex)(publicKey)
+        value: (0, import_utils5.bytesToHex)(publicKey)
       });
     }
-    const signature = import_secp256k15.secp256k1.sign(message, (0, import_utils4.hexToBytes)(privateKey));
+    const signature = import_secp256k15.secp256k1.sign(message, (0, import_utils5.hexToBytes)(privateKey));
     if (compact) {
       return signature.toCompactRawBytes();
     }
@@ -17320,12 +17420,12 @@ var DefaultSparkSigner = class {
     return signature.toDERRawBytes();
   }
   async encryptLeafPrivateKeyEcies(receiverPublicKey, publicKey) {
-    const publicKeyHex = (0, import_utils4.bytesToHex)(publicKey);
+    const publicKeyHex = (0, import_utils5.bytesToHex)(publicKey);
     const privateKey = this.publicKeyToPrivateKeyMap.get(publicKeyHex);
     if (!privateKey) {
       throw new Error("Private key is not set");
     }
-    return ecies.encrypt(receiverPublicKey, (0, import_utils4.hexToBytes)(privateKey));
+    return ecies.encrypt(receiverPublicKey, (0, import_utils5.hexToBytes)(privateKey));
   }
   async decryptEcies(ciphertext) {
     if (!this.identityKey?.privateKey) {
@@ -17334,12 +17434,12 @@ var DefaultSparkSigner = class {
       });
     }
     const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
-      (0, import_utils4.bytesToHex)(this.identityKey.privateKey)
+      (0, import_utils5.bytesToHex)(this.identityKey.privateKey)
     );
     const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
     const publicKey = import_secp256k15.secp256k1.getPublicKey(privateKey);
-    const publicKeyHex = (0, import_utils4.bytesToHex)(publicKey);
-    const privateKeyHex = (0, import_utils4.bytesToHex)(privateKey);
+    const publicKeyHex = (0, import_utils5.bytesToHex)(publicKey);
+    const privateKeyHex = (0, import_utils5.bytesToHex)(privateKey);
     this.publicKeyToPrivateKeyMap.set(publicKeyHex, privateKeyHex);
     return publicKey;
   }
@@ -17356,8 +17456,8 @@ var DefaultSparkSigner = class {
     const adaptor = generateAdaptorFromSignature(signature);
     const adaptorPublicKey = import_secp256k15.secp256k1.getPublicKey(adaptor.adaptorPrivateKey);
     this.publicKeyToPrivateKeyMap.set(
-      (0, import_utils4.bytesToHex)(adaptorPublicKey),
-      (0, import_utils4.bytesToHex)(adaptor.adaptorPrivateKey)
+      (0, import_utils5.bytesToHex)(adaptorPublicKey),
+      (0, import_utils5.bytesToHex)(adaptor.adaptorPrivateKey)
     );
     return {
       adaptorSignature: signature,
@@ -17408,19 +17508,19 @@ var DefaultSparkSigner = class {
   }
   signTransactionIndex(tx, index, publicKey) {
     let privateKey;
-    if ((0, import_utils4.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+    if ((0, import_utils5.equalBytes)(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
       privateKey = this.identityKey?.privateKey;
-    } else if ((0, import_utils4.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+    } else if ((0, import_utils5.equalBytes)(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
       privateKey = this.depositKey?.privateKey;
     } else {
-      privateKey = (0, import_utils4.hexToBytes)(
-        this.publicKeyToPrivateKeyMap.get((0, import_utils4.bytesToHex)(publicKey)) ?? ""
+      privateKey = (0, import_utils5.hexToBytes)(
+        this.publicKeyToPrivateKeyMap.get((0, import_utils5.bytesToHex)(publicKey)) ?? ""
       );
     }
     if (!privateKey) {
       throw new ValidationError("Private key not found for public key", {
         field: "privateKey",
-        value: (0, import_utils4.bytesToHex)(publicKey)
+        value: (0, import_utils5.bytesToHex)(publicKey)
       });
     }
     tx.signIdx(privateKey, index);
@@ -17429,7 +17529,7 @@ var DefaultSparkSigner = class {
 
 // src/utils/network.ts
 init_buffer();
-var import_lrc20_sdk2 = require("@buildonspark/lrc20-sdk");
+var import_lrc20_sdk3 = require("@buildonspark/lrc20-sdk");
 var btc = __toESM(require("@scure/btc-signer"), 1);
 var bitcoin = __toESM(require("bitcoinjs-lib"), 1);
 var Network2 = /* @__PURE__ */ ((Network6) => {
@@ -17463,11 +17563,11 @@ var LRC_WALLET_NETWORK = Object.freeze({
   [4 /* LOCAL */]: bitcoin.networks.regtest
 });
 var LRC_WALLET_NETWORK_TYPE = Object.freeze({
-  [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
+  [0 /* MAINNET */]: import_lrc20_sdk3.NetworkType.MAINNET,
+  [1 /* TESTNET */]: import_lrc20_sdk3.NetworkType.TESTNET,
+  [2 /* SIGNET */]: import_lrc20_sdk3.NetworkType.TESTNET,
+  [3 /* REGTEST */]: import_lrc20_sdk3.NetworkType.REGTEST,
+  [4 /* LOCAL */]: import_lrc20_sdk3.NetworkType.LOCAL
 });
 function getNetworkFromAddress(address2) {
   try {
@@ -17504,10 +17604,10 @@ init_buffer();
 
 // src/tests/isHermeticTest.ts
 init_buffer();
-var import_core9 = require("@lightsparkdev/core");
+var import_core11 = require("@lightsparkdev/core");
 var import_fs = __toESM(require("fs"), 1);
 function isHermeticTest() {
-  if (import_core9.isNode) {
+  if (import_core11.isNode) {
     return (import_fs.default?.existsSync?.("/tmp/spark_hermetic") ?? false) || process.env.HERMETIC_TEST === "true";
   }
   return typeof process !== "undefined" && process.env?.HERMETIC_TEST === "true" || false;
@@ -17635,6 +17735,7 @@ var BASE_CONFIG = {
   signingOperators: getLocalSigningOperators(),
   tokenSignatures: "SCHNORR",
   tokenTransactionVersion: "V0",
+  tokenValidityDurationSeconds: 180,
   electrsUrl: getElectrsUrl("LOCAL"),
   expectedWithdrawBondSats: 1e4,
   expectedWithdrawRelativeBlockLocktime: 1e3,
@@ -17845,6 +17946,9 @@ var WalletConfigService = class {
   getTokenTransactionVersion() {
     return this.config.tokenTransactionVersion;
   }
+  getTokenValidityDurationSeconds() {
+    return this.config.tokenValidityDurationSeconds;
+  }
   getElectrsUrl() {
     return this.config.electrsUrl;
   }
@@ -17855,7 +17959,7 @@ var WalletConfigService = class {
 
 // src/services/connection.ts
 init_buffer();
-var import_core10 = require("@lightsparkdev/core");
+var import_core12 = require("@lightsparkdev/core");
 var import_sha23 = require("@noble/hashes/sha2");
 var import_nice_grpc_client_middleware_retry = require("nice-grpc-client-middleware-retry");
 var import_nice_grpc_common2 = require("nice-grpc-common");
@@ -19704,7 +19808,7 @@ var ConnectionManager = class {
   async createMockClient(address2) {
     const channel = await this.createChannelWithTLS(address2);
     const isNodeChannel = "close" in channel;
-    if (import_core10.isNode && isNodeChannel && !isBun) {
+    if (import_core12.isNode && isNodeChannel && !isBun) {
       const grpcModule = await import("nice-grpc");
       const { createClient } = "default" in grpcModule ? grpcModule.default : grpcModule;
       const client = createClient(MockServiceDefinition, channel);
@@ -19721,7 +19825,7 @@ var ConnectionManager = class {
   }
   async createChannelWithTLS(address2, certPath) {
     try {
-      if (import_core10.isNode && !isBun) {
+      if (import_core12.isNode && !isBun) {
         const grpcModule = await import("nice-grpc");
         const { ChannelCredentials, createChannel } = "default" in grpcModule ? grpcModule.default : grpcModule;
         if (certPath) {
@@ -19862,14 +19966,38 @@ var ConnectionManager = class {
   }
   async createSparkAuthnGrpcConnection(address2, certPath) {
     const channel = await this.createChannelWithTLS(address2, certPath);
+    const authnMiddleware = this.createAuthnMiddleware();
     return this.createGrpcClient(
       SparkAuthnServiceDefinition,
       channel,
-      false
+      false,
+      authnMiddleware
     );
   }
+  createAuthnMiddleware() {
+    if (import_core12.isNode) {
+      return async function* (call, options) {
+        const metadata = (0, import_nice_grpc_common2.Metadata)(options.metadata).set(
+          "X-Client-Env",
+          clientEnv
+        );
+        return yield* call.next(call.request, {
+          ...options,
+          metadata
+        });
+      }.bind(this);
+    } else {
+      return async function* (call, options) {
+        const metadata = (0, import_nice_grpc_common2.Metadata)(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("X-Client-Env", clientEnv).set("Content-Type", "application/grpc-web+proto");
+        return yield* call.next(call.request, {
+          ...options,
+          metadata
+        });
+      }.bind(this);
+    }
+  }
   createMiddleware(address2, authToken) {
-    if (import_core10.isNode) {
+    if (import_core12.isNode) {
       return this.createNodeMiddleware(address2, authToken);
     } else {
       return this.createBrowserMiddleware(address2, authToken);
@@ -19877,21 +20005,29 @@ var ConnectionManager = class {
   }
   createNodeMiddleware(address2, initialAuthToken) {
     return async function* (call, options) {
+      const metadata = (0, import_nice_grpc_common2.Metadata)(options.metadata).set(
+        "X-Client-Env",
+        clientEnv
+      );
       try {
         return yield* call.next(call.request, {
           ...options,
-          metadata: (0, import_nice_grpc_common2.Metadata)(options.metadata).set(
+          metadata: metadata.set(
             "Authorization",
             `Bearer ${this.clients.get(address2)?.authToken || initialAuthToken}`
-          ).set("User-Agent", "spark-js-sdk")
+          )
         });
       } catch (error) {
         if (error.message?.includes("token has expired")) {
           const newAuthToken = await this.authenticate(address2);
-          this.clients.get(address2).authToken = newAuthToken;
+          const clientData = this.clients.get(address2);
+          if (!clientData) {
+            throw new Error(`No client found for address: ${address2}`);
+          }
+          clientData.authToken = newAuthToken;
           return yield* call.next(call.request, {
             ...options,
-            metadata: (0, import_nice_grpc_common2.Metadata)(options.metadata).set("Authorization", `Bearer ${newAuthToken}`).set("User-Agent", "spark-js-sdk")
+            metadata: metadata.set("Authorization", `Bearer ${newAuthToken}`)
           });
         }
         throw error;
@@ -19900,21 +20036,26 @@ var ConnectionManager = class {
   }
   createBrowserMiddleware(address2, initialAuthToken) {
     return async function* (call, options) {
+      const metadata = (0, import_nice_grpc_common2.Metadata)(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("X-Client-Env", clientEnv).set("Content-Type", "application/grpc-web+proto");
       try {
         return yield* call.next(call.request, {
           ...options,
-          metadata: (0, import_nice_grpc_common2.Metadata)(options.metadata).set(
+          metadata: metadata.set(
             "Authorization",
             `Bearer ${this.clients.get(address2)?.authToken || initialAuthToken}`
-          ).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("Content-Type", "application/grpc-web+proto").set("User-Agent", "spark-js-sdk")
+          )
         });
       } catch (error) {
         if (error.message?.includes("token has expired")) {
           const newAuthToken = await this.authenticate(address2);
-          this.clients.get(address2).authToken = newAuthToken;
+          const clientData = this.clients.get(address2);
+          if (!clientData) {
+            throw new Error(`No client found for address: ${address2}`);
+          }
+          clientData.authToken = newAuthToken;
           return yield* call.next(call.request, {
             ...options,
-            metadata: (0, import_nice_grpc_common2.Metadata)(options.metadata).set("Authorization", `Bearer ${newAuthToken}`).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("Content-Type", "application/grpc-web+proto").set("User-Agent", "spark-js-sdk")
+            metadata: metadata.set("Authorization", `Bearer ${newAuthToken}`)
           });
         }
         throw error;
@@ -19929,7 +20070,7 @@ var ConnectionManager = class {
     };
     let options = {};
     const isNodeChannel = "close" in channel;
-    if (import_core10.isNode && isNodeChannel && !isBun) {
+    if (import_core12.isNode && isNodeChannel && !isBun) {
       const grpcModule = await import("nice-grpc");
       const { openTelemetryClientMiddleware } = await import("nice-grpc-opentelemetry");
       const { createClientFactory } = "default" in grpcModule ? grpcModule.default : grpcModule;
@@ -19979,7 +20120,7 @@ var import_uuidv72 = require("uuidv7");
 
 // src/utils/bitcoin.ts
 init_buffer();
-var import_utils6 = require("@noble/curves/abstract/utils");
+var import_utils7 = require("@noble/curves/abstract/utils");
 var import_secp256k17 = require("@noble/curves/secp256k1");
 var import_sha24 = require("@noble/hashes/sha2");
 var btc2 = __toESM(require("@scure/btc-signer"), 1);
@@ -19992,7 +20133,7 @@ function computeTaprootKeyNoScript(pubkey) {
     });
   }
   const taggedHash = import_secp256k17.schnorr.utils.taggedHash("TapTweak", pubkey);
-  const tweak = (0, import_utils6.bytesToNumberBE)(taggedHash);
+  const tweak = (0, import_utils7.bytesToNumberBE)(taggedHash);
   const P = import_secp256k17.schnorr.utils.lift_x(import_secp256k17.schnorr.utils.bytesToNumberBE(pubkey));
   const Q = P.add(import_secp256k17.secp256k1.ProjectivePoint.fromPrivateKey(tweak));
   return Q.toRawBytes();
@@ -20045,7 +20186,7 @@ function getP2TRAddressFromPkScript(pkScript, network) {
   if (pkScript.length !== 34 || pkScript[0] !== 81 || pkScript[1] !== 32) {
     throw new ValidationError("Invalid pkscript", {
       field: "pkScript",
-      value: (0, import_utils6.bytesToHex)(pkScript),
+      value: (0, import_utils7.bytesToHex)(pkScript),
       expected: "34 bytes starting with 0x51 0x20"
     });
   }
@@ -20070,7 +20211,7 @@ function getP2WPKHAddressFromPublicKey(pubKey, network) {
   return address2;
 }
 function getTxFromRawTxHex(rawTxHex) {
-  const txBytes = (0, import_utils6.hexToBytes)(rawTxHex);
+  const txBytes = (0, import_utils7.hexToBytes)(rawTxHex);
   const tx = btc2.Transaction.fromRaw(txBytes, {
     allowUnknownOutputs: true
   });
@@ -20117,10 +20258,10 @@ function getSigHashFromTx(tx, inputIndex, prevOutput) {
   );
 }
 function getTxId(tx) {
-  return (0, import_utils6.bytesToHex)((0, import_sha24.sha256)((0, import_sha24.sha256)(tx.toBytes(true))).reverse());
+  return (0, import_utils7.bytesToHex)((0, import_sha24.sha256)((0, import_sha24.sha256)(tx.toBytes(true))).reverse());
 }
 function getTxIdNoReverse(tx) {
-  return (0, import_utils6.bytesToHex)((0, import_sha24.sha256)((0, import_sha24.sha256)(tx.toBytes(true))));
+  return (0, import_utils7.bytesToHex)((0, import_sha24.sha256)((0, import_sha24.sha256)(tx.toBytes(true))));
 }
 
 // src/utils/transaction.ts
@@ -20208,7 +20349,7 @@ function getEphemeralAnchorOutput() {
 
 // src/services/transfer.ts
 init_buffer();
-var import_utils8 = require("@noble/curves/abstract/utils");
+var import_utils9 = require("@noble/curves/abstract/utils");
 var import_secp256k18 = require("@noble/curves/secp256k1");
 var import_sha26 = require("@noble/hashes/sha2");
 var import_btc_signer2 = require("@scure/btc-signer");
@@ -20217,7 +20358,7 @@ var import_uuidv7 = require("uuidv7");
 
 // src/utils/transfer_package.ts
 init_buffer();
-var import_utils7 = require("@noble/curves/abstract/utils");
+var import_utils8 = require("@noble/curves/abstract/utils");
 var import_sha25 = require("@noble/hashes/sha2");
 function getTransferPackageSigningPayload(transferID, transferPackage) {
   const encryptedPayload = transferPackage.keyTweakPackage;
@@ -20226,7 +20367,7 @@ function getTransferPackageSigningPayload(transferID, transferPackage) {
   ).map(([key, value]) => ({ key, value }));
   pairs.sort((a, b) => a.key.localeCompare(b.key));
   const encoder = new TextEncoder();
-  let message = (0, import_utils7.hexToBytes)(transferID.replaceAll("-", ""));
+  let message = (0, import_utils8.hexToBytes)(transferID.replaceAll("-", ""));
   for (const pair of pairs) {
     const keyPart = encoder.encode(pair.key + ":");
     const separator = encoder.encode(";");
@@ -20505,7 +20646,7 @@ var BaseTransferService = class {
   }
   async prepareSendTransferKeyTweaks(transferID, receiverIdentityPubkey, leaves, refundSignatureMap) {
     const receiverEciesPubKey = ecies2.PublicKey.fromHex(
-      (0, import_utils8.bytesToHex)(receiverIdentityPubkey)
+      (0, import_utils9.bytesToHex)(receiverIdentityPubkey)
     );
     const leavesTweaksMap = /* @__PURE__ */ new Map();
     for (const leaf of leaves) {
@@ -20545,7 +20686,7 @@ var BaseTransferService = class {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
       const pubkeyTweak = import_secp256k18.secp256k1.getPublicKey(
-        (0, import_utils8.numberToBytesBE)(share.share, 32),
+        (0, import_utils9.numberToBytesBE)(share.share, 32),
         true
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
@@ -20574,7 +20715,7 @@ var BaseTransferService = class {
       leafTweaksMap.set(identifier, {
         leafId: leaf.leaf.id,
         secretShareTweak: {
-          secretShare: (0, import_utils8.numberToBytesBE)(share.share, 32),
+          secretShare: (0, import_utils9.numberToBytesBE)(share.share, 32),
           proofs: share.proofs
         },
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak),
@@ -20595,7 +20736,7 @@ var BaseTransferService = class {
     return void 0;
   }
   compareTransfers(transfer1, transfer2) {
-    return transfer1.id === transfer2.id && (0, import_utils8.equalBytes)(
+    return transfer1.id === transfer2.id && (0, import_utils9.equalBytes)(
       transfer1.senderIdentityPublicKey,
       transfer2.senderIdentityPublicKey
     ) && transfer1.status === transfer2.status && transfer1.totalValue === transfer2.totalValue && transfer1.expiryTime?.getTime() === transfer2.expiryTime?.getTime() && transfer1.leaves.length === transfer2.leaves.length;
@@ -20838,7 +20979,7 @@ var TransferService = class extends BaseTransferService {
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
       const nodeOutPoint = {
-        txid: (0, import_utils8.hexToBytes)(getTxId(nodeTx)),
+        txid: (0, import_utils9.hexToBytes)(getTxId(nodeTx)),
         index: 0
       };
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
@@ -20954,7 +21095,7 @@ var TransferService = class extends BaseTransferService {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
       const pubkeyTweak = import_secp256k18.secp256k1.getPublicKey(
-        (0, import_utils8.numberToBytesBE)(share.share, 32)
+        (0, import_utils9.numberToBytesBE)(share.share, 32)
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
     }
@@ -20967,7 +21108,7 @@ var TransferService = class extends BaseTransferService {
       leafTweaksMap.set(identifier, {
         leafId: leaf.leaf.id,
         secretShareTweak: {
-          secretShare: (0, import_utils8.numberToBytesBE)(share.share, 32),
+          secretShare: (0, import_utils9.numberToBytesBE)(share.share, 32),
           proofs: share.proofs
         },
         pubkeySharesTweak: Object.fromEntries(pubkeySharesTweak)
@@ -21257,7 +21398,7 @@ var TransferService = class extends BaseTransferService {
     const refundTx = getTxFromRawTxBytes(node.refundTx);
     const refundSequence = refundTx.getInput(0).sequence || 0;
     const newNodeOutPoint = {
-      txid: (0, import_utils8.hexToBytes)(getTxId(nodeTx)),
+      txid: (0, import_utils9.hexToBytes)(getTxId(nodeTx)),
       index: 0
     };
     const { nextSequence: newNodeSequence } = getNextTransactionSequence(refundSequence);
@@ -21277,7 +21418,7 @@ var TransferService = class extends BaseTransferService {
     });
     newNodeTx.addOutput(getEphemeralAnchorOutput());
     const newRefundOutPoint = {
-      txid: (0, import_utils8.hexToBytes)(getTxId(newNodeTx)),
+      txid: (0, import_utils9.hexToBytes)(getTxId(newNodeTx)),
       index: 0
     };
     const amountSats = refundTx.getOutput(0).amount;
@@ -21478,7 +21619,7 @@ var CoopExitService = class extends BaseTransferService {
       connectorOutputs,
       receiverPubKey
     );
-    const transferTweak = await this.sendTransferTweakKey(
+    const transferTweak = await this.deliverTransferPackage(
       transfer,
       leaves,
       signaturesMap
@@ -21624,10 +21765,10 @@ var CoopExitService = class extends BaseTransferService {
 init_buffer();
 var import_secp256k19 = require("@noble/curves/secp256k1");
 var import_sha28 = require("@noble/hashes/sha2");
-var import_utils9 = require("@noble/hashes/utils");
+var import_utils10 = require("@noble/hashes/utils");
 var btc3 = __toESM(require("@scure/btc-signer"), 1);
 var import_btc_signer4 = require("@scure/btc-signer");
-var import_utils10 = require("@scure/btc-signer/utils");
+var import_utils11 = require("@scure/btc-signer/utils");
 
 // src/utils/proof.ts
 init_buffer();
@@ -21695,7 +21836,7 @@ var DepositService = class {
       if (operator.identifier === this.config.getCoordinatorIdentifier()) {
         continue;
       }
-      const operatorPubkey2 = (0, import_utils9.hexToBytes)(operator.identityPublicKey);
+      const operatorPubkey2 = (0, import_utils10.hexToBytes)(operator.identityPublicKey);
       const operatorSig = address2.depositAddressProof.addressSignatures[operator.identifier];
       if (!operatorSig) {
         throw new ValidationError("Operator signature not found", {
@@ -21871,7 +22012,7 @@ var DepositService = class {
         }
       );
     }
-    if (!(0, import_utils10.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+    if (!(0, import_utils11.equalBytes)(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
       throw new ValidationError("Verifying key mismatch", {
         field: "verifyingKey",
         value: treeResp.rootNodeSignatureShares.verifyingKey,
@@ -21947,7 +22088,7 @@ var DepositService = class {
 
 // src/services/lightning.ts
 init_buffer();
-var import_utils11 = require("@noble/curves/abstract/utils");
+var import_utils12 = require("@noble/curves/abstract/utils");
 var import_secp256k111 = require("@noble/curves/secp256k1");
 var import_sha210 = require("@noble/hashes/sha2");
 var import_uuidv73 = require("uuidv7");
@@ -22148,8 +22289,8 @@ var LightningService = class {
     descriptionHash
   }) {
     const randBytes = crypto2.getRandomValues(new Uint8Array(32));
-    const preimage = (0, import_utils11.numberToBytesBE)(
-      (0, import_utils11.bytesToNumberBE)(randBytes) % import_secp256k111.secp256k1.CURVE.n,
+    const preimage = (0, import_utils12.numberToBytesBE)(
+      (0, import_utils12.bytesToNumberBE)(randBytes) % import_secp256k111.secp256k1.CURVE.n,
       32
     );
     return await this.createLightningInvoiceWithPreImage({
@@ -22204,12 +22345,12 @@ var LightningService = class {
         const sparkClient = await this.connectionManager.createSparkClient(
           operator.address
         );
-        const userIdentityPublicKey = receiverIdentityPubkey ? (0, import_utils11.hexToBytes)(receiverIdentityPubkey) : await this.config.signer.getIdentityPublicKey();
+        const userIdentityPublicKey = receiverIdentityPubkey ? (0, import_utils12.hexToBytes)(receiverIdentityPubkey) : await this.config.signer.getIdentityPublicKey();
         try {
           await sparkClient.store_preimage_share({
             paymentHash,
             preimageShare: {
-              secretShare: (0, import_utils11.numberToBytesBE)(share.share, 32),
+              secretShare: (0, import_utils12.numberToBytesBE)(share.share, 32),
               proofs: share.proofs
             },
             threshold: this.config.getThreshold(),
@@ -22241,7 +22382,8 @@ var LightningService = class {
     paymentHash,
     invoiceString,
     isInboundPayment,
-    feeSats = 0
+    feeSats = 0,
+    amountSatsToSend
   }) {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
@@ -22278,7 +22420,25 @@ var LightningService = class {
       } catch (error) {
         console.error("Error decoding invoice", error);
       }
-      amountSats = amountMsats / 1e3;
+      const isZeroAmountInvoice = !amountMsats;
+      if (isZeroAmountInvoice && amountSatsToSend === void 0) {
+        throw new ValidationError(
+          "Invalid amount. User must specify amountSatsToSend for 0 amount lightning invoice",
+          {
+            field: "amountSatsToSend",
+            value: amountSatsToSend,
+            expected: "positive number"
+          }
+        );
+      }
+      amountSats = isZeroAmountInvoice ? amountSatsToSend : amountMsats / 1e3;
+      if (isNaN(amountSats) || amountSats <= 0) {
+        throw new ValidationError("Invalid amount", {
+          field: "amountSats",
+          value: amountSats,
+          expected: "greater than 0"
+        });
+      }
       bolt11String = invoiceString;
     }
     const reason = isInboundPayment ? 1 /* REASON_RECEIVE */ : 0 /* REASON_SEND */;
@@ -22379,7 +22539,7 @@ var LightningService = class {
 
 // src/services/lrc-connection.ts
 init_buffer();
-var import_core11 = require("@lightsparkdev/core");
+var import_core13 = require("@lightsparkdev/core");
 var import_nice_grpc_client_middleware_retry2 = require("nice-grpc-client-middleware-retry");
 var import_nice_grpc_common3 = require("nice-grpc-common");
 
@@ -25452,7 +25612,7 @@ var Lrc20ConnectionManager = class {
   }
   async createChannelWithTLS(address2, certPath) {
     try {
-      if (import_core11.isNode && !isBun) {
+      if (import_core13.isNode && !isBun) {
         const grpcModule = await import("nice-grpc");
         const { ChannelCredentials, createChannel } = "default" in grpcModule ? grpcModule.default : grpcModule;
         if (certPath) {
@@ -25519,7 +25679,7 @@ var Lrc20ConnectionManager = class {
     return client;
   }
   createMiddleware() {
-    if (import_core11.isNode) {
+    if (import_core13.isNode) {
       return this.createNodeMiddleware();
     } else {
       return this.createBrowserMiddleware();
@@ -25529,7 +25689,7 @@ var Lrc20ConnectionManager = class {
     return async function* (call, options) {
       return yield* call.next(call.request, {
         ...options,
-        metadata: (0, import_nice_grpc_common3.Metadata)(options.metadata).set("User-Agent", "spark-js-sdk")
+        metadata: (0, import_nice_grpc_common3.Metadata)(options.metadata).set("X-Client-Env", clientEnv)
       });
     }.bind(this);
   }
@@ -25537,7 +25697,7 @@ var Lrc20ConnectionManager = class {
     return async function* (call, options) {
       return yield* call.next(call.request, {
         ...options,
-        metadata: (0, import_nice_grpc_common3.Metadata)(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("Content-Type", "application/grpc-web+proto").set("User-Agent", "spark-js-sdk")
+        metadata: (0, import_nice_grpc_common3.Metadata)(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("Content-Type", "application/grpc-web+proto").set("X-Client-Env", clientEnv)
       });
     }.bind(this);
   }
@@ -25549,7 +25709,7 @@ var Lrc20ConnectionManager = class {
     };
     let options = {};
     const isNodeChannel = "close" in channel;
-    if (import_core11.isNode && isNodeChannel && !isBun) {
+    if (import_core13.isNode && isNodeChannel && !isBun) {
       const grpcModule = await import("nice-grpc");
       const { openTelemetryClientMiddleware } = await import("nice-grpc-opentelemetry");
       const { createClientFactory } = "default" in grpcModule ? grpcModule.default : grpcModule;
@@ -25594,13 +25754,26 @@ var Lrc20ConnectionManager = class {
 
 // src/services/token-transactions.ts
 init_buffer();
-var import_utils15 = require("@noble/curves/abstract/utils");
+var import_utils16 = require("@noble/curves/abstract/utils");
 var import_secp256k114 = require("@noble/curves/secp256k1");
 
 // src/utils/token-hashing.ts
 init_buffer();
 var import_sha211 = require("@noble/hashes/sha2");
 function hashTokenTransaction(tokenTransaction, partialHash = false) {
+  switch (tokenTransaction.version) {
+    case 0:
+      return hashTokenTransactionV0(tokenTransaction, partialHash);
+    case 1:
+      return hashTokenTransactionV1(tokenTransaction, partialHash);
+    default:
+      throw new ValidationError("invalid token transaction version", {
+        field: "tokenTransaction.version",
+        value: tokenTransaction.version
+      });
+  }
+}
+function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
   if (!tokenTransaction) {
     throw new ValidationError("token transaction cannot be nil", {
       field: "tokenTransaction"
@@ -25848,6 +26021,275 @@ function hashTokenTransaction(tokenTransaction, partialHash = false) {
   finalHashObj.update(concatenatedHashes);
   return finalHashObj.digest();
 }
+function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
+  if (!tokenTransaction) {
+    throw new ValidationError("token transaction cannot be nil", {
+      field: "tokenTransaction"
+    });
+  }
+  let allHashes = [];
+  const versionHashObj = import_sha211.sha256.create();
+  const versionBytes = new Uint8Array(4);
+  new DataView(versionBytes.buffer).setUint32(
+    0,
+    tokenTransaction.version,
+    false
+    // false for big-endian
+  );
+  versionHashObj.update(versionBytes);
+  allHashes.push(versionHashObj.digest());
+  if (tokenTransaction.tokenInputs?.$case === "transferInput") {
+    if (!tokenTransaction.tokenInputs.transferInput.outputsToSpend) {
+      throw new ValidationError("outputs to spend cannot be null", {
+        field: "tokenInputs.transferInput.outputsToSpend"
+      });
+    }
+    if (tokenTransaction.tokenInputs.transferInput.outputsToSpend.length === 0) {
+      throw new ValidationError("outputs to spend cannot be empty", {
+        field: "tokenInputs.transferInput.outputsToSpend"
+      });
+    }
+    for (const [
+      i,
+      output
+    ] of tokenTransaction.tokenInputs.transferInput.outputsToSpend.entries()) {
+      if (!output) {
+        throw new ValidationError(`output cannot be null at index ${i}`, {
+          field: `tokenInputs.transferInput.outputsToSpend[${i}]`,
+          index: i
+        });
+      }
+      const hashObj2 = import_sha211.sha256.create();
+      if (output.prevTokenTransactionHash) {
+        const prevHash = output.prevTokenTransactionHash;
+        if (output.prevTokenTransactionHash.length !== 32) {
+          throw new ValidationError(
+            `invalid previous transaction hash length at index ${i}`,
+            {
+              field: `tokenInputs.transferInput.outputsToSpend[${i}].prevTokenTransactionHash`,
+              value: prevHash,
+              expectedLength: 32,
+              actualLength: prevHash.length,
+              index: i
+            }
+          );
+        }
+        hashObj2.update(output.prevTokenTransactionHash);
+      }
+      const voutBytes = new Uint8Array(4);
+      new DataView(voutBytes.buffer).setUint32(
+        0,
+        output.prevTokenTransactionVout,
+        false
+      );
+      hashObj2.update(voutBytes);
+      allHashes.push(hashObj2.digest());
+    }
+  }
+  if (tokenTransaction.tokenInputs?.$case === "mintInput") {
+    const hashObj2 = import_sha211.sha256.create();
+    if (tokenTransaction.tokenInputs.mintInput.issuerPublicKey) {
+      const issuerPubKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
+      if (issuerPubKey.length === 0) {
+        throw new ValidationError("issuer public key cannot be empty", {
+          field: "tokenInputs.mintInput.issuerPublicKey",
+          value: issuerPubKey,
+          expectedLength: 1,
+          actualLength: 0
+        });
+      }
+      hashObj2.update(issuerPubKey);
+      if (tokenTransaction.tokenInputs.mintInput.issuerProvidedTimestamp != 0) {
+        const timestampBytes = new Uint8Array(8);
+        new DataView(timestampBytes.buffer).setBigUint64(
+          0,
+          BigInt(
+            tokenTransaction.tokenInputs.mintInput.issuerProvidedTimestamp
+          ),
+          true
+          // true for little-endian to match Go implementation
+        );
+        hashObj2.update(timestampBytes);
+      }
+      allHashes.push(hashObj2.digest());
+    }
+  }
+  if (!tokenTransaction.tokenOutputs) {
+    throw new ValidationError("token outputs cannot be null", {
+      field: "tokenOutputs"
+    });
+  }
+  if (tokenTransaction.tokenOutputs.length === 0) {
+    throw new ValidationError("token outputs cannot be empty", {
+      field: "tokenOutputs"
+    });
+  }
+  for (const [i, output] of tokenTransaction.tokenOutputs.entries()) {
+    if (!output) {
+      throw new ValidationError(`output cannot be null at index ${i}`, {
+        field: `tokenOutputs[${i}]`,
+        index: i
+      });
+    }
+    const hashObj2 = import_sha211.sha256.create();
+    if (output.id && !partialHash) {
+      if (output.id.length === 0) {
+        throw new ValidationError(`output ID at index ${i} cannot be empty`, {
+          field: `tokenOutputs[${i}].id`,
+          index: i
+        });
+      }
+      hashObj2.update(new TextEncoder().encode(output.id));
+    }
+    if (output.ownerPublicKey) {
+      if (output.ownerPublicKey.length === 0) {
+        throw new ValidationError(
+          `owner public key at index ${i} cannot be empty`,
+          {
+            field: `tokenOutputs[${i}].ownerPublicKey`,
+            index: i
+          }
+        );
+      }
+      hashObj2.update(output.ownerPublicKey);
+    }
+    if (!partialHash) {
+      const revPubKey = output.revocationCommitment;
+      if (revPubKey) {
+        if (revPubKey.length === 0) {
+          throw new ValidationError(
+            `revocation commitment at index ${i} cannot be empty`,
+            {
+              field: `tokenOutputs[${i}].revocationCommitment`,
+              index: i
+            }
+          );
+        }
+        hashObj2.update(revPubKey);
+      }
+      const bondBytes = new Uint8Array(8);
+      new DataView(bondBytes.buffer).setBigUint64(
+        0,
+        BigInt(output.withdrawBondSats),
+        false
+      );
+      hashObj2.update(bondBytes);
+      const locktimeBytes = new Uint8Array(8);
+      new DataView(locktimeBytes.buffer).setBigUint64(
+        0,
+        BigInt(output.withdrawRelativeBlockLocktime),
+        false
+      );
+      hashObj2.update(locktimeBytes);
+    }
+    if (output.tokenPublicKey) {
+      if (output.tokenPublicKey.length === 0) {
+        throw new ValidationError(
+          `token public key at index ${i} cannot be empty`,
+          {
+            field: `tokenOutputs[${i}].tokenPublicKey`,
+            index: i
+          }
+        );
+      }
+      hashObj2.update(output.tokenPublicKey);
+    }
+    if (output.tokenAmount) {
+      if (output.tokenAmount.length === 0) {
+        throw new ValidationError(
+          `token amount at index ${i} cannot be empty`,
+          {
+            field: `tokenOutputs[${i}].tokenAmount`,
+            index: i
+          }
+        );
+      }
+      if (output.tokenAmount.length > 16) {
+        throw new ValidationError(
+          `token amount at index ${i} exceeds maximum length`,
+          {
+            field: `tokenOutputs[${i}].tokenAmount`,
+            value: output.tokenAmount,
+            expectedLength: 16,
+            actualLength: output.tokenAmount.length,
+            index: i
+          }
+        );
+      }
+      hashObj2.update(output.tokenAmount);
+    }
+    allHashes.push(hashObj2.digest());
+  }
+  if (!tokenTransaction.sparkOperatorIdentityPublicKeys) {
+    throw new ValidationError(
+      "spark operator identity public keys cannot be null",
+      {}
+    );
+  }
+  const sortedPubKeys = [
+    ...tokenTransaction.sparkOperatorIdentityPublicKeys || []
+  ].sort((a, b) => {
+    for (let i = 0; i < a.length && i < b.length; i++) {
+      if (a[i] !== b[i]) return a[i] - b[i];
+    }
+    return a.length - b.length;
+  });
+  for (const [i, pubKey] of sortedPubKeys.entries()) {
+    if (!pubKey) {
+      throw new ValidationError(
+        `operator public key at index ${i} cannot be null`,
+        {
+          field: `sparkOperatorIdentityPublicKeys[${i}]`,
+          index: i
+        }
+      );
+    }
+    if (pubKey.length === 0) {
+      throw new ValidationError(
+        `operator public key at index ${i} cannot be empty`,
+        {
+          field: `sparkOperatorIdentityPublicKeys[${i}]`,
+          index: i
+        }
+      );
+    }
+    const hashObj2 = import_sha211.sha256.create();
+    hashObj2.update(pubKey);
+    allHashes.push(hashObj2.digest());
+  }
+  const hashObj = import_sha211.sha256.create();
+  let networkBytes = new Uint8Array(4);
+  new DataView(networkBytes.buffer).setUint32(
+    0,
+    tokenTransaction.network.valueOf(),
+    false
+    // false for big-endian
+  );
+  hashObj.update(networkBytes);
+  allHashes.push(hashObj.digest());
+  const expiryHashObj = import_sha211.sha256.create();
+  const validityDurationBytes = new Uint8Array(8);
+  const expiryUnixTime = tokenTransaction.expiryTime ? Math.floor(tokenTransaction.expiryTime.getTime() / 1e3) : 0;
+  new DataView(validityDurationBytes.buffer).setBigUint64(
+    0,
+    BigInt(expiryUnixTime),
+    false
+    // false for big-endian
+  );
+  expiryHashObj.update(validityDurationBytes);
+  allHashes.push(expiryHashObj.digest());
+  const finalHashObj = import_sha211.sha256.create();
+  const concatenatedHashes = new Uint8Array(
+    allHashes.reduce((sum, hash) => sum + hash.length, 0)
+  );
+  let offset = 0;
+  for (const hash of allHashes) {
+    concatenatedHashes.set(hash, offset);
+    offset += hash.length;
+  }
+  finalHashObj.update(concatenatedHashes);
+  return finalHashObj.digest();
+}
 function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
   if (!payload) {
     throw new ValidationError(
@@ -25899,15 +26341,15 @@ function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
 
 // src/utils/token-transactions.ts
 init_buffer();
-var import_utils12 = require("@noble/curves/abstract/utils");
+var import_utils13 = require("@noble/curves/abstract/utils");
 function calculateAvailableTokenAmount(outputLeaves) {
   return outputLeaves.reduce(
-    (sum, output) => sum + BigInt((0, import_utils12.bytesToNumberBE)(output.output.tokenAmount)),
+    (sum, output) => sum + BigInt((0, import_utils13.bytesToNumberBE)(output.output.tokenAmount)),
     BigInt(0)
   );
 }
 function checkIfSelectedOutputsAreAvailable(selectedOutputs, tokenOutputs, tokenPublicKey) {
-  const tokenPubKeyHex = (0, import_utils12.bytesToHex)(tokenPublicKey);
+  const tokenPubKeyHex = (0, import_utils13.bytesToHex)(tokenPublicKey);
   const tokenOutputsAvailable = tokenOutputs.get(tokenPubKeyHex);
   if (!tokenOutputsAvailable) {
     return false;
@@ -26193,7 +26635,7 @@ function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction
 }
 
 // src/services/token-transactions.ts
-var import_utils16 = require("@noble/hashes/utils");
+var import_utils17 = require("@noble/hashes/utils");
 
 // src/address/index.ts
 init_buffer();
@@ -26201,10 +26643,10 @@ init_buffer();
 // src/address/address.ts
 init_buffer();
 var import_secp256k112 = require("@noble/curves/secp256k1");
-var import_utils13 = require("@noble/hashes/utils");
+var import_utils14 = require("@noble/hashes/utils");
 var import_base3 = require("@scure/base");
 var import_uuidv74 = require("uuidv7");
-var import_utils14 = require("@noble/curves/abstract/utils");
+var import_utils15 = require("@noble/curves/abstract/utils");
 var AddressNetwork = {
   MAINNET: "sp",
   TESTNET: "spt",
@@ -26220,7 +26662,7 @@ function encodeSparkAddress(payload) {
       paymentIntentFields = payload.paymentIntentFields;
     }
     const sparkAddressProto = SparkAddress.create({
-      identityPublicKey: (0, import_utils13.hexToBytes)(payload.identityPublicKey),
+      identityPublicKey: (0, import_utils14.hexToBytes)(payload.identityPublicKey),
       paymentIntentFields
     });
     const serializedPayload = SparkAddress.encode(sparkAddressProto).finish();
@@ -26252,7 +26694,7 @@ function decodeSparkAddress(address2, network) {
       });
     }
     const payload = SparkAddress.decode(import_base3.bech32m.fromWords(decoded.words));
-    const publicKey = (0, import_utils13.bytesToHex)(payload.identityPublicKey);
+    const publicKey = (0, import_utils14.bytesToHex)(payload.identityPublicKey);
     isValidPublicKey(publicKey);
     const paymentIntentFields = payload.paymentIntentFields;
     return {
@@ -26260,8 +26702,8 @@ function decodeSparkAddress(address2, network) {
       network,
       paymentIntentFields: paymentIntentFields && {
         id: import_uuidv74.UUID.ofInner(paymentIntentFields.id).toString(),
-        assetIdentifier: paymentIntentFields.assetIdentifier ? (0, import_utils13.bytesToHex)(paymentIntentFields.assetIdentifier) : void 0,
-        assetAmount: (0, import_utils14.bytesToNumberBE)(paymentIntentFields.assetAmount),
+        assetIdentifier: paymentIntentFields.assetIdentifier ? (0, import_utils14.bytesToHex)(paymentIntentFields.assetIdentifier) : void 0,
+        assetAmount: (0, import_utils15.bytesToNumberBE)(paymentIntentFields.assetAmount),
         memo: paymentIntentFields.memo
       }
     };
@@ -26362,7 +26804,7 @@ var TokenTransactionService = class {
       if (!checkIfSelectedOutputsAreAvailable(
         outputsToUse,
         tokenOutputs,
-        (0, import_utils16.hexToBytes)(receiverOutputs[0].tokenPublicKey)
+        (0, import_utils17.hexToBytes)(receiverOutputs[0].tokenPublicKey)
       )) {
         throw new ValidationError(
           "One or more selected TTXOs are not available",
@@ -26403,8 +26845,8 @@ var TokenTransactionService = class {
         this.config.getNetworkType()
       );
       return {
-        receiverSparkAddress: (0, import_utils16.hexToBytes)(receiverAddress.identityPublicKey),
-        tokenPublicKey: (0, import_utils16.hexToBytes)(transfer.tokenPublicKey),
+        receiverSparkAddress: (0, import_utils17.hexToBytes)(receiverAddress.identityPublicKey),
+        tokenPublicKey: (0, import_utils17.hexToBytes)(transfer.tokenPublicKey),
         tokenAmount: transfer.tokenAmount
       };
     });
@@ -26436,7 +26878,7 @@ var TokenTransactionService = class {
     const tokenOutputs = tokenOutputData.map((output) => ({
       ownerPublicKey: output.receiverSparkAddress,
       tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: (0, import_utils15.numberToBytesBE)(output.tokenAmount, 16)
+      tokenAmount: (0, import_utils16.numberToBytesBE)(output.tokenAmount, 16)
     }));
     if (availableTokenAmount > totalRequestedAmount) {
       const changeAmount = availableTokenAmount - totalRequestedAmount;
@@ -26444,7 +26886,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils15.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils16.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -26471,7 +26913,7 @@ var TokenTransactionService = class {
     const tokenOutputs = tokenOutputData.map((output) => ({
       ownerPublicKey: output.receiverSparkAddress,
       tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: (0, import_utils15.numberToBytesBE)(output.tokenAmount, 16)
+      tokenAmount: (0, import_utils16.numberToBytesBE)(output.tokenAmount, 16)
     }));
     if (availableTokenAmount > totalRequestedAmount) {
       const changeAmount = availableTokenAmount - totalRequestedAmount;
@@ -26479,7 +26921,7 @@ var TokenTransactionService = class {
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
         tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils15.numberToBytesBE)(changeAmount, 16)
+        tokenAmount: (0, import_utils16.numberToBytesBE)(changeAmount, 16)
       });
     }
     return {
@@ -26504,7 +26946,7 @@ var TokenTransactionService = class {
     for (const [_, operator] of Object.entries(
       this.config.getSigningOperators()
     )) {
-      operatorKeys.push((0, import_utils16.hexToBytes)(operator.identityPublicKey));
+      operatorKeys.push((0, import_utils17.hexToBytes)(operator.identityPublicKey));
     }
     return operatorKeys;
   }
@@ -26588,7 +27030,7 @@ var TokenTransactionService = class {
               {
                 field: "revocationCommitment",
                 value: derivedRevocationCommitment,
-                expected: (0, import_utils15.bytesToHex)(outputsToSpendCommitments[outputIndex]),
+                expected: (0, import_utils16.bytesToHex)(outputsToSpendCommitments[outputIndex]),
                 outputIndex
               }
             )
@@ -26614,7 +27056,7 @@ var TokenTransactionService = class {
         threshold
       );
     }
-    return (0, import_utils15.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils16.bytesToHex)(finalTokenTransactionHash);
   }
   async broadcastTokenTransactionV1(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
@@ -26628,13 +27070,13 @@ var TokenTransactionService = class {
       finalTokenTransactionHash,
       signingOperators
     );
-    return (0, import_utils15.bytesToHex)(finalTokenTransactionHash);
+    return (0, import_utils16.bytesToHex)(finalTokenTransactionHash);
   }
   async startTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress()
     );
-    const partialTokenTransactionHash = hashTokenTransaction(
+    const partialTokenTransactionHash = hashTokenTransactionV0(
       tokenTransaction,
       true
     );
@@ -26715,7 +27157,7 @@ var TokenTransactionService = class {
       this.config.getThreshold()
     );
     const finalTokenTransaction = startResponse.finalTokenTransaction;
-    const finalTokenTransactionHash = hashTokenTransaction(
+    const finalTokenTransactionHash = hashTokenTransactionV0(
       finalTokenTransaction,
       false
     );
@@ -26783,7 +27225,9 @@ var TokenTransactionService = class {
     const startResponse = await sparkClient.start_transaction(
       {
         identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        partialTokenTransaction: tokenTransaction
+        partialTokenTransaction: tokenTransaction,
+        validityDurationSeconds: await this.config.getTokenValidityDurationSeconds(),
+        partialTokenTransactionOwnerSignatures: ownerSignaturesWithIndex
       },
       {
         retry: true,
@@ -26825,7 +27269,7 @@ var TokenTransactionService = class {
           const identityPublicKey = await this.config.signer.getIdentityPublicKey();
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils16.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let operatorSpecificSignatures = [];
@@ -26982,7 +27426,7 @@ var TokenTransactionService = class {
       []
     );
     unsortedTokenOutputs.forEach((output) => {
-      const tokenKey = (0, import_utils15.bytesToHex)(output.output.tokenPublicKey);
+      const tokenKey = (0, import_utils16.bytesToHex)(output.output.tokenPublicKey);
       const index = output.previousTransactionVout;
       tokenOutputs.set(tokenKey, [
         { ...output, previousTransactionVout: index }
@@ -26998,7 +27442,7 @@ var TokenTransactionService = class {
       });
     }
     const exactMatch = tokenOutputs.find(
-      (item) => (0, import_utils15.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
+      (item) => (0, import_utils16.bytesToNumberBE)(item.output.tokenAmount) === tokenAmount
     );
     if (exactMatch) {
       return [exactMatch];
@@ -27009,7 +27453,7 @@ var TokenTransactionService = class {
     for (const outputWithPreviousTransactionData of tokenOutputs) {
       if (remainingAmount <= 0n) break;
       selectedOutputs.push(outputWithPreviousTransactionData);
-      remainingAmount -= (0, import_utils15.bytesToNumberBE)(
+      remainingAmount -= (0, import_utils16.bytesToNumberBE)(
         outputWithPreviousTransactionData.output.tokenAmount
       );
     }
@@ -27025,13 +27469,13 @@ var TokenTransactionService = class {
     if (strategy === "SMALL_FIRST") {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils15.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils15.bytesToNumberBE)(b.output.tokenAmount)
+          (0, import_utils16.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils16.bytesToNumberBE)(b.output.tokenAmount)
         );
       });
     } else {
       tokenOutputs.sort((a, b) => {
         return Number(
-          (0, import_utils15.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils15.bytesToNumberBE)(a.output.tokenAmount)
+          (0, import_utils16.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils16.bytesToNumberBE)(a.output.tokenAmount)
         );
       });
     }
@@ -27039,7 +27483,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_utils15.bytesToHex)(publicKey) === (0, import_utils15.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
+    if ((0, import_utils16.bytesToHex)(publicKey) === (0, import_utils16.bytesToHex)(await this.config.signer.getIdentityPublicKey())) {
       if (tokenSignatures === "SCHNORR") {
         return await this.config.signer.signSchnorrWithIdentityKey(message);
       } else {
@@ -27115,7 +27559,7 @@ var TokenTransactionService = class {
         }
         const payload = {
           finalTokenTransactionHash,
-          operatorIdentityPublicKey: (0, import_utils16.hexToBytes)(operator.identityPublicKey)
+          operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
         };
         const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
         const ownerSignature = await this.signMessageWithKey(
@@ -27131,7 +27575,7 @@ var TokenTransactionService = class {
         for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
           const payload = {
             finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils16.hexToBytes)(operator.identityPublicKey)
+            operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
           };
           const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
           let ownerSignature;
@@ -27148,7 +27592,7 @@ var TokenTransactionService = class {
       }
       inputTtxoSignaturesPerOperator.push({
         ttxoSignatures,
-        operatorIdentityPublicKey: (0, import_utils16.hexToBytes)(operator.identityPublicKey)
+        operatorIdentityPublicKey: (0, import_utils17.hexToBytes)(operator.identityPublicKey)
       });
     }
     return inputTtxoSignaturesPerOperator;
@@ -27160,7 +27604,7 @@ function isTokenTransaction(tokenTransaction) {
 
 // src/services/tree-creation.ts
 init_buffer();
-var import_utils17 = require("@noble/curves/abstract/utils");
+var import_utils18 = require("@noble/curves/abstract/utils");
 var import_sha212 = require("@noble/hashes/sha2");
 var import_btc_signer5 = require("@scure/btc-signer");
 var INITIAL_TIME_LOCK3 = 2e3;
@@ -27209,7 +27653,7 @@ var TreeCreationService = class {
       request.source = {
         $case: "onChainUtxo",
         onChainUtxo: {
-          txid: (0, import_utils17.hexToBytes)(getTxId(parentTx)),
+          txid: (0, import_utils18.hexToBytes)(getTxId(parentTx)),
           vout,
           rawTx: parentTx.toBytes(),
           network: this.config.getNetworkProto()
@@ -27250,7 +27694,7 @@ var TreeCreationService = class {
       request.source = {
         $case: "onChainUtxo",
         onChainUtxo: {
-          txid: (0, import_utils17.hexToBytes)(getTxId(parentTx)),
+          txid: (0, import_utils18.hexToBytes)(getTxId(parentTx)),
           vout,
           rawTx: parentTx.toBytes(),
           network: this.config.getNetworkProto()
@@ -27621,13 +28065,13 @@ var TreeCreationService = class {
 };
 
 // src/spark-wallet/spark-wallet.ts
-var import_lrc20_sdk3 = require("@buildonspark/lrc20-sdk");
+var import_lrc20_sdk4 = require("@buildonspark/lrc20-sdk");
 var import_sha213 = require("@noble/hashes/sha2");
 var import_eventemitter3 = require("eventemitter3");
 
 // src/services/signing.ts
 init_buffer();
-var import_utils18 = require("@noble/curves/abstract/utils");
+var import_utils19 = require("@noble/curves/abstract/utils");
 var SigningService = class {
   config;
   constructor(config) {
@@ -27646,7 +28090,7 @@ var SigningService = class {
       }
       const nodeTx = getTxFromRawTxBytes(leaf.leaf.nodeTx);
       const nodeOutPoint = {
-        txid: (0, import_utils18.hexToBytes)(getTxId(nodeTx)),
+        txid: (0, import_utils19.hexToBytes)(getTxId(nodeTx)),
         index: 0
       };
       const currRefundTx = getTxFromRawTxBytes(leaf.leaf.refundTx);
@@ -27704,15 +28148,15 @@ var SigningService = class {
 
 // src/tests/utils/test-faucet.ts
 init_buffer();
-var import_utils19 = require("@noble/curves/abstract/utils");
+var import_utils20 = require("@noble/curves/abstract/utils");
 var import_secp256k115 = require("@noble/curves/secp256k1");
 var btc4 = __toESM(require("@scure/btc-signer"), 1);
 var import_btc_signer6 = require("@scure/btc-signer");
-var import_utils20 = require("@scure/btc-signer/utils");
-var STATIC_FAUCET_KEY = (0, import_utils19.hexToBytes)(
+var import_utils21 = require("@scure/btc-signer/utils");
+var STATIC_FAUCET_KEY = (0, import_utils20.hexToBytes)(
   "deadbeef1337cafe4242424242424242deadbeef1337cafe4242424242424242"
 );
-var STATIC_MINING_KEY = (0, import_utils19.hexToBytes)(
+var STATIC_MINING_KEY = (0, import_utils20.hexToBytes)(
   "1337cafe4242deadbeef4242424242421337cafe4242deadbeef424242424242"
 );
 var SATS_PER_BTC = 1e8;
@@ -27775,7 +28219,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     if (!scanResult.success || scanResult.unspents.length === 0) {
       const blockHash = await this.generateToAddress(1, address2);
       const block = await this.getBlock(blockHash[0]);
-      const fundingTx = import_btc_signer6.Transaction.fromRaw((0, import_utils19.hexToBytes)(block.tx[0].hex), {
+      const fundingTx = import_btc_signer6.Transaction.fromRaw((0, import_utils20.hexToBytes)(block.tx[0].hex), {
         allowUnknownOutputs: true
       });
       await this.generateToAddress(100, this.miningAddress);
@@ -27837,13 +28281,13 @@ var BitcoinFaucet = class _BitcoinFaucet {
       },
       STATIC_MINING_KEY
     );
-    await this.broadcastTx((0, import_utils19.bytesToHex)(signedSplitTx.extract()));
+    await this.broadcastTx((0, import_utils20.bytesToHex)(signedSplitTx.extract()));
     const splitTxId = signedSplitTx.id;
     for (let i = 0; i < numCoinsToCreate; i++) {
       this.coins.push({
         key: STATIC_FAUCET_KEY,
         outpoint: {
-          txid: (0, import_utils19.hexToBytes)(splitTxId),
+          txid: (0, import_utils20.hexToBytes)(splitTxId),
           index: i
         },
         txout: signedSplitTx.getOutput(i)
@@ -27871,7 +28315,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       coinToSend.txout,
       coinToSend.key
     );
-    await this.broadcastTx((0, import_utils19.bytesToHex)(signedTx.extract()));
+    await this.broadcastTx((0, import_utils20.bytesToHex)(signedTx.extract()));
   }
   async signFaucetCoin(unsignedTx, fundingTxOut, key) {
     const pubKey = import_secp256k115.secp256k1.getPublicKey(key);
@@ -27891,7 +28335,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       new Array(unsignedTx.inputsLength).fill(fundingTxOut.amount)
     );
     const merkleRoot = new Uint8Array();
-    const tweakedKey = (0, import_utils20.taprootTweakPrivKey)(key, merkleRoot);
+    const tweakedKey = (0, import_utils21.taprootTweakPrivKey)(key, merkleRoot);
     if (!tweakedKey)
       throw new Error("Invalid private key for taproot tweaking");
     const signature = import_secp256k115.schnorr.sign(sighash, tweakedKey);
@@ -27990,7 +28434,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       });
     }
     const signedTx = await this.signFaucetCoin(tx, coin.txout, coin.key);
-    const txHex = (0, import_utils19.bytesToHex)(signedTx.extract());
+    const txHex = (0, import_utils20.bytesToHex)(signedTx.extract());
     await this.broadcastTx(txHex);
     const randomKey = import_secp256k115.secp256k1.utils.randomPrivateKey();
     const randomPubKey = import_secp256k115.secp256k1.getPublicKey(randomKey);
@@ -28008,18 +28452,18 @@ var BitcoinFaucet = class _BitcoinFaucet {
 
 // src/types/sdk-types.ts
 init_buffer();
-var import_utils21 = require("@noble/curves/abstract/utils");
+var import_utils22 = require("@noble/curves/abstract/utils");
 function mapTreeNodeToWalletLeaf(proto) {
   return {
     id: proto.id,
     treeId: proto.treeId,
     value: proto.value,
     parentNodeId: proto.parentNodeId,
-    nodeTx: (0, import_utils21.bytesToHex)(proto.nodeTx),
-    refundTx: (0, import_utils21.bytesToHex)(proto.refundTx),
+    nodeTx: (0, import_utils22.bytesToHex)(proto.nodeTx),
+    refundTx: (0, import_utils22.bytesToHex)(proto.refundTx),
     vout: proto.vout,
-    verifyingPublicKey: (0, import_utils21.bytesToHex)(proto.verifyingPublicKey),
-    ownerIdentityPublicKey: (0, import_utils21.bytesToHex)(proto.ownerIdentityPublicKey),
+    verifyingPublicKey: (0, import_utils22.bytesToHex)(proto.verifyingPublicKey),
+    ownerIdentityPublicKey: (0, import_utils22.bytesToHex)(proto.ownerIdentityPublicKey),
     signingKeyshare: proto.signingKeyshare,
     status: proto.status,
     network: Network[proto.network]
@@ -28028,14 +28472,14 @@ function mapTreeNodeToWalletLeaf(proto) {
 function mapTransferLeafToWalletTransferLeaf(proto) {
   return {
     leaf: proto.leaf ? mapTreeNodeToWalletLeaf(proto.leaf) : void 0,
-    secretCipher: (0, import_utils21.bytesToHex)(proto.secretCipher),
-    signature: (0, import_utils21.bytesToHex)(proto.signature),
-    intermediateRefundTx: (0, import_utils21.bytesToHex)(proto.intermediateRefundTx)
+    secretCipher: (0, import_utils22.bytesToHex)(proto.secretCipher),
+    signature: (0, import_utils22.bytesToHex)(proto.signature),
+    intermediateRefundTx: (0, import_utils22.bytesToHex)(proto.intermediateRefundTx)
   };
 }
 function mapTransferToWalletTransfer(proto, identityPublicKey) {
-  const receiverIdentityPublicKey = (0, import_utils21.bytesToHex)(proto.receiverIdentityPublicKey);
-  const senderIdentityPublicKey = (0, import_utils21.bytesToHex)(proto.senderIdentityPublicKey);
+  const receiverIdentityPublicKey = (0, import_utils22.bytesToHex)(proto.receiverIdentityPublicKey);
+  const senderIdentityPublicKey = (0, import_utils22.bytesToHex)(proto.senderIdentityPublicKey);
   return {
     id: proto.id,
     senderIdentityPublicKey,
@@ -28161,7 +28605,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     try {
       if (event?.$case === "transfer" && event.transfer.transfer && event.transfer.transfer.type !== 40 /* COUNTER_SWAP */) {
         const { senderIdentityPublicKey, receiverIdentityPublicKey } = event.transfer.transfer;
-        if (event.transfer.transfer && !(0, import_utils22.equalBytes)(senderIdentityPublicKey, receiverIdentityPublicKey)) {
+        if (event.transfer.transfer && !(0, import_utils23.equalBytes)(senderIdentityPublicKey, receiverIdentityPublicKey)) {
           await this.claimTransfer({
             transfer: event.transfer.transfer,
             emit: true,
@@ -28233,7 +28677,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
             setTimeout(maybeUnref, 100);
           }
         };
-        if (import_core12.isNode) {
+        if (import_core14.isNode) {
           maybeUnref();
         }
         const claimedTransfersIds = await this.claimTransfers();
@@ -28323,10 +28767,10 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
               leavesToIgnore.add(nodeId);
               continue;
             }
-            if (leaf.status !== operatorLeaf.status || !leaf.signingKeyshare || !operatorLeaf.signingKeyshare || !(0, import_utils22.equalBytes)(
+            if (leaf.status !== operatorLeaf.status || !leaf.signingKeyshare || !operatorLeaf.signingKeyshare || !(0, import_utils23.equalBytes)(
               leaf.signingKeyshare.publicKey,
               operatorLeaf.signingKeyshare.publicKey
-            ) || !(0, import_utils22.equalBytes)(leaf.nodeTx, operatorLeaf.nodeTx) || !(0, import_utils22.equalBytes)(leaf.refundTx, operatorLeaf.refundTx)) {
+            ) || !(0, import_utils23.equalBytes)(leaf.nodeTx, operatorLeaf.nodeTx) || !(0, import_utils23.equalBytes)(leaf.refundTx, operatorLeaf.refundTx)) {
               leavesToIgnore.add(nodeId);
             }
           }
@@ -28334,7 +28778,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       }
     }
     const verifyKey = (pubkey1, pubkey2, verifyingKey) => {
-      return (0, import_utils22.equalBytes)(addPublicKeys(pubkey1, pubkey2), verifyingKey);
+      return (0, import_utils23.equalBytes)(addPublicKeys(pubkey1, pubkey2), verifyingKey);
     };
     for (const [id, leaf] of Object.entries(leaves.nodes)) {
       if (!verifyKey(
@@ -28468,7 +28912,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    * @returns {Promise<string>} The identity public key as a hex string.
    */
   async getIdentityPublicKey() {
-    return (0, import_utils22.bytesToHex)(await this.config.signer.getIdentityPublicKey());
+    return (0, import_utils23.bytesToHex)(await this.config.signer.getIdentityPublicKey());
   }
   /**
    * Gets the Spark address of the wallet.
@@ -28478,7 +28922,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   async getSparkAddress() {
     if (!this.sparkAddress) {
       this.sparkAddress = encodeSparkAddress({
-        identityPublicKey: (0, import_utils22.bytesToHex)(
+        identityPublicKey: (0, import_utils23.bytesToHex)(
           await this.config.signer.getIdentityPublicKey()
         ),
         network: this.config.getNetworkType()
@@ -28515,14 +28959,14 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       isValidPublicKey(assetIdentifier);
     }
     const paymentRequest = encodeSparkAddress({
-      identityPublicKey: (0, import_utils22.bytesToHex)(
+      identityPublicKey: (0, import_utils23.bytesToHex)(
         await this.config.signer.getIdentityPublicKey()
       ),
       network: this.config.getNetworkType(),
       paymentIntentFields: {
         id: (0, import_uuidv75.uuidv7obj)().bytes,
-        assetIdentifier: assetIdentifier ? (0, import_utils22.hexToBytes)(assetIdentifier) : void 0,
-        assetAmount: (0, import_utils22.numberToVarBytesBE)(assetAmount),
+        assetIdentifier: assetIdentifier ? (0, import_utils23.hexToBytes)(assetIdentifier) : void 0,
+        assetAmount: (0, import_utils23.numberToVarBytesBE)(assetAmount),
         memo
       }
     });
@@ -28567,12 +29011,12 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         mnemonic = mnemonicOrSeed;
         seed = await this.config.signer.mnemonicToSeed(mnemonicOrSeed);
       } else {
-        seed = (0, import_utils22.hexToBytes)(mnemonicOrSeed);
+        seed = (0, import_utils23.hexToBytes)(mnemonicOrSeed);
       }
     }
     await this.initWalletFromSeed(seed, accountNumber);
     const network = this.config.getNetwork();
-    this.lrc20Wallet = await import_lrc20_sdk3.LRCWallet.create(
+    this.lrc20Wallet = await import_lrc20_sdk4.LRCWallet.create(
       LRC_WALLET_NETWORK[network],
       LRC_WALLET_NETWORK_TYPE[network],
       this.config.lrc20ApiConfig,
@@ -28672,7 +29116,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     );
     const { transfer, signatureMap } = await this.transferService.startSwapSignRefund(
       leafKeyTweaks,
-      (0, import_utils22.hexToBytes)(this.config.getSspIdentityPublicKey()),
+      (0, import_utils23.hexToBytes)(this.config.getSspIdentityPublicKey()),
       new Date(Date.now() + 2 * 60 * 1e3)
     );
     try {
@@ -28690,10 +29134,10 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       const userLeaves = [];
       userLeaves.push({
         leaf_id: transfer.leaves[0].leaf.id,
-        raw_unsigned_refund_transaction: (0, import_utils22.bytesToHex)(
+        raw_unsigned_refund_transaction: (0, import_utils23.bytesToHex)(
           transfer.leaves[0].intermediateRefundTx
         ),
-        adaptor_added_signature: (0, import_utils22.bytesToHex)(adaptorSignature)
+        adaptor_added_signature: (0, import_utils23.bytesToHex)(adaptorSignature)
       });
       for (let i = 1; i < transfer.leaves.length; i++) {
         const leaf = transfer.leaves[i];
@@ -28710,14 +29154,14 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         );
         userLeaves.push({
           leaf_id: leaf.leaf.id,
-          raw_unsigned_refund_transaction: (0, import_utils22.bytesToHex)(
+          raw_unsigned_refund_transaction: (0, import_utils23.bytesToHex)(
             leaf.intermediateRefundTx
           ),
-          adaptor_added_signature: (0, import_utils22.bytesToHex)(signature)
+          adaptor_added_signature: (0, import_utils23.bytesToHex)(signature)
         });
       }
       const sspClient = this.getSspClient();
-      const adaptorPubkey = (0, import_utils22.bytesToHex)(
+      const adaptorPubkey = (0, import_utils23.bytesToHex)(
         import_secp256k116.secp256k1.getPublicKey(adaptorPrivateKey)
       );
       let request = null;
@@ -28758,12 +29202,12 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           throw new Error(`Leaf not found for node ${nodeId}`);
         }
         const nodeTx = getTxFromRawTxBytes(node.nodeTx);
-        const refundTxBytes = (0, import_utils22.hexToBytes)(leaf.rawUnsignedRefundTransaction);
+        const refundTxBytes = (0, import_utils23.hexToBytes)(leaf.rawUnsignedRefundTransaction);
         const refundTx = getTxFromRawTxBytes(refundTxBytes);
         const sighash = getSigHashFromTx(refundTx, 0, nodeTx.getOutput(0));
         const nodePublicKey = node.verifyingPublicKey;
         const taprootKey = computeTaprootKeyNoScript(nodePublicKey.slice(1));
-        const adaptorSignatureBytes = (0, import_utils22.hexToBytes)(leaf.adaptorSignedSignature);
+        const adaptorSignatureBytes = (0, import_utils23.hexToBytes)(leaf.adaptorSignedSignature);
         applyAdaptorToSignature(
           taprootKey.slice(1),
           sighash,
@@ -28777,7 +29221,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         signatureMap
       );
       const completeResponse = await sspClient.completeLeaveSwap({
-        adaptorSecretKey: (0, import_utils22.bytesToHex)(adaptorPrivateKey),
+        adaptorSecretKey: (0, import_utils23.bytesToHex)(adaptorPrivateKey),
         userOutboundTransferExternalId: transfer.id,
         leavesSwapRequestId: request.id
       });
@@ -28803,7 +29247,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       limit,
       offset
     );
-    const identityPublicKey = (0, import_utils22.bytesToHex)(
+    const identityPublicKey = (0, import_utils23.bytesToHex)(
       await this.config.signer.getIdentityPublicKey()
     );
     return {
@@ -28824,14 +29268,14 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
     const { balance, tokenBalances } = await this.getBalance();
     const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
-      publicKeys: Array.from(tokenBalances.keys()).map(import_utils22.hexToBytes)
+      publicKeys: Array.from(tokenBalances.keys()).map(import_utils23.hexToBytes)
     });
     return tokenInfo.tokenPubkeyInfos.map((info) => ({
-      tokenPublicKey: (0, import_utils22.bytesToHex)(info.announcement.publicKey.publicKey),
+      tokenPublicKey: (0, import_utils23.bytesToHex)(info.announcement.publicKey.publicKey),
       tokenName: info.announcement.name,
       tokenSymbol: info.announcement.symbol,
-      tokenDecimals: Number((0, import_utils22.bytesToNumberBE)(info.announcement.decimal)),
-      maxSupply: (0, import_utils22.bytesToNumberBE)(info.announcement.maxSupply)
+      tokenDecimals: Number((0, import_utils23.bytesToNumberBE)(info.announcement.decimal)),
+      maxSupply: (0, import_utils23.bytesToNumberBE)(info.announcement.maxSupply)
     }));
   }
   /**
@@ -28860,11 +29304,11 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   async getTokenBalance() {
     const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
     const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
-      publicKeys: Array.from(this.tokenOutputs.keys()).map(import_utils22.hexToBytes)
+      publicKeys: Array.from(this.tokenOutputs.keys()).map(import_utils23.hexToBytes)
     });
     const result = /* @__PURE__ */ new Map();
     for (const info of tokenInfo.tokenPubkeyInfos) {
-      const tokenPublicKey = (0, import_utils22.bytesToHex)(
+      const tokenPublicKey = (0, import_utils23.bytesToHex)(
         info.announcement.publicKey.publicKey
       );
       const leaves = this.tokenOutputs.get(tokenPublicKey);
@@ -28874,8 +29318,8 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           tokenPublicKey,
           tokenName: info.announcement.name,
           tokenSymbol: info.announcement.symbol,
-          tokenDecimals: Number((0, import_utils22.bytesToNumberBE)(info.announcement.decimal)),
-          maxSupply: (0, import_utils22.bytesToNumberBE)(info.announcement.maxSupply)
+          tokenDecimals: Number((0, import_utils23.bytesToNumberBE)(info.announcement.decimal)),
+          maxSupply: (0, import_utils23.bytesToNumberBE)(info.announcement.maxSupply)
         }
       });
     }
@@ -29009,7 +29453,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     if (network === BitcoinNetwork_default.FUTURE_VALUE) {
       network = BitcoinNetwork_default.REGTEST;
     }
-    const depositSecretKey = (0, import_utils22.bytesToHex)(
+    const depositSecretKey = (0, import_utils23.bytesToHex)(
       await this.config.signer.getStaticDepositSecretKey(0)
     );
     const message = await this.getStaticDepositSigningPayload(
@@ -29022,7 +29466,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     );
     const hashBuffer = (0, import_sha213.sha256)(message);
     const signatureBytes = await this.config.signer.signMessageWithIdentityKey(hashBuffer);
-    const signature = (0, import_utils22.bytesToHex)(signatureBytes);
+    const signature = (0, import_utils23.bytesToHex)(signatureBytes);
     const response = await this.sspClient.claimStaticDeposit({
       transactionId,
       outputIndex,
@@ -29107,7 +29551,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       networkJSON.toLowerCase(),
       2 /* Refund */,
       creditAmountSats,
-      (0, import_utils22.bytesToHex)(spendTxSighash)
+      (0, import_utils23.bytesToHex)(spendTxSighash)
     );
     const hashBuffer = (0, import_sha213.sha256)(message);
     const swapResponseUserSignature = await this.config.signer.signMessageWithIdentityKey(hashBuffer);
@@ -29117,7 +29561,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const transferId = (0, import_uuidv75.uuidv7)();
     const swapResponse = await sparkClient.initiate_utxo_swap({
       onChainUtxo: {
-        txid: (0, import_utils22.hexToBytes)(depositTransactionId),
+        txid: (0, import_utils23.hexToBytes)(depositTransactionId),
         vout: outputIndex,
         network: networkType
       },
@@ -29194,7 +29638,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     creditAmountView.setUint32(0, lowerHalf, true);
     creditAmountView.setUint32(4, upperHalf, true);
     parts.push(new Uint8Array(creditAmountBuffer));
-    parts.push((0, import_utils22.hexToBytes)(sspSignature));
+    parts.push((0, import_utils23.hexToBytes)(sspSignature));
     const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
     const payload = new Uint8Array(totalLength);
     let offset = 0;
@@ -29544,9 +29988,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       this.config.getNetworkType()
     );
     const signerIdentityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const isSelfTransfer = (0, import_utils22.equalBytes)(
+    const isSelfTransfer = (0, import_utils23.equalBytes)(
       signerIdentityPublicKey,
-      (0, import_utils22.hexToBytes)(receiverAddress.identityPublicKey)
+      (0, import_utils23.hexToBytes)(receiverAddress.identityPublicKey)
     );
     return await this.withLeaves(async () => {
       let leavesToSend = await this.selectLeaves(amountSats);
@@ -29563,7 +30007,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       );
       const transfer = await this.transferService.sendTransferWithKeyTweaks(
         leafKeyTweaks,
-        (0, import_utils22.hexToBytes)(receiverAddress.identityPublicKey)
+        (0, import_utils23.hexToBytes)(receiverAddress.identityPublicKey)
       );
       const leavesToRemove = new Set(leavesToSend.map((leaf) => leaf.id));
       this.leaves = this.leaves.filter((leaf) => !leavesToRemove.has(leaf.id));
@@ -29579,7 +30023,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       }
       return mapTransferToWalletTransfer(
         transfer,
-        (0, import_utils22.bytesToHex)(await this.config.signer.getIdentityPublicKey())
+        (0, import_utils23.bytesToHex)(await this.config.signer.getIdentityPublicKey())
       );
     });
   }
@@ -29903,7 +30347,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       const invoice2 = await sspClient.requestLightningReceive({
         amountSats: amountSats2,
         network: bitcoinNetwork,
-        paymentHash: (0, import_utils22.bytesToHex)(paymentHash),
+        paymentHash: (0, import_utils23.bytesToHex)(paymentHash),
         expirySecs: expirySeconds,
         memo: memo2,
         includeSparkAddress,
@@ -29917,7 +30361,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         const sparkFallbackAddress = decodeInvoice(
           invoice2.invoice.encodedInvoice
         ).fallbackAddress;
-        if (sparkFallbackAddress && isValidSparkFallback((0, import_utils22.hexToBytes)(sparkFallbackAddress))) {
+        if (sparkFallbackAddress && isValidSparkFallback((0, import_utils23.hexToBytes)(sparkFallbackAddress))) {
           const invoiceIdentityPubkey = sparkFallbackAddress.slice(6);
           const expectedIdentityPubkey = receiverIdentityPubkey2 ?? await this.getIdentityPublicKey();
           if (invoiceIdentityPubkey !== expectedIdentityPubkey) {
@@ -29958,12 +30402,14 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    * @param {Object} params - Parameters for paying the invoice
    * @param {string} params.invoice - The BOLT11-encoded Lightning invoice to pay
    * @param {boolean} [params.preferSpark] - Whether to prefer a spark transfer over lightning for the payment
+   * @param {number} [params.amountSatsToSend] - The amount in sats to send. This is only valid for 0 amount lightning invoices.
    * @returns {Promise<LightningSendRequest>} The Lightning payment request details
    */
   async payLightningInvoice({
     invoice,
     maxFeeSats,
-    preferSpark = false
+    preferSpark = false,
+    amountSatsToSend
   }) {
     const invoiceNetwork = getNetworkFromInvoice(invoice);
     const walletNetwork = this.config.getNetwork();
@@ -29978,11 +30424,40 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       );
     }
     const decodedInvoice = decodeInvoice(invoice);
-    const amountSats = decodedInvoice.amountMSats !== null ? Number(decodedInvoice.amountMSats / 1000n) : 0;
+    const amountMSats = decodedInvoice.amountMSats;
+    const isZeroAmountInvoice = !amountMSats;
+    if (!isZeroAmountInvoice && amountSatsToSend !== void 0) {
+      throw new ValidationError(
+        "Invalid amount. User can only specify amountSatsToSend for 0 amount lightning invoice",
+        {
+          field: "amountMSats",
+          value: Number(amountMSats),
+          expected: "0"
+        }
+      );
+    }
+    if (isZeroAmountInvoice && amountSatsToSend === void 0) {
+      throw new ValidationError(
+        "Invalid amount. User must specify amountSatsToSend for 0 amount lightning invoice",
+        {
+          field: "amountMSats",
+          value: Number(amountMSats),
+          expected: "0"
+        }
+      );
+    }
+    const amountSats = isZeroAmountInvoice ? amountSatsToSend : Number(amountMSats / 1000n);
+    if (isNaN(amountSats) || amountSats <= 0) {
+      throw new ValidationError("Invalid amount", {
+        field: "amountSats",
+        value: amountSats,
+        expected: "greater than 0"
+      });
+    }
     const sparkFallbackAddress = decodedInvoice.fallbackAddress;
     const paymentHash = decodedInvoice.paymentHash;
     if (preferSpark) {
-      if (sparkFallbackAddress === void 0 || isValidSparkFallback((0, import_utils22.hexToBytes)(sparkFallbackAddress)) === false) {
+      if (sparkFallbackAddress === void 0 || isValidSparkFallback((0, import_utils23.hexToBytes)(sparkFallbackAddress)) === false) {
         console.warn(
           "No valid spark address found in invoice. Defaulting to lightning."
         );
@@ -30000,15 +30475,9 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     }
     return await this.withLeaves(async () => {
       const sspClient = this.getSspClient();
-      if (isNaN(amountSats) || amountSats <= 0) {
-        throw new ValidationError("Invalid amount", {
-          field: "amountSats",
-          value: amountSats,
-          expected: "positive number"
-        });
-      }
       const feeEstimate = await this.getLightningSendFeeEstimate({
-        encodedInvoice: invoice
+        encodedInvoice: invoice,
+        amountSats: isZeroAmountInvoice ? amountSatsToSend : void 0
       });
       if (maxFeeSats < feeEstimate) {
         throw new ValidationError("maxFeeSats does not cover fee estimate", {
@@ -30040,25 +30509,27 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       );
       const swapResponse = await this.lightningService.swapNodesForPreimage({
         leaves: leavesToSend,
-        receiverIdentityPubkey: (0, import_utils22.hexToBytes)(
+        receiverIdentityPubkey: (0, import_utils23.hexToBytes)(
           this.config.getSspIdentityPublicKey()
         ),
-        paymentHash: (0, import_utils22.hexToBytes)(paymentHash),
+        paymentHash: (0, import_utils23.hexToBytes)(paymentHash),
         isInboundPayment: false,
         invoiceString: invoice,
-        feeSats: feeEstimate
+        feeSats: feeEstimate,
+        amountSatsToSend
       });
       if (!swapResponse.transfer) {
         throw new Error("Failed to swap nodes for preimage");
       }
-      const transfer = await this.transferService.sendTransferTweakKey(
+      await this.transferService.deliverTransferPackage(
         swapResponse.transfer,
         leavesToSend,
         /* @__PURE__ */ new Map()
       );
       const sspResponse = await sspClient.requestLightningSend({
         encodedInvoice: invoice,
-        idempotencyKey: paymentHash
+        idempotencyKey: paymentHash,
+        amountSats: isZeroAmountInvoice ? amountSatsToSend : void 0
       });
       if (!sspResponse) {
         throw new Error("Failed to contact SSP");
@@ -30075,14 +30546,18 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    * @returns {Promise<number>} Fee estimate for sending Lightning payments
    */
   async getLightningSendFeeEstimate({
-    encodedInvoice
+    encodedInvoice,
+    amountSats
   }) {
     const sspClient = this.getSspClient();
-    const feeEstimate = await sspClient.getLightningSendFeeEstimate(encodedInvoice);
+    const feeEstimate = await sspClient.getLightningSendFeeEstimate(
+      encodedInvoice,
+      amountSats
+    );
     if (!feeEstimate) {
       throw new Error("Failed to get lightning send fee estimate");
     }
-    const satsFeeEstimate = (0, import_core12.mapCurrencyAmount)(feeEstimate.feeEstimate);
+    const satsFeeEstimate = (0, import_core14.mapCurrencyAmount)(feeEstimate.feeEstimate);
     return Math.ceil(satsFeeEstimate.sats);
   }
   // ***** Tree Creation Flow *****
@@ -30240,11 +30715,11 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const connectorOutputs = [];
     for (let i = 0; i < connectorTx.outputsLength - 1; i++) {
       connectorOutputs.push({
-        txid: (0, import_utils22.hexToBytes)(connectorTxId),
+        txid: (0, import_utils23.hexToBytes)(connectorTxId),
         index: i
       });
     }
-    const sspPubIdentityKey = (0, import_utils22.hexToBytes)(this.config.getSspIdentityPublicKey());
+    const sspPubIdentityKey = (0, import_utils23.hexToBytes)(this.config.getSspIdentityPublicKey());
     const transfer = await this.coopExitService.getConnectorRefundSignatures({
       leaves: leafKeyTweaks,
       exitTxId: coopExitTxId,
@@ -30331,7 +30806,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     );
     const groupedOutputs = /* @__PURE__ */ new Map();
     filteredTokenOutputs.forEach((output) => {
-      const tokenKey = (0, import_utils22.bytesToHex)(output.output.tokenPublicKey);
+      const tokenKey = (0, import_utils23.bytesToHex)(output.output.tokenPublicKey);
       const index = output.previousTransactionVout;
       if (!groupedOutputs.has(tokenKey)) {
         groupedOutputs.set(tokenKey, []);
@@ -30429,14 +30904,14 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     let queryParams;
     if (tokenTransactionHashes?.length) {
       queryParams = {
-        tokenPublicKeys: tokenPublicKeys?.map(import_utils22.hexToBytes),
-        ownerPublicKeys: [(0, import_utils22.hexToBytes)(await this.getIdentityPublicKey())],
-        tokenTransactionHashes: tokenTransactionHashes.map(import_utils22.hexToBytes)
+        tokenPublicKeys: tokenPublicKeys?.map(import_utils23.hexToBytes),
+        ownerPublicKeys: [(0, import_utils23.hexToBytes)(await this.getIdentityPublicKey())],
+        tokenTransactionHashes: tokenTransactionHashes.map(import_utils23.hexToBytes)
       };
     } else {
       queryParams = {
-        tokenPublicKeys: tokenPublicKeys?.map(import_utils22.hexToBytes),
-        ownerPublicKeys: [(0, import_utils22.hexToBytes)(await this.getIdentityPublicKey())]
+        tokenPublicKeys: tokenPublicKeys?.map(import_utils23.hexToBytes),
+        ownerPublicKeys: [(0, import_utils23.hexToBytes)(await this.getIdentityPublicKey())]
       };
     }
     const response = await sparkClient.query_token_transactions(queryParams);
@@ -30461,7 +30936,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
       hash,
       compact
     );
-    return (0, import_utils22.bytesToHex)(signature);
+    return (0, import_utils23.bytesToHex)(signature);
   }
   /**
    * Validates a message with the identity key.
@@ -30473,7 +30948,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
   async validateMessageWithIdentityKey(message, signature) {
     const hash = (0, import_sha213.sha256)(message);
     if (typeof signature === "string") {
-      signature = (0, import_utils22.hexToBytes)(signature);
+      signature = (0, import_utils23.hexToBytes)(signature);
     }
     return this.config.signer.validateMessageWithIdentityKey(hash, signature);
   }
@@ -30486,7 +30961,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
    */
   async signTransaction(txHex, keyType = "auto-detect") {
     try {
-      const tx = import_btc_signer7.Transaction.fromRaw((0, import_utils22.hexToBytes)(txHex));
+      const tx = import_btc_signer7.Transaction.fromRaw((0, import_utils23.hexToBytes)(txHex));
       let publicKey;
       switch (keyType.toLowerCase()) {
         case "identity":
@@ -30519,7 +30994,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
           publicKey,
           this.config.getNetwork()
         );
-        if ((0, import_utils22.bytesToHex)(script) === (0, import_utils22.bytesToHex)(identityScript)) {
+        if ((0, import_utils23.bytesToHex)(script) === (0, import_utils23.bytesToHex)(identityScript)) {
           try {
             this.config.signer.signTransactionIndex(tx, i, publicKey);
             inputsSigned++;
@@ -30563,13 +31038,13 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
             depositPubKey,
             this.config.getNetwork()
           );
-          if ((0, import_utils22.bytesToHex)(script) === (0, import_utils22.bytesToHex)(identityScript)) {
+          if ((0, import_utils23.bytesToHex)(script) === (0, import_utils23.bytesToHex)(identityScript)) {
             return {
               publicKey: identityPubKey,
               keyType: "identity"
             };
           }
-          if ((0, import_utils22.bytesToHex)(script) === (0, import_utils22.bytesToHex)(depositScript)) {
+          if ((0, import_utils23.bytesToHex)(script) === (0, import_utils23.bytesToHex)(depositScript)) {
             return {
               publicKey: depositPubKey,
               keyType: "deposit"
@@ -30967,7 +31442,7 @@ async function isTxBroadcast(txid, baseUrl, network) {
 
 // src/utils/unilateral-exit.ts
 init_buffer();
-var import_utils23 = require("@noble/curves/abstract/utils");
+var import_utils24 = require("@noble/curves/abstract/utils");
 var import_legacy = require("@noble/hashes/legacy");
 var import_sha214 = require("@noble/hashes/sha2");
 var btc5 = __toESM(require("@scure/btc-signer"), 1);
@@ -30982,7 +31457,7 @@ function isEphemeralAnchorOutput(script, amount) {
 }
 async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network) {
   const result = [];
-  const nodes = nodeHexStrings.map((hex) => TreeNode.decode((0, import_utils23.hexToBytes)(hex)));
+  const nodes = nodeHexStrings.map((hex) => TreeNode.decode((0, import_utils24.hexToBytes)(hex)));
   const nodeMap = /* @__PURE__ */ new Map();
   for (const node of nodes) {
     nodeMap.set(node.id, node);
@@ -31038,10 +31513,10 @@ async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network)
       }
     }
     for (const chainNode of chain) {
-      const nodeTx = (0, import_utils23.bytesToHex)(chainNode.nodeTx);
+      const nodeTx = (0, import_utils24.bytesToHex)(chainNode.nodeTx);
       transactions.push(nodeTx);
       if (chainNode.id === node.id) {
-        const refundTx = (0, import_utils23.bytesToHex)(chainNode.refundTx);
+        const refundTx = (0, import_utils24.bytesToHex)(chainNode.refundTx);
         transactions.push(refundTx);
       }
     }
@@ -31071,7 +31546,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           `Node hex string at index ${i} appears to be a raw transaction hex, not a TreeNode protobuf. Use 'leafidtohex' command to convert node IDs to proper hex strings.`
         );
       }
-      const nodeBytes = (0, import_utils23.hexToBytes)(hex);
+      const nodeBytes = (0, import_utils24.hexToBytes)(hex);
       const node = TreeNode.decode(nodeBytes);
       if (!node.id) {
         throw new Error(
@@ -31147,7 +31622,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
       }
     }
     for (const chainNode of chain) {
-      let nodeTxHex = (0, import_utils23.bytesToHex)(chainNode.nodeTx);
+      let nodeTxHex = (0, import_utils24.bytesToHex)(chainNode.nodeTx);
       try {
         const txObj = getTxFromRawTxHex(nodeTxHex);
         const txid = getTxId(txObj);
@@ -31164,7 +31639,7 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
         for (let i = txObj.outputsLength - 1; i >= 0; i--) {
           const output = txObj.getOutput(i);
           if (output?.amount === 0n && output.script) {
-            anchorOutputScriptHex = (0, import_utils23.bytesToHex)(output.script);
+            anchorOutputScriptHex = (0, import_utils24.bytesToHex)(output.script);
             break;
           }
         }
@@ -31185,11 +31660,11 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
         usedUtxos,
         correctedParentTx
       } = constructFeeBumpTx(nodeTxHex, availableUtxos, feeRate, void 0);
-      const feeBumpTx = btc5.Transaction.fromPSBT((0, import_utils23.hexToBytes)(nodeFeeBumpPsbt));
+      const feeBumpTx = btc5.Transaction.fromPSBT((0, import_utils24.hexToBytes)(nodeFeeBumpPsbt));
       var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
       var feeBumpOutPubKey = null;
       for (const usedUtxo of usedUtxos) {
-        if (feeBumpOut && (0, import_utils23.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
+        if (feeBumpOut && (0, import_utils24.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
           feeBumpOutPubKey = usedUtxo.publicKey;
         }
         const index = availableUtxos.findIndex(
@@ -31204,20 +31679,20 @@ async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, fee
           txid: getTxId(feeBumpTx),
           vout: 0,
           value: feeBumpOut.amount,
-          script: (0, import_utils23.bytesToHex)(feeBumpOut.script),
+          script: (0, import_utils24.bytesToHex)(feeBumpOut.script),
           publicKey: feeBumpOutPubKey
         });
       const finalNodeTx = correctedParentTx || nodeTxHex;
       txPackages.push({ tx: finalNodeTx, feeBumpPsbt: nodeFeeBumpPsbt });
       if (chainNode.id === node.id) {
-        let refundTxHex = (0, import_utils23.bytesToHex)(chainNode.refundTx);
+        let refundTxHex = (0, import_utils24.bytesToHex)(chainNode.refundTx);
         try {
           const txObj = getTxFromRawTxHex(refundTxHex);
           let anchorOutputScriptHex;
           for (let i = txObj.outputsLength - 1; i >= 0; i--) {
             const output = txObj.getOutput(i);
             if (output?.amount === 0n && output.script) {
-              anchorOutputScriptHex = (0, import_utils23.bytesToHex)(output.script);
+              anchorOutputScriptHex = (0, import_utils24.bytesToHex)(output.script);
               break;
             }
           }
@@ -31331,10 +31806,10 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
     if (!fundingUtxo) {
       throw new Error(`UTXO at index ${i} is undefined`);
     }
-    const pubKeyHash = hash160((0, import_utils23.hexToBytes)(fundingUtxo.publicKey));
+    const pubKeyHash = hash160((0, import_utils24.hexToBytes)(fundingUtxo.publicKey));
     const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
-    const providedScript = (0, import_utils23.hexToBytes)(fundingUtxo.script);
-    if ((0, import_utils23.bytesToHex)(scriptToUse) !== (0, import_utils23.bytesToHex)(providedScript)) {
+    const providedScript = (0, import_utils24.hexToBytes)(fundingUtxo.script);
+    if ((0, import_utils24.bytesToHex)(scriptToUse) !== (0, import_utils24.bytesToHex)(providedScript)) {
       throw new Error(
         `\u274C  Derived script doesn't match provided script for UTXO ${i + 1}.`
       );
@@ -31399,7 +31874,7 @@ function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
   }
   let psbtHex;
   try {
-    psbtHex = (0, import_utils23.bytesToHex)(builder.toPSBT());
+    psbtHex = (0, import_utils24.bytesToHex)(builder.toPSBT());
   } catch (error) {
     throw new Error(`Failed to extract transaction: ${error}`);
   }