@buildonspark/spark-sdk 0.3.3 → 0.3.5

package/dist/{chunk-SXXM52XH.js → chunk-JE73HB26.js}

@@ -4,11 +4,11 @@ import {
 } from "./chunk-NX5KPN5F.js";
 import {
   SparkTokenServiceDefinition
-} from "./chunk-73GJOG5R.js";
+} from "./chunk-XWLR6G5C.js";
 import {
   mapTransferToWalletTransfer,
   mapTreeNodeToWalletLeaf
-} from "./chunk-MH7BMOLL.js";
+} from "./chunk-J2P3KTQP.js";
 import {
   Empty,
   SatsPayment,
@@ -19,7 +19,7 @@ import {
   TokensPayment,
   TreeNode,
   networkToJSON
-} from "./chunk-MGCUXELA.js";
+} from "./chunk-IC4IUEOS.js";
 import {
   BitcoinNetwork_default,
   ClaimStaticDepositFromJson,
@@ -584,7 +584,7 @@ var isWebExtension = (
   "chrome" in globalThis && globalThis.chrome.runtime?.id
 );
 var userAgent = "navigator" in globalThis ? globalThis.navigator.userAgent || "unknown-user-agent" : void 0;
-var packageVersion = true ? "0.3.3" : "unknown";
+var packageVersion = true ? "0.3.5" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -1273,7 +1273,6 @@ var BASE_CONFIG = {
   threshold: 2,
   signingOperators: getLocalSigningOperators(),
   tokenSignatures: "SCHNORR",
-  tokenTransactionVersion: "V1",
   tokenValidityDurationSeconds: 180,
   electrsUrl: getElectrsUrl("LOCAL"),
   expectedWithdrawBondSats: 1e4,
@@ -1477,9 +1476,6 @@ var WalletConfigService = class {
   getTokenSignatures() {
     return this.config.tokenSignatures;
   }
-  getTokenTransactionVersion() {
-    return this.config.tokenTransactionVersion;
-  }
   getTokenValidityDurationSeconds() {
     return this.config.tokenValidityDurationSeconds;
   }
@@ -4173,6 +4169,13 @@ function uint64be(value) {
 // src/utils/address.ts
 var BECH32M_LIMIT = 1024;
 var AddressNetwork = {
+  MAINNET: "spark",
+  TESTNET: "sparkt",
+  REGTEST: "sparkrt",
+  SIGNET: "sparks",
+  LOCAL: "sparkl"
+};
+var LegacyAddressNetwork = {
   MAINNET: "sp",
   TESTNET: "spt",
   REGTEST: "sprt",
@@ -4203,7 +4206,7 @@ function encodeSparkAddressWithSignature(payload, signature) {
     const serializedPayload = w.finish();
     const words = bech32m.toWords(serializedPayload);
     return bech32mEncode(
-      AddressNetwork[payload.network],
+      LegacyAddressNetwork[payload.network],
       words
     );
   } catch (error) {
@@ -4219,14 +4222,14 @@ function encodeSparkAddressWithSignature(payload, signature) {
 }
 function decodeSparkAddress(address2, network) {
   try {
-    const decoded = bech32mDecode(address2);
-    if (decoded.prefix !== AddressNetwork[network]) {
+    if (network !== getNetworkFromSparkAddress(address2)) {
       throw new ValidationError("Invalid Spark address prefix", {
         field: "address",
         value: address2,
-        expected: `prefix='${AddressNetwork[network]}'`
+        expected: `prefix='${AddressNetwork[network]}' or '${LegacyAddressNetwork[network]}'`
       });
     }
+    const decoded = bech32mDecode(address2);
     const payload = SparkAddress.decode(bech32m.fromWords(decoded.words));
     const { identityPublicKey, sparkInvoiceFields, signature } = payload;
     const identityPubkeyHex = bytesToHex5(identityPublicKey);
@@ -4270,18 +4273,35 @@ function decodeSparkAddress(address2, network) {
     );
   }
 }
+var PrefixToNetwork = Object.fromEntries(
+  Object.entries(AddressNetwork).map(([k, v]) => [v, k])
+);
+var LegacyPrefixToNetwork = Object.fromEntries(
+  Object.entries(LegacyAddressNetwork).map(([k, v]) => [v, k])
+);
+function getNetworkFromSparkAddress(address2) {
+  const { prefix } = bech32mDecode(address2);
+  const network = PrefixToNetwork[prefix] ?? LegacyPrefixToNetwork[prefix];
+  if (!network) {
+    throw new ValidationError("Invalid Spark address prefix", {
+      field: "network",
+      value: address2,
+      expected: "prefix='spark1', 'sparkt1', 'sparkrt1', 'sparks1', 'sparkl1' or legacy ('sp1', 'spt1', 'sprt1', 'sps1', 'spl1')"
+    });
+  }
+  return network;
+}
+function isLegacySparkAddress(address2) {
+  try {
+    const { prefix } = bech32mDecode(address2);
+    return prefix in LegacyPrefixToNetwork;
+  } catch (error) {
+    return false;
+  }
+}
 function isValidSparkAddress(address2) {
   try {
-    const network = Object.entries(AddressNetwork).find(
-      ([_, prefix]) => address2.startsWith(prefix)
-    )?.[0];
-    if (!network) {
-      throw new ValidationError("Invalid Spark address network", {
-        field: "network",
-        value: address2,
-        expected: Object.values(AddressNetwork)
-      });
-    }
+    const network = getNetworkFromSparkAddress(address2);
     decodeSparkAddress(address2, network);
     return true;
   } catch (error) {
@@ -4477,25 +4497,16 @@ function validateSparkInvoiceSignature(invoice) {
     );
   }
 }
-function getNetworkFromSparkAddress(address2) {
-  const { prefix } = bech32mDecode(address2);
-  const network = Object.entries(AddressNetwork).find(
-    ([, p]) => p === prefix
-  )?.[0];
-  if (!network) {
-    throw new ValidationError("Invalid Spark address network", {
-      field: "network",
-      value: address2,
-      expected: Object.values(AddressNetwork)
-    });
-  }
-  return network;
-}
 function toProtoTimestamp(date) {
   const ms = date.getTime();
   return { seconds: Math.floor(ms / 1e3), nanos: ms % 1e3 * 1e6 };
 }
+function assertBech32(s) {
+  const i = s.lastIndexOf("1");
+  if (i <= 0 || i >= s.length - 1) throw new Error("invalid bech32 string");
+}
 function bech32mDecode(address2) {
+  assertBech32(address2);
   return bech32m.decode(address2, BECH32M_LIMIT);
 }
 function bech32mEncode(prefix, words) {
@@ -4530,27 +4541,6 @@ function isSafeForNumber(bi) {
   return bi >= BigInt(Number.MIN_SAFE_INTEGER) && bi <= BigInt(Number.MAX_SAFE_INTEGER);
 }
 
-// src/utils/response-validation.ts
-function collectResponses(responses) {
-  const successfulResponses = responses.filter(
-    (result) => result.status === "fulfilled"
-  ).map((result) => result.value);
-  const failedResponses = responses.filter(
-    (result) => result.status === "rejected"
-  );
-  if (failedResponses.length > 0) {
-    const errors = failedResponses.map((result) => result.reason).join("\n");
-    throw new NetworkError(
-      `${failedResponses.length} out of ${responses.length} requests failed, please try again`,
-      {
-        errorCount: failedResponses.length,
-        errors
-      }
-    );
-  }
-  return successfulResponses;
-}
-
 // src/utils/token-identifier.ts
 import { bech32m as bech32m2 } from "@scure/base";
 var Bech32mTokenIdentifierTokenIdentifierNetworkPrefix = {
@@ -4697,7 +4687,6 @@ function filterTokenBalanceForTokenIdentifier(tokenBalances, tokenIdentifier) {
 }
 
 // src/services/token-transactions.ts
-import { secp256k1 as secp256k19 } from "@noble/curves/secp256k1";
 import {
   bytesToHex as bytesToHex6,
   bytesToNumberBE as bytesToNumberBE5,
@@ -4710,8 +4699,6 @@ import { sha256 as sha2568 } from "@noble/hashes/sha2";
 import { bech32m as bech32m3 } from "@scure/base";
 function hashTokenTransaction(tokenTransaction, partialHash = false) {
   switch (tokenTransaction.version) {
-    case 0:
-      return hashTokenTransactionV0(tokenTransaction, partialHash);
     case 1:
       return hashTokenTransactionV1(tokenTransaction, partialHash);
     case 2:
@@ -4723,13 +4710,43 @@ function hashTokenTransaction(tokenTransaction, partialHash = false) {
       });
   }
 }
-function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
+function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
   if (!tokenTransaction) {
     throw new ValidationError("token transaction cannot be nil", {
       field: "tokenTransaction"
     });
   }
   let allHashes = [];
+  const versionHashObj = sha2568.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());
+  const typeHashObj = sha2568.create();
+  const typeBytes = new Uint8Array(4);
+  let transactionType = 0;
+  if (tokenTransaction.tokenInputs?.$case === "mintInput") {
+    transactionType = 2 /* TOKEN_TRANSACTION_TYPE_MINT */;
+  } else if (tokenTransaction.tokenInputs?.$case === "transferInput") {
+    transactionType = 3 /* TOKEN_TRANSACTION_TYPE_TRANSFER */;
+  } else if (tokenTransaction.tokenInputs?.$case === "createInput") {
+    transactionType = 1 /* TOKEN_TRANSACTION_TYPE_CREATE */;
+  } else {
+    throw new ValidationError(
+      "token transaction must have exactly one input type",
+      {
+        field: "tokenInputs"
+      }
+    );
+  }
+  new DataView(typeBytes.buffer).setUint32(0, transactionType, false);
+  typeHashObj.update(typeBytes);
+  allHashes.push(typeHashObj.digest());
   if (tokenTransaction.tokenInputs?.$case === "transferInput") {
     if (!tokenTransaction.tokenInputs.transferInput.outputsToSpend) {
       throw new ValidationError("outputs to spend cannot be null", {
@@ -4741,6 +4758,15 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
         field: "tokenInputs.transferInput.outputsToSpend"
       });
     }
+    const outputsLenHashObj2 = sha2568.create();
+    const outputsLenBytes2 = new Uint8Array(4);
+    new DataView(outputsLenBytes2.buffer).setUint32(
+      0,
+      tokenTransaction.tokenInputs.transferInput.outputsToSpend.length,
+      false
+    );
+    outputsLenHashObj2.update(outputsLenBytes2);
+    allHashes.push(outputsLenHashObj2.digest());
     for (const [
       i,
       output
@@ -4777,8 +4803,7 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
       hashObj2.update(voutBytes);
       allHashes.push(hashObj2.digest());
     }
-  }
-  if (tokenTransaction.tokenInputs?.$case === "mintInput") {
+  } else if (tokenTransaction.tokenInputs?.$case === "mintInput") {
     const hashObj2 = sha2568.create();
     if (tokenTransaction.tokenInputs.mintInput.issuerPublicKey) {
       const issuerPubKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
@@ -4791,32 +4816,20 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
         });
       }
       hashObj2.update(issuerPubKey);
-      let timestampValue = 0;
-      const mintInput = tokenTransaction.tokenInputs.mintInput;
-      if ("issuerProvidedTimestamp" in mintInput) {
-        const v0MintInput = mintInput;
-        if (v0MintInput.issuerProvidedTimestamp != 0) {
-          timestampValue = v0MintInput.issuerProvidedTimestamp;
-        }
-      } else if ("clientCreatedTimestamp" in tokenTransaction && tokenTransaction.clientCreatedTimestamp) {
-        timestampValue = tokenTransaction.clientCreatedTimestamp.getTime();
-      }
-      if (timestampValue != 0) {
-        const timestampBytes = new Uint8Array(8);
-        new DataView(timestampBytes.buffer).setBigUint64(
-          0,
-          BigInt(timestampValue),
-          true
-          // true for little-endian to match Go implementation
+      allHashes.push(hashObj2.digest());
+      const tokenIdentifierHashObj = sha2568.create();
+      if (tokenTransaction.tokenInputs.mintInput.tokenIdentifier) {
+        tokenIdentifierHashObj.update(
+          tokenTransaction.tokenInputs.mintInput.tokenIdentifier
         );
-        hashObj2.update(timestampBytes);
+      } else {
+        tokenIdentifierHashObj.update(new Uint8Array(32));
       }
-      allHashes.push(hashObj2.digest());
+      allHashes.push(tokenIdentifierHashObj.digest());
     }
-  }
-  if (tokenTransaction.tokenInputs?.$case === "createInput") {
-    const issuerPubKeyHashObj = sha2568.create();
+  } else if (tokenTransaction.tokenInputs?.$case === "createInput") {
     const createInput = tokenTransaction.tokenInputs.createInput;
+    const issuerPubKeyHashObj = sha2568.create();
     if (!createInput.issuerPublicKey || createInput.issuerPublicKey.length === 0) {
       throw new ValidationError("issuer public key cannot be nil or empty", {
         field: "tokenInputs.createInput.issuerPublicKey"
@@ -4838,10 +4851,8 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
         actualLength: createInput.tokenName.length
       });
     }
-    const tokenNameBytes = new Uint8Array(20);
     const tokenNameEncoder = new TextEncoder();
-    tokenNameBytes.set(tokenNameEncoder.encode(createInput.tokenName));
-    tokenNameHashObj.update(tokenNameBytes);
+    tokenNameHashObj.update(tokenNameEncoder.encode(createInput.tokenName));
     allHashes.push(tokenNameHashObj.digest());
     const tokenTickerHashObj = sha2568.create();
     if (!createInput.tokenTicker || createInput.tokenTicker.length === 0) {
@@ -4857,10 +4868,10 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
         actualLength: createInput.tokenTicker.length
       });
     }
-    const tokenTickerBytes = new Uint8Array(6);
     const tokenTickerEncoder = new TextEncoder();
-    tokenTickerBytes.set(tokenTickerEncoder.encode(createInput.tokenTicker));
-    tokenTickerHashObj.update(tokenTickerBytes);
+    tokenTickerHashObj.update(
+      tokenTickerEncoder.encode(createInput.tokenTicker)
+    );
     allHashes.push(tokenTickerHashObj.digest());
     const decimalsHashObj = sha2568.create();
     const decimalsBytes = new Uint8Array(4);
@@ -4888,8 +4899,9 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
     maxSupplyHashObj.update(createInput.maxSupply);
     allHashes.push(maxSupplyHashObj.digest());
     const isFreezableHashObj = sha2568.create();
-    const isFreezableByte = new Uint8Array([createInput.isFreezable ? 1 : 0]);
-    isFreezableHashObj.update(isFreezableByte);
+    isFreezableHashObj.update(
+      new Uint8Array([createInput.isFreezable ? 1 : 0])
+    );
     allHashes.push(isFreezableHashObj.digest());
     const creationEntityHashObj = sha2568.create();
     if (!partialHash && createInput.creationEntityPublicKey) {
@@ -4902,11 +4914,15 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
       field: "tokenOutputs"
     });
   }
-  if (tokenTransaction.tokenOutputs.length === 0 && tokenTransaction.tokenInputs?.$case !== "createInput") {
-    throw new ValidationError("token outputs cannot be empty", {
-      field: "tokenOutputs"
-    });
-  }
+  const outputsLenHashObj = sha2568.create();
+  const outputsLenBytes = new Uint8Array(4);
+  new DataView(outputsLenBytes.buffer).setUint32(
+    0,
+    tokenTransaction.tokenOutputs.length,
+    false
+  );
+  outputsLenHashObj.update(outputsLenBytes);
+  allHashes.push(outputsLenHashObj.digest());
   for (const [i, output] of tokenTransaction.tokenOutputs.entries()) {
     if (!output) {
       throw new ValidationError(`output cannot be null at index ${i}`, {
@@ -4965,18 +4981,16 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = 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
-          }
-        );
-      }
+    if (!output.tokenPublicKey || output.tokenPublicKey.length === 0) {
+      hashObj2.update(new Uint8Array(33));
+    } else {
       hashObj2.update(output.tokenPublicKey);
     }
+    if (!output.tokenIdentifier || output.tokenIdentifier.length === 0) {
+      hashObj2.update(new Uint8Array(32));
+    } else {
+      hashObj2.update(output.tokenIdentifier);
+    }
     if (output.tokenAmount) {
       if (output.tokenAmount.length === 0) {
         throw new ValidationError(
@@ -5017,6 +5031,15 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
     }
     return a.length - b.length;
   });
+  const operatorLenHashObj = sha2568.create();
+  const operatorLenBytes = new Uint8Array(4);
+  new DataView(operatorLenBytes.buffer).setUint32(
+    0,
+    sortedPubKeys.length,
+    false
+  );
+  operatorLenHashObj.update(operatorLenBytes);
+  allHashes.push(operatorLenHashObj.digest());
   for (const [i, pubKey] of sortedPubKeys.entries()) {
     if (!pubKey) {
       throw new ValidationError(
@@ -5050,6 +5073,38 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
   );
   hashObj.update(networkBytes);
   allHashes.push(hashObj.digest());
+  const clientTimestampHashObj = sha2568.create();
+  const clientCreatedTs = tokenTransaction.clientCreatedTimestamp;
+  if (!clientCreatedTs) {
+    throw new ValidationError(
+      "client created timestamp cannot be null for V1 token transactions",
+      {
+        field: "clientCreatedTimestamp"
+      }
+    );
+  }
+  const clientUnixTime = clientCreatedTs.getTime();
+  const clientTimestampBytes = new Uint8Array(8);
+  new DataView(clientTimestampBytes.buffer).setBigUint64(
+    0,
+    BigInt(clientUnixTime),
+    false
+  );
+  clientTimestampHashObj.update(clientTimestampBytes);
+  allHashes.push(clientTimestampHashObj.digest());
+  if (!partialHash) {
+    const expiryHashObj = sha2568.create();
+    const expiryTimeBytes = new Uint8Array(8);
+    const expiryUnixTime = tokenTransaction.expiryTime ? Math.floor(tokenTransaction.expiryTime.getTime() / 1e3) : 0;
+    new DataView(expiryTimeBytes.buffer).setBigUint64(
+      0,
+      BigInt(expiryUnixTime),
+      false
+      // false for big-endian
+    );
+    expiryHashObj.update(expiryTimeBytes);
+    allHashes.push(expiryHashObj.digest());
+  }
   const finalHashObj = sha2568.create();
   const concatenatedHashes = new Uint8Array(
     allHashes.reduce((sum, hash) => sum + hash.length, 0)
@@ -5062,7 +5117,7 @@ function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
   finalHashObj.update(concatenatedHashes);
   return finalHashObj.digest();
 }
-function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
+function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
   if (!tokenTransaction) {
     throw new ValidationError("token transaction cannot be nil", {
       field: "tokenTransaction"
@@ -5457,6 +5512,72 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
     expiryHashObj.update(expiryTimeBytes);
     allHashes.push(expiryHashObj.digest());
   }
+  const attachments = tokenTransaction.invoiceAttachments;
+  const lenHash = sha2568.create();
+  const lenBytes = new Uint8Array(4);
+  new DataView(lenBytes.buffer).setUint32(
+    0,
+    attachments ? attachments.length : 0,
+    false
+  );
+  lenHash.update(lenBytes);
+  allHashes.push(lenHash.digest());
+  const sortedInvoices = [];
+  if (attachments) {
+    for (let i = 0; i < attachments.length; i++) {
+      const attachment = attachments[i];
+      if (!attachment) {
+        throw new ValidationError(
+          `invoice attachment at index ${i} cannot be null`,
+          {
+            field: `invoiceAttachments[${i}]`,
+            index: i
+          }
+        );
+      }
+      const invoice = attachment.sparkInvoice;
+      let idBytes;
+      try {
+        const decoded = bech32m3.decode(invoice, 500);
+        const payload = SparkAddress.decode(bech32m3.fromWords(decoded.words));
+        if (!payload.sparkInvoiceFields || !payload.sparkInvoiceFields.id) {
+          throw new Error("missing spark invoice fields or id");
+        }
+        idBytes = payload.sparkInvoiceFields.id;
+      } catch (err) {
+        throw new ValidationError(
+          `invalid invoice at ${i}`,
+          {
+            field: `invoiceAttachments[${i}].sparkInvoice`,
+            index: i,
+            value: invoice
+          },
+          err
+        );
+      }
+      if (!idBytes || idBytes.length !== 16) {
+        throw new ValidationError(`invalid invoice id at ${i}`, {
+          field: `invoiceAttachments[${i}].sparkInvoice`,
+          index: i
+        });
+      }
+      sortedInvoices.push({ id: idBytes, raw: invoice });
+    }
+  }
+  sortedInvoices.sort((a, b) => {
+    for (let j = 0; j < a.id.length && j < b.id.length; j++) {
+      const av = a.id[j];
+      const bv = b.id[j];
+      if (av !== bv) return av - bv;
+    }
+    return a.id.length - b.id.length;
+  });
+  const encoder = new TextEncoder();
+  for (const k of sortedInvoices) {
+    const h = sha2568.create();
+    h.update(encoder.encode(k.raw));
+    allHashes.push(h.digest());
+  }
   const finalHashObj = sha2568.create();
   const concatenatedHashes = new Uint8Array(
     allHashes.reduce((sum, hash) => sum + hash.length, 0)
@@ -5469,798 +5590,64 @@ function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
   finalHashObj.update(concatenatedHashes);
   return finalHashObj.digest();
 }
-function hashTokenTransactionV2(tokenTransaction, partialHash = false) {
-  if (!tokenTransaction) {
-    throw new ValidationError("token transaction cannot be nil", {
-      field: "tokenTransaction"
-    });
-  }
-  let allHashes = [];
-  const versionHashObj = sha2568.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());
-  const typeHashObj = sha2568.create();
-  const typeBytes = new Uint8Array(4);
-  let transactionType = 0;
-  if (tokenTransaction.tokenInputs?.$case === "mintInput") {
-    transactionType = 2 /* TOKEN_TRANSACTION_TYPE_MINT */;
-  } else if (tokenTransaction.tokenInputs?.$case === "transferInput") {
-    transactionType = 3 /* TOKEN_TRANSACTION_TYPE_TRANSFER */;
-  } else if (tokenTransaction.tokenInputs?.$case === "createInput") {
-    transactionType = 1 /* TOKEN_TRANSACTION_TYPE_CREATE */;
-  } else {
-    throw new ValidationError(
-      "token transaction must have exactly one input type",
-      {
-        field: "tokenInputs"
-      }
-    );
-  }
-  new DataView(typeBytes.buffer).setUint32(0, transactionType, false);
-  typeHashObj.update(typeBytes);
-  allHashes.push(typeHashObj.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"
-      });
-    }
-    const outputsLenHashObj2 = sha2568.create();
-    const outputsLenBytes2 = new Uint8Array(4);
-    new DataView(outputsLenBytes2.buffer).setUint32(
-      0,
-      tokenTransaction.tokenInputs.transferInput.outputsToSpend.length,
-      false
-    );
-    outputsLenHashObj2.update(outputsLenBytes2);
-    allHashes.push(outputsLenHashObj2.digest());
-    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 = sha2568.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());
-    }
-  } else if (tokenTransaction.tokenInputs?.$case === "mintInput") {
-    const hashObj2 = sha2568.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);
-      allHashes.push(hashObj2.digest());
-      const tokenIdentifierHashObj = sha2568.create();
-      if (tokenTransaction.tokenInputs.mintInput.tokenIdentifier) {
-        tokenIdentifierHashObj.update(
-          tokenTransaction.tokenInputs.mintInput.tokenIdentifier
-        );
-      } else {
-        tokenIdentifierHashObj.update(new Uint8Array(32));
-      }
-      allHashes.push(tokenIdentifierHashObj.digest());
-    }
-  } else if (tokenTransaction.tokenInputs?.$case === "createInput") {
-    const createInput = tokenTransaction.tokenInputs.createInput;
-    const issuerPubKeyHashObj = sha2568.create();
-    if (!createInput.issuerPublicKey || createInput.issuerPublicKey.length === 0) {
-      throw new ValidationError("issuer public key cannot be nil or empty", {
-        field: "tokenInputs.createInput.issuerPublicKey"
-      });
-    }
-    issuerPubKeyHashObj.update(createInput.issuerPublicKey);
-    allHashes.push(issuerPubKeyHashObj.digest());
-    const tokenNameHashObj = sha2568.create();
-    if (!createInput.tokenName || createInput.tokenName.length === 0) {
-      throw new ValidationError("token name cannot be empty", {
-        field: "tokenInputs.createInput.tokenName"
-      });
-    }
-    if (createInput.tokenName.length > 20) {
-      throw new ValidationError("token name cannot be longer than 20 bytes", {
-        field: "tokenInputs.createInput.tokenName",
-        value: createInput.tokenName,
-        expectedLength: 20,
-        actualLength: createInput.tokenName.length
-      });
-    }
-    const tokenNameEncoder = new TextEncoder();
-    tokenNameHashObj.update(tokenNameEncoder.encode(createInput.tokenName));
-    allHashes.push(tokenNameHashObj.digest());
-    const tokenTickerHashObj = sha2568.create();
-    if (!createInput.tokenTicker || createInput.tokenTicker.length === 0) {
-      throw new ValidationError("token ticker cannot be empty", {
-        field: "tokenInputs.createInput.tokenTicker"
-      });
-    }
-    if (createInput.tokenTicker.length > 6) {
-      throw new ValidationError("token ticker cannot be longer than 6 bytes", {
-        field: "tokenInputs.createInput.tokenTicker",
-        value: createInput.tokenTicker,
-        expectedLength: 6,
-        actualLength: createInput.tokenTicker.length
-      });
-    }
-    const tokenTickerEncoder = new TextEncoder();
-    tokenTickerHashObj.update(
-      tokenTickerEncoder.encode(createInput.tokenTicker)
-    );
-    allHashes.push(tokenTickerHashObj.digest());
-    const decimalsHashObj = sha2568.create();
-    const decimalsBytes = new Uint8Array(4);
-    new DataView(decimalsBytes.buffer).setUint32(
-      0,
-      createInput.decimals,
-      false
-    );
-    decimalsHashObj.update(decimalsBytes);
-    allHashes.push(decimalsHashObj.digest());
-    const maxSupplyHashObj = sha2568.create();
-    if (!createInput.maxSupply) {
-      throw new ValidationError("max supply cannot be nil", {
-        field: "tokenInputs.createInput.maxSupply"
-      });
-    }
-    if (createInput.maxSupply.length !== 16) {
-      throw new ValidationError("max supply must be exactly 16 bytes", {
-        field: "tokenInputs.createInput.maxSupply",
-        value: createInput.maxSupply,
-        expectedLength: 16,
-        actualLength: createInput.maxSupply.length
-      });
-    }
-    maxSupplyHashObj.update(createInput.maxSupply);
-    allHashes.push(maxSupplyHashObj.digest());
-    const isFreezableHashObj = sha2568.create();
-    isFreezableHashObj.update(
-      new Uint8Array([createInput.isFreezable ? 1 : 0])
-    );
-    allHashes.push(isFreezableHashObj.digest());
-    const creationEntityHashObj = sha2568.create();
-    if (!partialHash && createInput.creationEntityPublicKey) {
-      creationEntityHashObj.update(createInput.creationEntityPublicKey);
-    }
-    allHashes.push(creationEntityHashObj.digest());
-  }
-  if (!tokenTransaction.tokenOutputs) {
-    throw new ValidationError("token outputs cannot be null", {
-      field: "tokenOutputs"
-    });
-  }
-  const outputsLenHashObj = sha2568.create();
-  const outputsLenBytes = new Uint8Array(4);
-  new DataView(outputsLenBytes.buffer).setUint32(
-    0,
-    tokenTransaction.tokenOutputs.length,
-    false
-  );
-  outputsLenHashObj.update(outputsLenBytes);
-  allHashes.push(outputsLenHashObj.digest());
-  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 = sha2568.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 || output.tokenPublicKey.length === 0) {
-      hashObj2.update(new Uint8Array(33));
-    } else {
-      hashObj2.update(output.tokenPublicKey);
-    }
-    if (!output.tokenIdentifier || output.tokenIdentifier.length === 0) {
-      hashObj2.update(new Uint8Array(32));
-    } else {
-      hashObj2.update(output.tokenIdentifier);
-    }
-    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;
-  });
-  const operatorLenHashObj = sha2568.create();
-  const operatorLenBytes = new Uint8Array(4);
-  new DataView(operatorLenBytes.buffer).setUint32(
-    0,
-    sortedPubKeys.length,
-    false
-  );
-  operatorLenHashObj.update(operatorLenBytes);
-  allHashes.push(operatorLenHashObj.digest());
-  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 = sha2568.create();
-    hashObj2.update(pubKey);
-    allHashes.push(hashObj2.digest());
-  }
-  const hashObj = sha2568.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 clientTimestampHashObj = sha2568.create();
-  const clientCreatedTs = tokenTransaction.clientCreatedTimestamp;
-  if (!clientCreatedTs) {
-    throw new ValidationError(
-      "client created timestamp cannot be null for V1 token transactions",
-      {
-        field: "clientCreatedTimestamp"
-      }
-    );
-  }
-  const clientUnixTime = clientCreatedTs.getTime();
-  const clientTimestampBytes = new Uint8Array(8);
-  new DataView(clientTimestampBytes.buffer).setBigUint64(
-    0,
-    BigInt(clientUnixTime),
-    false
-  );
-  clientTimestampHashObj.update(clientTimestampBytes);
-  allHashes.push(clientTimestampHashObj.digest());
-  if (!partialHash) {
-    const expiryHashObj = sha2568.create();
-    const expiryTimeBytes = new Uint8Array(8);
-    const expiryUnixTime = tokenTransaction.expiryTime ? Math.floor(tokenTransaction.expiryTime.getTime() / 1e3) : 0;
-    new DataView(expiryTimeBytes.buffer).setBigUint64(
-      0,
-      BigInt(expiryUnixTime),
-      false
-      // false for big-endian
-    );
-    expiryHashObj.update(expiryTimeBytes);
-    allHashes.push(expiryHashObj.digest());
-  }
-  const attachments = tokenTransaction.invoiceAttachments;
-  const lenHash = sha2568.create();
-  const lenBytes = new Uint8Array(4);
-  new DataView(lenBytes.buffer).setUint32(
-    0,
-    attachments ? attachments.length : 0,
-    false
-  );
-  lenHash.update(lenBytes);
-  allHashes.push(lenHash.digest());
-  const sortedInvoices = [];
-  if (attachments) {
-    for (let i = 0; i < attachments.length; i++) {
-      const attachment = attachments[i];
-      if (!attachment) {
-        throw new ValidationError(
-          `invoice attachment at index ${i} cannot be null`,
-          {
-            field: `invoiceAttachments[${i}]`,
-            index: i
-          }
-        );
-      }
-      const invoice = attachment.sparkInvoice;
-      let idBytes;
-      try {
-        const decoded = bech32m3.decode(invoice, 500);
-        const payload = SparkAddress.decode(bech32m3.fromWords(decoded.words));
-        if (!payload.sparkInvoiceFields || !payload.sparkInvoiceFields.id) {
-          throw new Error("missing spark invoice fields or id");
-        }
-        idBytes = payload.sparkInvoiceFields.id;
-      } catch (err) {
-        throw new ValidationError(
-          `invalid invoice at ${i}`,
-          {
-            field: `invoiceAttachments[${i}].sparkInvoice`,
-            index: i,
-            value: invoice
-          },
-          err
-        );
-      }
-      if (!idBytes || idBytes.length !== 16) {
-        throw new ValidationError(`invalid invoice id at ${i}`, {
-          field: `invoiceAttachments[${i}].sparkInvoice`,
-          index: i
-        });
-      }
-      sortedInvoices.push({ id: idBytes, raw: invoice });
-    }
-  }
-  sortedInvoices.sort((a, b) => {
-    for (let j = 0; j < a.id.length && j < b.id.length; j++) {
-      const av = a.id[j];
-      const bv = b.id[j];
-      if (av !== bv) return av - bv;
-    }
-    return a.id.length - b.id.length;
-  });
-  const encoder = new TextEncoder();
-  for (const k of sortedInvoices) {
-    const h = sha2568.create();
-    h.update(encoder.encode(k.raw));
-    allHashes.push(h.digest());
-  }
-  const finalHashObj = sha2568.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(
-      "operator specific token transaction signable payload cannot be null",
-      {
-        field: "payload"
-      }
-    );
-  }
-  let allHashes = [];
-  if (payload.finalTokenTransactionHash) {
-    const hashObj2 = sha2568.create();
-    if (payload.finalTokenTransactionHash.length !== 32) {
-      throw new ValidationError(`invalid final token transaction hash length`, {
-        field: "finalTokenTransactionHash",
-        value: payload.finalTokenTransactionHash,
-        expectedLength: 32,
-        actualLength: payload.finalTokenTransactionHash.length
-      });
-    }
-    hashObj2.update(payload.finalTokenTransactionHash);
-    allHashes.push(hashObj2.digest());
-  }
-  if (!payload.operatorIdentityPublicKey) {
-    throw new ValidationError("operator identity public key cannot be null", {
-      field: "operatorIdentityPublicKey"
-    });
-  }
-  if (payload.operatorIdentityPublicKey.length === 0) {
-    throw new ValidationError("operator identity public key cannot be empty", {
-      field: "operatorIdentityPublicKey"
-    });
-  }
-  const hashObj = sha2568.create();
-  hashObj.update(payload.operatorIdentityPublicKey);
-  allHashes.push(hashObj.digest());
-  const finalHashObj = sha2568.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();
-}
-
-// src/utils/token-keyshares.ts
-import { secp256k1 as secp256k18 } from "@noble/curves/secp256k1";
-function recoverRevocationSecretFromKeyshares(keyshares, threshold) {
-  const shares = keyshares.map((keyshare) => ({
-    fieldModulus: BigInt("0x" + secp256k18.CURVE.n.toString(16)),
-    // secp256k1 curve order
-    threshold,
-    index: BigInt(keyshare.operatorIndex),
-    share: BigInt(
-      "0x" + Buffer.from(keyshare.keyshare.keyshare).toString("hex")
-    ),
-    proofs: []
-  }));
-  const recoveredSecret = recoverSecret(shares);
-  return bigIntToPrivateKey(recoveredSecret);
-}
-
-// src/utils/token-transaction-validation.ts
-function areByteArraysEqual(a, b) {
-  if (a.length !== b.length) {
-    return false;
-  }
-  return a.every((byte, index) => byte === b[index]);
-}
-function hasDuplicates(array) {
-  return new Set(array).size !== array.length;
-}
-function validateTokenTransactionV0(finalTokenTransaction, partialTokenTransaction, signingOperators, keyshareInfo, expectedWithdrawBondSats, expectedWithdrawRelativeBlockLocktime, expectedThreshold) {
-  if (finalTokenTransaction.network !== partialTokenTransaction.network) {
-    throw new InternalValidationError(
-      "Network mismatch in response token transaction",
-      {
-        value: finalTokenTransaction.network,
-        expected: partialTokenTransaction.network
-      }
-    );
-  }
-  if (!finalTokenTransaction.tokenInputs) {
-    throw new InternalValidationError(
-      "Token inputs missing in final transaction",
-      {
-        value: finalTokenTransaction
-      }
-    );
-  }
-  if (!partialTokenTransaction.tokenInputs) {
-    throw new InternalValidationError(
-      "Token inputs missing in partial transaction",
-      {
-        value: partialTokenTransaction
-      }
-    );
-  }
-  if (finalTokenTransaction.tokenInputs.$case !== partialTokenTransaction.tokenInputs.$case) {
-    throw new InternalValidationError(
-      `Transaction type mismatch: final transaction has ${finalTokenTransaction.tokenInputs.$case}, partial transaction has ${partialTokenTransaction.tokenInputs.$case}`,
-      {
-        value: finalTokenTransaction.tokenInputs.$case,
-        expected: partialTokenTransaction.tokenInputs.$case
-      }
-    );
-  }
-  if (finalTokenTransaction.sparkOperatorIdentityPublicKeys.length !== partialTokenTransaction.sparkOperatorIdentityPublicKeys.length) {
-    throw new InternalValidationError(
-      "Spark operator identity public keys count mismatch",
-      {
-        value: finalTokenTransaction.sparkOperatorIdentityPublicKeys.length,
-        expected: partialTokenTransaction.sparkOperatorIdentityPublicKeys.length
-      }
-    );
-  }
-  if (partialTokenTransaction.tokenInputs.$case === "mintInput" && finalTokenTransaction.tokenInputs.$case === "mintInput") {
-    const finalMintInput = finalTokenTransaction.tokenInputs.mintInput;
-    const partialMintInput = partialTokenTransaction.tokenInputs.mintInput;
-    if (!areByteArraysEqual(
-      finalMintInput.issuerPublicKey,
-      partialMintInput.issuerPublicKey
-    )) {
-      throw new InternalValidationError(
-        "Issuer public key mismatch in mint input",
-        {
-          value: finalMintInput.issuerPublicKey.toString(),
-          expected: partialMintInput.issuerPublicKey.toString()
-        }
-      );
-    }
-  } else if (partialTokenTransaction.tokenInputs.$case === "transferInput" && finalTokenTransaction.tokenInputs.$case === "transferInput") {
-    const finalTransferInput = finalTokenTransaction.tokenInputs.transferInput;
-    const partialTransferInput = partialTokenTransaction.tokenInputs.transferInput;
-    if (finalTransferInput.outputsToSpend.length !== partialTransferInput.outputsToSpend.length) {
-      throw new InternalValidationError(
-        "Outputs to spend count mismatch in transfer input",
-        {
-          value: finalTransferInput.outputsToSpend.length,
-          expected: partialTransferInput.outputsToSpend.length
-        }
-      );
-    }
-    for (let i = 0; i < finalTransferInput.outputsToSpend.length; i++) {
-      const finalOutput = finalTransferInput.outputsToSpend[i];
-      const partialOutput = partialTransferInput.outputsToSpend[i];
-      if (!finalOutput) {
-        throw new InternalValidationError(
-          "Token output to spend missing in final transaction",
-          {
-            outputIndex: i,
-            value: finalOutput
-          }
-        );
-      }
-      if (!partialOutput) {
-        throw new InternalValidationError(
-          "Token output to spend missing in partial transaction",
-          {
-            outputIndex: i,
-            value: partialOutput
-          }
-        );
-      }
-      if (!areByteArraysEqual(
-        finalOutput.prevTokenTransactionHash,
-        partialOutput.prevTokenTransactionHash
-      )) {
-        throw new InternalValidationError(
-          "Previous token transaction hash mismatch in transfer input",
-          {
-            outputIndex: i,
-            value: finalOutput.prevTokenTransactionHash.toString(),
-            expected: partialOutput.prevTokenTransactionHash.toString()
-          }
-        );
-      }
-      if (finalOutput.prevTokenTransactionVout !== partialOutput.prevTokenTransactionVout) {
-        throw new InternalValidationError(
-          "Previous token transaction vout mismatch in transfer input",
-          {
-            outputIndex: i,
-            value: finalOutput.prevTokenTransactionVout,
-            expected: partialOutput.prevTokenTransactionVout
-          }
-        );
-      }
-    }
-  }
-  if (finalTokenTransaction.tokenOutputs.length !== partialTokenTransaction.tokenOutputs.length) {
-    throw new InternalValidationError("Token outputs count mismatch", {
-      value: finalTokenTransaction.tokenOutputs.length,
-      expected: partialTokenTransaction.tokenOutputs.length
-    });
-  }
-  for (let i = 0; i < finalTokenTransaction.tokenOutputs.length; i++) {
-    const finalOutput = finalTokenTransaction.tokenOutputs[i];
-    const partialOutput = partialTokenTransaction.tokenOutputs[i];
-    if (!finalOutput) {
-      throw new InternalValidationError(
-        "Token output missing in final transaction",
-        {
-          outputIndex: i,
-          value: finalOutput
-        }
-      );
-    }
-    if (!partialOutput) {
-      throw new InternalValidationError(
-        "Token output missing in partial transaction",
-        {
-          outputIndex: i,
-          value: partialOutput
-        }
-      );
-    }
-    if (!areByteArraysEqual(
-      finalOutput.ownerPublicKey,
-      partialOutput.ownerPublicKey
-    )) {
-      throw new InternalValidationError(
-        "Owner public key mismatch in token output",
-        {
-          outputIndex: i,
-          value: finalOutput.ownerPublicKey.toString(),
-          expected: partialOutput.ownerPublicKey.toString()
-        }
-      );
-    }
-    if (finalOutput.tokenPublicKey !== void 0 && partialOutput.tokenPublicKey !== void 0 && !areByteArraysEqual(
-      finalOutput.tokenPublicKey,
-      partialOutput.tokenPublicKey
-    )) {
-      throw new InternalValidationError(
-        "Token public key mismatch in token output",
-        {
-          outputIndex: i,
-          value: finalOutput.tokenPublicKey?.toString(),
-          expected: partialOutput.tokenPublicKey?.toString()
-        }
-      );
-    }
-    if (!areByteArraysEqual(finalOutput.tokenAmount, partialOutput.tokenAmount)) {
-      throw new InternalValidationError(
-        "Token amount mismatch in token output",
-        {
-          outputIndex: i,
-          value: finalOutput.tokenAmount.toString(),
-          expected: partialOutput.tokenAmount.toString()
-        }
-      );
-    }
-    if (finalOutput.withdrawBondSats !== void 0) {
-      if (finalOutput.withdrawBondSats !== expectedWithdrawBondSats) {
-        throw new InternalValidationError(
-          "Withdraw bond sats mismatch in token output",
-          {
-            outputIndex: i,
-            value: finalOutput.withdrawBondSats,
-            expected: expectedWithdrawBondSats
-          }
-        );
-      }
-    }
-    if (finalOutput.withdrawRelativeBlockLocktime !== void 0) {
-      if (finalOutput.withdrawRelativeBlockLocktime !== expectedWithdrawRelativeBlockLocktime) {
-        throw new InternalValidationError(
-          "Withdraw relative block locktime mismatch in token output",
-          {
-            outputIndex: i,
-            value: finalOutput.withdrawRelativeBlockLocktime,
-            expected: expectedWithdrawRelativeBlockLocktime
-          }
-        );
-      }
-    }
-    if (keyshareInfo.threshold !== expectedThreshold) {
-      throw new InternalValidationError(
-        "Threshold mismatch: expected " + expectedThreshold + " but got " + keyshareInfo.threshold,
-        {
-          field: "threshold",
-          value: keyshareInfo.threshold,
-          expected: expectedThreshold
-        }
-      );
-    }
-  }
-  if (keyshareInfo.ownerIdentifiers.length !== Object.keys(signingOperators).length) {
-    throw new InternalValidationError(
-      `Keyshare operator count (${keyshareInfo.ownerIdentifiers.length}) does not match signing operator count (${Object.keys(signingOperators).length})`,
-      {
-        keyshareInfo: keyshareInfo.ownerIdentifiers.length,
-        signingOperators: Object.keys(signingOperators).length
-      }
-    );
-  }
-  if (hasDuplicates(keyshareInfo.ownerIdentifiers)) {
-    throw new InternalValidationError(
-      "Duplicate ownerIdentifiers found in keyshareInfo",
+function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
+  if (!payload) {
+    throw new ValidationError(
+      "operator specific token transaction signable payload cannot be null",
       {
-        keyshareInfo: keyshareInfo.ownerIdentifiers
+        field: "payload"
       }
     );
   }
-  for (const identifier of keyshareInfo.ownerIdentifiers) {
-    if (!signingOperators[identifier]) {
-      throw new InternalValidationError(
-        `Keyshare operator ${identifier} not found in signing operator list`,
-        {
-          keyshareInfo: identifier,
-          signingOperators: Object.keys(signingOperators)
-        }
-      );
+  let allHashes = [];
+  if (payload.finalTokenTransactionHash) {
+    const hashObj2 = sha2568.create();
+    if (payload.finalTokenTransactionHash.length !== 32) {
+      throw new ValidationError(`invalid final token transaction hash length`, {
+        field: "finalTokenTransactionHash",
+        value: payload.finalTokenTransactionHash,
+        expectedLength: 32,
+        actualLength: payload.finalTokenTransactionHash.length
+      });
     }
+    hashObj2.update(payload.finalTokenTransactionHash);
+    allHashes.push(hashObj2.digest());
+  }
+  if (!payload.operatorIdentityPublicKey) {
+    throw new ValidationError("operator identity public key cannot be null", {
+      field: "operatorIdentityPublicKey"
+    });
+  }
+  if (payload.operatorIdentityPublicKey.length === 0) {
+    throw new ValidationError("operator identity public key cannot be empty", {
+      field: "operatorIdentityPublicKey"
+    });
+  }
+  const hashObj = sha2568.create();
+  hashObj.update(payload.operatorIdentityPublicKey);
+  allHashes.push(hashObj.digest());
+  const finalHashObj = sha2568.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();
+}
+
+// src/utils/token-transaction-validation.ts
+function areByteArraysEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
   }
+  return a.every((byte, index) => byte === b[index]);
+}
+function hasDuplicates(array) {
+  return new Set(array).size !== array.length;
 }
 function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction, signingOperators, keyshareInfo, expectedWithdrawBondSats, expectedWithdrawRelativeBlockLocktime, expectedThreshold) {
   if (finalTokenTransaction.network !== partialTokenTransaction.network) {
@@ -6614,16 +6001,6 @@ var TokenTransactionService = class {
       tokenIdentifier,
       this.config.getNetworkType()
     ).tokenIdentifier;
-    let tokenPublicKey;
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      const tokenClient = await this.connectionManager.createSparkTokenClient(
-        this.config.getCoordinatorAddress()
-      );
-      const tokenMetadata = await tokenClient.query_token_metadata({
-        tokenIdentifiers: [rawTokenIdentifier]
-      });
-      tokenPublicKey = tokenMetadata.tokenMetadata[0].issuerPublicKey;
-    }
     let sparkInvoices = [];
     const tokenOutputData = receiverOutputs.map((transfer) => {
       const receiverAddress = decodeSparkAddress(
@@ -6633,7 +6010,7 @@ var TokenTransactionService = class {
       if (receiverAddress.sparkInvoiceFields) {
         sparkInvoices.push(transfer.receiverSparkAddress);
       }
-      if (this.config.getTokenTransactionVersion() !== "V0" && receiverAddress.sparkInvoiceFields) {
+      if (receiverAddress.sparkInvoiceFields) {
         return {
           receiverPublicKey: hexToBytes6(receiverAddress.identityPublicKey),
           rawTokenIdentifier,
@@ -6644,24 +6021,14 @@ var TokenTransactionService = class {
       return {
         receiverPublicKey: hexToBytes6(receiverAddress.identityPublicKey),
         rawTokenIdentifier,
-        tokenPublicKey,
-        // Remove for full v0 deprecation
         tokenAmount: transfer.tokenAmount
       };
     });
-    let tokenTransaction;
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      tokenTransaction = await this.constructTransferTokenTransactionV0(
-        outputsToUse,
-        tokenOutputData
-      );
-    } else {
-      tokenTransaction = await this.constructTransferTokenTransaction(
-        outputsToUse,
-        tokenOutputData,
-        sparkInvoices
-      );
-    }
+    const tokenTransaction = await this.constructTransferTokenTransaction(
+      outputsToUse,
+      tokenOutputData,
+      sparkInvoices
+    );
     const txId = await this.broadcastTokenTransaction(
       tokenTransaction,
       outputsToUse.map((output) => output.output.ownerPublicKey),
@@ -6669,44 +6036,6 @@ var TokenTransactionService = class {
     );
     return txId;
   }
-  async constructTransferTokenTransactionV0(selectedOutputs, tokenOutputData) {
-    selectedOutputs.sort(
-      (a, b) => a.previousTransactionVout - b.previousTransactionVout
-    );
-    const availableTokenAmount = sumAvailableTokens(selectedOutputs);
-    const totalRequestedAmount = tokenOutputData.reduce(
-      (sum, output) => sum + output.tokenAmount,
-      0n
-    );
-    const tokenOutputs = tokenOutputData.map((output) => ({
-      ownerPublicKey: output.receiverPublicKey,
-      tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: numberToBytesBE2(output.tokenAmount, 16)
-    }));
-    if (availableTokenAmount > totalRequestedAmount) {
-      const changeAmount = availableTokenAmount - totalRequestedAmount;
-      const firstTokenPublicKey = tokenOutputData[0].tokenPublicKey;
-      tokenOutputs.push({
-        ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
-        tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: numberToBytesBE2(changeAmount, 16)
-      });
-    }
-    return {
-      network: this.config.getNetworkProto(),
-      tokenInputs: {
-        $case: "transferInput",
-        transferInput: {
-          outputsToSpend: selectedOutputs.map((output) => ({
-            prevTokenTransactionHash: output.previousTransactionHash,
-            prevTokenTransactionVout: output.previousTransactionVout
-          }))
-        }
-      },
-      tokenOutputs,
-      sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys()
-    };
-  }
   async constructTransferTokenTransaction(selectedOutputs, tokenOutputData, sparkInvoices) {
     selectedOutputs.sort(
       (a, b) => a.previousTransactionVout - b.previousTransactionVout
@@ -6753,229 +6082,27 @@ var TokenTransactionService = class {
   }
   collectOperatorIdentityPublicKeys() {
     const operatorKeys = [];
-    for (const [_, operator] of Object.entries(
-      this.config.getSigningOperators()
-    )) {
-      operatorKeys.push(hexToBytes6(operator.identityPublicKey));
-    }
-    return operatorKeys;
-  }
-  async broadcastTokenTransaction(tokenTransaction, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
-    const signingOperators = this.config.getSigningOperators();
-    if (!isTokenTransaction(tokenTransaction)) {
-      return this.broadcastTokenTransactionV0(
-        tokenTransaction,
-        signingOperators,
-        outputsToSpendSigningPublicKeys,
-        outputsToSpendCommitments
-      );
-    } else {
-      return this.broadcastTokenTransactionV1(
-        tokenTransaction,
-        signingOperators,
-        outputsToSpendSigningPublicKeys,
-        outputsToSpendCommitments
-      );
-    }
-  }
-  async broadcastTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
-    const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransactionV0(
-      tokenTransaction,
-      signingOperators,
-      outputsToSpendSigningPublicKeys,
-      outputsToSpendCommitments
-    );
-    const { successfulSignatures } = await this.signTokenTransactionV0(
-      finalTokenTransaction,
-      finalTokenTransactionHash,
-      signingOperators
-    );
-    if (finalTokenTransaction.tokenInputs.$case === "transferInput") {
-      const outputsToSpend = finalTokenTransaction.tokenInputs.transferInput.outputsToSpend;
-      const errors = [];
-      const revocationSecrets = [];
-      for (let outputIndex = 0; outputIndex < outputsToSpend.length; outputIndex++) {
-        const outputKeyshares = successfulSignatures.map(({ identifier, response }) => ({
-          operatorIndex: parseInt(identifier, 16),
-          keyshare: response.revocationKeyshares[outputIndex]
-        }));
-        if (outputKeyshares.length < threshold) {
-          errors.push(
-            new ValidationError("Insufficient keyshares", {
-              field: "outputKeyshares",
-              value: outputKeyshares.length,
-              expected: threshold,
-              index: outputIndex
-            })
-          );
-        }
-        const seenIndices = /* @__PURE__ */ new Set();
-        for (const { operatorIndex } of outputKeyshares) {
-          if (seenIndices.has(operatorIndex)) {
-            errors.push(
-              new ValidationError("Duplicate operator index", {
-                field: "outputKeyshares",
-                value: operatorIndex,
-                expected: "Unique operator index",
-                index: outputIndex
-              })
-            );
-          }
-          seenIndices.add(operatorIndex);
-        }
-        const revocationSecret = recoverRevocationSecretFromKeyshares(
-          outputKeyshares,
-          threshold
-        );
-        const derivedRevocationCommitment = secp256k19.getPublicKey(
-          revocationSecret,
-          true
-        );
-        if (!outputsToSpendCommitments || !outputsToSpendCommitments[outputIndex] || !derivedRevocationCommitment.every(
-          (byte, i) => byte === outputsToSpendCommitments[outputIndex][i]
-        )) {
-          errors.push(
-            new InternalValidationError(
-              "Revocation commitment verification failed",
-              {
-                field: "revocationCommitment",
-                value: derivedRevocationCommitment,
-                expected: bytesToHex6(outputsToSpendCommitments[outputIndex]),
-                outputIndex
-              }
-            )
-          );
-        }
-        revocationSecrets.push({
-          inputIndex: outputIndex,
-          revocationSecret
-        });
-      }
-      if (errors.length > 0) {
-        throw new ValidationError(
-          "Multiple validation errors occurred across outputs",
-          {
-            field: "outputValidation",
-            value: errors
-          }
-        );
-      }
-      await this.finalizeTokenTransaction(
-        finalTokenTransaction,
-        revocationSecrets,
-        threshold
-      );
-    }
-    return bytesToHex6(finalTokenTransactionHash);
-  }
-  async broadcastTokenTransactionV1(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
-    const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
-      tokenTransaction,
-      signingOperators,
-      outputsToSpendSigningPublicKeys,
-      outputsToSpendCommitments
-    );
-    await this.signTokenTransaction(
-      finalTokenTransaction,
-      finalTokenTransactionHash,
-      signingOperators
-    );
-    return bytesToHex6(finalTokenTransactionHash);
-  }
-  async startTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    const partialTokenTransactionHash = hashTokenTransactionV0(
-      tokenTransaction,
-      true
-    );
-    const ownerSignaturesWithIndex = [];
-    if (tokenTransaction.tokenInputs.$case === "mintInput") {
-      const issuerPublicKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-      if (!issuerPublicKey) {
-        throw new ValidationError("Invalid mint input", {
-          field: "issuerPublicKey",
-          value: null,
-          expected: "Non-null issuer public key"
-        });
-      }
-      const ownerSignature = await this.signMessageWithKey(
-        partialTokenTransactionHash,
-        issuerPublicKey
-      );
-      ownerSignaturesWithIndex.push({
-        signature: ownerSignature,
-        inputIndex: 0
-      });
-    } else if (tokenTransaction.tokenInputs.$case === "transferInput") {
-      if (!outputsToSpendSigningPublicKeys || !outputsToSpendCommitments) {
-        throw new ValidationError("Invalid transfer input", {
-          field: "outputsToSpend",
-          value: {
-            signingPublicKeys: outputsToSpendSigningPublicKeys,
-            revocationPublicKeys: outputsToSpendCommitments
-          },
-          expected: "Non-null signing and revocation public keys"
-        });
-      }
-      for (const [i, key] of outputsToSpendSigningPublicKeys.entries()) {
-        if (!key) {
-          throw new ValidationError("Invalid signing key", {
-            field: "outputsToSpendSigningPublicKeys",
-            value: i,
-            expected: "Non-null signing key"
-          });
-        }
-        const ownerSignature = await this.signMessageWithKey(
-          partialTokenTransactionHash,
-          key
-        );
-        ownerSignaturesWithIndex.push({
-          signature: ownerSignature,
-          inputIndex: i
-        });
-      }
-    }
-    const startResponse = await sparkClient.start_token_transaction(
-      {
-        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        partialTokenTransaction: tokenTransaction,
-        tokenTransactionSignatures: {
-          ownerSignatures: ownerSignaturesWithIndex
-        }
-      },
-      {
-        retry: true,
-        retryableStatuses: ["UNKNOWN", "UNAVAILABLE", "CANCELLED", "INTERNAL"],
-        retryMaxAttempts: 3
-      }
-    );
-    if (!startResponse.finalTokenTransaction) {
-      throw new Error("Final token transaction missing in start response");
-    }
-    if (!startResponse.keyshareInfo) {
-      throw new Error("Keyshare info missing in start response");
+    for (const [_, operator] of Object.entries(
+      this.config.getSigningOperators()
+    )) {
+      operatorKeys.push(hexToBytes6(operator.identityPublicKey));
     }
-    validateTokenTransactionV0(
-      startResponse.finalTokenTransaction,
+    return operatorKeys;
+  }
+  async broadcastTokenTransaction(tokenTransaction, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
+    const signingOperators = this.config.getSigningOperators();
+    const { finalTokenTransaction, finalTokenTransactionHash, threshold } = await this.startTokenTransaction(
       tokenTransaction,
       signingOperators,
-      startResponse.keyshareInfo,
-      this.config.getExpectedWithdrawBondSats(),
-      this.config.getExpectedWithdrawRelativeBlockLocktime(),
-      this.config.getThreshold()
-    );
-    const finalTokenTransaction = startResponse.finalTokenTransaction;
-    const finalTokenTransactionHash = hashTokenTransactionV0(
-      finalTokenTransaction,
-      false
+      outputsToSpendSigningPublicKeys,
+      outputsToSpendCommitments
     );
-    return {
+    await this.signTokenTransaction(
       finalTokenTransaction,
       finalTokenTransactionHash,
-      threshold: startResponse.keyshareInfo.threshold
-    };
+      signingOperators
+    );
+    return bytesToHex6(finalTokenTransactionHash);
   }
   async startTokenTransaction(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
     const sparkClient = await this.connectionManager.createSparkTokenClient(
@@ -7096,103 +6223,6 @@ var TokenTransactionService = class {
       threshold: startResponse.keyshareInfo.threshold
     };
   }
-  async signTokenTransactionV0(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
-    const soSignatures = await Promise.allSettled(
-      Object.entries(signingOperators).map(
-        async ([identifier, operator], index) => {
-          const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
-          const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-          const payload = {
-            finalTokenTransactionHash,
-            operatorIdentityPublicKey: hexToBytes6(operator.identityPublicKey)
-          };
-          const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
-          let operatorSpecificSignatures = [];
-          if (finalTokenTransaction.tokenInputs.$case === "mintInput") {
-            const issuerPublicKey = finalTokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-            if (!issuerPublicKey) {
-              throw new ValidationError("Invalid mint input", {
-                field: "issuerPublicKey",
-                value: null,
-                expected: "Non-null issuer public key"
-              });
-            }
-            const ownerSignature = await this.signMessageWithKey(
-              payloadHash,
-              issuerPublicKey
-            );
-            operatorSpecificSignatures.push({
-              ownerSignature: {
-                signature: ownerSignature,
-                inputIndex: 0
-              },
-              payload
-            });
-          }
-          if (finalTokenTransaction.tokenInputs.$case === "transferInput") {
-            const transferInput = finalTokenTransaction.tokenInputs.transferInput;
-            for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
-              let ownerSignature;
-              if (this.config.getTokenSignatures() === "SCHNORR") {
-                ownerSignature = await this.config.signer.signSchnorrWithIdentityKey(
-                  payloadHash
-                );
-              } else {
-                ownerSignature = await this.config.signer.signMessageWithIdentityKey(
-                  payloadHash
-                );
-              }
-              operatorSpecificSignatures.push({
-                ownerSignature: {
-                  signature: ownerSignature,
-                  inputIndex: i
-                },
-                payload
-              });
-            }
-          }
-          try {
-            const response = await internalSparkClient.sign_token_transaction(
-              {
-                finalTokenTransaction,
-                operatorSpecificSignatures,
-                identityPublicKey
-              },
-              {
-                retry: true,
-                retryableStatuses: [
-                  "UNKNOWN",
-                  "UNAVAILABLE",
-                  "CANCELLED",
-                  "INTERNAL"
-                ],
-                retryMaxAttempts: 3
-              }
-            );
-            return {
-              index,
-              identifier,
-              response
-            };
-          } catch (error) {
-            throw new NetworkError(
-              "Failed to sign token transaction",
-              {
-                operation: "sign_token_transaction",
-                errorCount: 1,
-                errors: error instanceof Error ? error.message : String(error)
-              },
-              error
-            );
-          }
-        }
-      )
-    );
-    const successfulSignatures = collectResponses(soSignatures);
-    return {
-      successfulSignatures
-    };
-  }
   async signTokenTransaction(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
     const coordinatorClient = await this.connectionManager.createSparkTokenClient(
       this.config.getCoordinatorAddress()
@@ -7264,54 +6294,6 @@ var TokenTransactionService = class {
         );
       }
     }
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      return this.fetchOwnedTokenOutputsV0(params);
-    } else {
-      return this.fetchOwnedTokenOutputsV1(params);
-    }
-  }
-  async queryTokenTransactions(params) {
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      return this.queryTokenTransactionsV0(params);
-    } else {
-      return this.queryTokenTransactionsV1(params);
-    }
-  }
-  async fetchOwnedTokenOutputsV0(params) {
-    const {
-      ownerPublicKeys,
-      issuerPublicKeys: tokenPublicKeys = [],
-      tokenIdentifiers = []
-    } = params;
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    try {
-      const result = await sparkClient.query_token_outputs({
-        ownerPublicKeys,
-        tokenPublicKeys,
-        tokenIdentifiers,
-        network: this.config.getNetworkProto()
-      });
-      return result.outputsWithPreviousTransactionData;
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to fetch owned token outputs",
-        {
-          operation: "spark.query_token_outputs",
-          errorCount: 1,
-          errors: error instanceof Error ? error.message : String(error)
-        },
-        error
-      );
-    }
-  }
-  async fetchOwnedTokenOutputsV1(params) {
-    const {
-      ownerPublicKeys,
-      issuerPublicKeys = [],
-      tokenIdentifiers = []
-    } = params;
     const tokenClient = await this.connectionManager.createSparkTokenClient(
       this.config.getCoordinatorAddress()
     );
@@ -7352,75 +6334,7 @@ var TokenTransactionService = class {
       );
     }
   }
-  async queryTokenTransactionsV0(params) {
-    const {
-      ownerPublicKeys,
-      issuerPublicKeys,
-      tokenTransactionHashes,
-      tokenIdentifiers,
-      outputIds,
-      pageSize,
-      offset
-    } = params;
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    let queryParams = {
-      tokenPublicKeys: issuerPublicKeys?.map(hexToBytes6),
-      ownerPublicKeys: ownerPublicKeys?.map(hexToBytes6),
-      tokenIdentifiers: tokenIdentifiers?.map((identifier) => {
-        const { tokenIdentifier } = decodeBech32mTokenIdentifier(
-          identifier,
-          this.config.getNetworkType()
-        );
-        return tokenIdentifier;
-      }),
-      tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes6),
-      outputIds: outputIds || [],
-      limit: pageSize,
-      offset
-    };
-    try {
-      const response = await sparkClient.query_token_transactions(queryParams);
-      return {
-        tokenTransactionsWithStatus: response.tokenTransactionsWithStatus.map(
-          (tx) => {
-            const v1TokenTransaction = {
-              version: 1,
-              network: tx.tokenTransaction.network,
-              tokenInputs: tx.tokenTransaction.tokenInputs,
-              tokenOutputs: tx.tokenTransaction.tokenOutputs,
-              sparkOperatorIdentityPublicKeys: tx.tokenTransaction.sparkOperatorIdentityPublicKeys,
-              expiryTime: void 0,
-              // V0 doesn't have expiry time
-              clientCreatedTimestamp: tx.tokenTransaction?.tokenInputs?.$case === "mintInput" ? new Date(
-                tx.tokenTransaction.tokenInputs.mintInput.issuerProvidedTimestamp * 1e3
-              ) : /* @__PURE__ */ new Date(),
-              invoiceAttachments: []
-            };
-            return {
-              tokenTransaction: v1TokenTransaction,
-              status: tx.status,
-              confirmationMetadata: tx.confirmationMetadata,
-              tokenTransactionHash: tx.tokenTransactionHash
-            };
-          }
-        ),
-        offset: response.offset
-      };
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to query token transactions",
-        {
-          operation: "spark.query_token_transactions",
-          errorCount: 1,
-          errors: error instanceof Error ? error.message : String(error)
-        },
-        error
-      );
-    }
-  }
-  async queryTokenTransactionsV1(params) {
+  async queryTokenTransactions(params) {
     const {
       ownerPublicKeys,
       issuerPublicKeys,
@@ -7533,50 +6447,6 @@ var TokenTransactionService = class {
       });
     }
   }
-  async finalizeTokenTransaction(finalTokenTransaction, revocationSecrets, threshold) {
-    const signingOperators = this.config.getSigningOperators();
-    const soResponses = await Promise.allSettled(
-      Object.entries(signingOperators).map(async ([identifier, operator]) => {
-        const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
-        const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-        try {
-          const response = await internalSparkClient.finalize_token_transaction(
-            {
-              finalTokenTransaction,
-              revocationSecrets,
-              identityPublicKey
-            },
-            {
-              retry: true,
-              retryableStatuses: [
-                "UNKNOWN",
-                "UNAVAILABLE",
-                "CANCELLED",
-                "INTERNAL"
-              ],
-              retryMaxAttempts: 3
-            }
-          );
-          return {
-            identifier,
-            response
-          };
-        } catch (error) {
-          throw new NetworkError(
-            "Failed to finalize token transaction",
-            {
-              operation: "finalize_token_transaction",
-              errorCount: 1,
-              errors: error instanceof Error ? error.message : String(error)
-            },
-            error
-          );
-        }
-      })
-    );
-    collectResponses(soResponses);
-    return finalTokenTransaction;
-  }
   async createSignaturesForOperators(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
     const inputTtxoSignaturesPerOperator = [];
     for (const [_, operator] of Object.entries(signingOperators)) {
@@ -7653,28 +6523,25 @@ var TokenTransactionService = class {
     return inputTtxoSignaturesPerOperator;
   }
 };
-function isTokenTransaction(tokenTransaction) {
-  return "version" in tokenTransaction && "expiryTime" in tokenTransaction;
-}
 
 // src/utils/adaptor-signature.ts
 import { mod } from "@noble/curves/abstract/modular";
-import { schnorr as schnorr5, secp256k1 as secp256k110 } from "@noble/curves/secp256k1";
+import { schnorr as schnorr5, secp256k1 as secp256k18 } from "@noble/curves/secp256k1";
 import { bytesToNumberBE as bytesToNumberBE6, numberToBytesBE as numberToBytesBE3 } from "@noble/curves/utils";
 function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
   const { r, s } = parseSignature(signature);
   const sBigInt = bytesToNumberBE6(s);
   const tBigInt = bytesToNumberBE6(adaptorPrivateKeyBytes);
-  const newS = mod(sBigInt - tBigInt, secp256k110.CURVE.n);
+  const newS = mod(sBigInt - tBigInt, secp256k18.CURVE.n);
   const newSignature = new Uint8Array([...r, ...numberToBytesBE3(newS, 32)]);
   return newSignature;
 }
 function generateAdaptorFromSignature(signature) {
-  const adaptorPrivateKey = secp256k110.utils.randomPrivateKey();
+  const adaptorPrivateKey = secp256k18.utils.randomPrivateKey();
   const { r, s } = parseSignature(signature);
   const sBigInt = bytesToNumberBE6(s);
   const tBigInt = bytesToNumberBE6(adaptorPrivateKey);
-  const newS = mod(sBigInt - tBigInt, secp256k110.CURVE.n);
+  const newS = mod(sBigInt - tBigInt, secp256k18.CURVE.n);
   const newSignature = new Uint8Array([...r, ...numberToBytesBE3(newS, 32)]);
   return {
     adaptorSignature: newSignature,
@@ -7694,7 +6561,7 @@ function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes
   const { r, s } = parseSignature(signature);
   const sBigInt = bytesToNumberBE6(s);
   const adaptorPrivateKey = bytesToNumberBE6(adaptorPrivateKeyBytes);
-  const newS = mod(sBigInt + adaptorPrivateKey, secp256k110.CURVE.n);
+  const newS = mod(sBigInt + adaptorPrivateKey, secp256k18.CURVE.n);
   const newSig = new Uint8Array([...r, ...numberToBytesBE3(newS, 32)]);
   try {
     if (schnorr5.verify(newSig, hash, pubkey)) {
@@ -7703,7 +6570,7 @@ function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes
   } catch (e) {
     console.error("[applyAdaptorToSignature] Addition verification failed:", e);
   }
-  const altS = mod(sBigInt - adaptorPrivateKey, secp256k110.CURVE.n);
+  const altS = mod(sBigInt - adaptorPrivateKey, secp256k18.CURVE.n);
   const altSig = new Uint8Array([...r, ...numberToBytesBE3(altS, 32)]);
   try {
     if (schnorr5.verify(altSig, hash, pubkey)) {
@@ -7733,18 +6600,18 @@ function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, i
   if (commitmenet.length > 32) {
     throw new Error("hash of (r || P || m) too big");
   }
-  const e = mod(bytesToNumberBE6(commitmenet), secp256k110.CURVE.n);
-  const negE = mod(-e, secp256k110.CURVE.n);
-  const sG = secp256k110.Point.BASE.multiplyUnsafe(bytesToNumberBE6(s));
+  const e = mod(bytesToNumberBE6(commitmenet), secp256k18.CURVE.n);
+  const negE = mod(-e, secp256k18.CURVE.n);
+  const sG = secp256k18.Point.BASE.multiplyUnsafe(bytesToNumberBE6(s));
   const eP = pubKey.multiplyUnsafe(negE);
   const R = sG.add(eP);
   if (R.is0()) {
     throw new Error("R is zero");
   }
   R.assertValidity();
-  const adaptorPoint = secp256k110.Point.fromHex(adaptorPubkey);
+  const adaptorPoint = secp256k18.Point.fromHex(adaptorPubkey);
   const newR = R.add(adaptorPoint);
-  if (!inbound && newR.equals(secp256k110.Point.ZERO)) {
+  if (!inbound && newR.equals(secp256k18.Point.ZERO)) {
     throw new Error("calculated R point is the point at infinity");
   }
   newR.assertValidity();
@@ -7772,23 +6639,23 @@ function parseSignature(signature) {
   }
   const r = signature.slice(0, 32);
   const s = signature.slice(32, 64);
-  if (bytesToNumberBE6(r) >= secp256k110.CURVE.Fp.ORDER) {
+  if (bytesToNumberBE6(r) >= secp256k18.CURVE.Fp.ORDER) {
     throw new ValidationError("Invalid signature: r >= field prime", {
       rValue: bytesToNumberBE6(r),
-      fieldPrime: secp256k110.CURVE.Fp.ORDER
+      fieldPrime: secp256k18.CURVE.Fp.ORDER
     });
   }
-  if (bytesToNumberBE6(s) >= secp256k110.CURVE.n) {
+  if (bytesToNumberBE6(s) >= secp256k18.CURVE.n) {
     throw new ValidationError("Invalid signature: s >= group order", {
       sValue: bytesToNumberBE6(s),
-      groupOrder: secp256k110.CURVE.n
+      groupOrder: secp256k18.CURVE.n
     });
   }
   return { r, s };
 }
 
 // src/tests/utils/test-faucet.ts
-import { schnorr as schnorr6, secp256k1 as secp256k111 } from "@noble/curves/secp256k1";
+import { schnorr as schnorr6, secp256k1 as secp256k19 } from "@noble/curves/secp256k1";
 import { bytesToHex as bytesToHex7, hexToBytes as hexToBytes7 } from "@noble/curves/utils";
 import * as btc3 from "@scure/btc-signer";
 import { Address as Address2, OutScript as OutScript2, SigHash as SigHash2, Transaction as Transaction4 } from "@scure/btc-signer";
@@ -7832,7 +6699,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     this.username = username;
     this.password = password;
     this.miningAddress = getP2TRAddressFromPublicKey(
-      secp256k111.getPublicKey(STATIC_MINING_KEY),
+      secp256k19.getPublicKey(STATIC_MINING_KEY),
       4 /* LOCAL */
     );
   }
@@ -7871,7 +6738,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     });
   }
   async refill() {
-    const minerPubKey = secp256k111.getPublicKey(STATIC_MINING_KEY);
+    const minerPubKey = secp256k19.getPublicKey(STATIC_MINING_KEY);
     const address2 = getP2TRAddressFromPublicKey(minerPubKey, 4 /* LOCAL */);
     const scanResult = await this.call("scantxoutset", [
       "start",
@@ -7920,7 +6787,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
       txid: selectedUtxo.txid,
       index: selectedUtxo.vout
     });
-    const faucetPubKey = secp256k111.getPublicKey(STATIC_FAUCET_KEY);
+    const faucetPubKey = secp256k19.getPublicKey(STATIC_FAUCET_KEY);
     const script = getP2TRScriptFromPublicKey(faucetPubKey, 4 /* LOCAL */);
     for (let i = 0; i < numCoinsToCreate; i++) {
       splitTx.addOutput({
@@ -7981,7 +6848,7 @@ var BitcoinFaucet = class _BitcoinFaucet {
     await this.broadcastTx(bytesToHex7(signedTx.extract()));
   }
   async signFaucetCoin(unsignedTx, fundingTxOut, key) {
-    const pubKey = secp256k111.getPublicKey(key);
+    const pubKey = secp256k19.getPublicKey(key);
     const internalKey = pubKey.slice(1);
     const script = getP2TRScriptFromPublicKey(pubKey, 4 /* LOCAL */);
     unsignedTx.updateInput(0, {
@@ -8064,8 +6931,8 @@ var BitcoinFaucet = class _BitcoinFaucet {
     return response;
   }
   async getNewAddress() {
-    const key = secp256k111.utils.randomPrivateKey();
-    const pubKey = secp256k111.getPublicKey(key);
+    const key = secp256k19.utils.randomPrivateKey();
+    const pubKey = secp256k19.getPublicKey(key);
     return getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */);
   }
   async sendToAddress(address2, amount, blocksToGenerate = 1) {
@@ -8086,8 +6953,8 @@ var BitcoinFaucet = class _BitcoinFaucet {
     });
     const changeAmount = availableAmount - amount;
     if (changeAmount > 0) {
-      const changeKey = secp256k111.utils.randomPrivateKey();
-      const changePubKey = secp256k111.getPublicKey(changeKey);
+      const changeKey = secp256k19.utils.randomPrivateKey();
+      const changePubKey = secp256k19.getPublicKey(changeKey);
       const changeScript = getP2TRScriptFromPublicKey(
         changePubKey,
         4 /* LOCAL */
@@ -8100,8 +6967,8 @@ var BitcoinFaucet = class _BitcoinFaucet {
     const signedTx = await this.signFaucetCoin(tx, coin.txout, coin.key);
     const txHex = bytesToHex7(signedTx.extract());
     await this.broadcastTx(txHex);
-    const randomKey = secp256k111.utils.randomPrivateKey();
-    const randomPubKey = secp256k111.getPublicKey(randomKey);
+    const randomKey = secp256k19.utils.randomPrivateKey();
+    const randomPubKey = secp256k19.getPublicKey(randomKey);
     const randomAddress = getP2TRAddressFromPublicKey(
       randomPubKey,
       4 /* LOCAL */
@@ -8126,19 +6993,18 @@ var SparkWalletEvent = {
 
 // src/spark-wallet/spark-wallet.ts
 import { isNode as isNode3, isObject as isObject2, mapCurrencyAmount } from "@lightsparkdev/core";
-import { secp256k1 as secp256k114 } from "@noble/curves/secp256k1";
+import { secp256k1 as secp256k112 } from "@noble/curves/secp256k1";
 import {
   bytesToHex as bytesToHex10,
   bytesToNumberBE as bytesToNumberBE8,
   equalBytes as equalBytes6,
-  hexToBytes as hexToBytes11,
-  numberToVarBytesBE
+  hexToBytes as hexToBytes11
 } from "@noble/curves/utils";
 import { validateMnemonic } from "@scure/bip39";
 import { wordlist as wordlist2 } from "@scure/bip39/wordlists/english";
 import { Address as Address3, OutScript as OutScript3, Transaction as Transaction7 } from "@scure/btc-signer";
 import { Mutex } from "async-mutex";
-import { uuidv7 as uuidv74, uuidv7obj } from "uuidv7";
+import { uuidv7 as uuidv74 } from "uuidv7";
 
 // src/graphql/client.ts
 import {
@@ -9261,7 +8127,7 @@ import { Transaction as Transaction6 } from "@scure/btc-signer";
 import { uuidv7 as uuidv72 } from "uuidv7";
 
 // src/services/transfer.ts
-import { secp256k1 as secp256k112 } from "@noble/curves/secp256k1";
+import { secp256k1 as secp256k110 } from "@noble/curves/secp256k1";
 import {
   bytesToHex as bytesToHex9,
   equalBytes as equalBytes5,
@@ -9569,7 +8435,7 @@ var BaseTransferService = class {
       first: leaf.keyDerivation,
       second: leaf.newKeyDerivation,
       receiverPublicKey: receiverEciesPubKey.toBytes(),
-      curveOrder: secp256k112.CURVE.n,
+      curveOrder: secp256k110.CURVE.n,
       threshold: this.config.getThreshold(),
       numShares: Object.keys(signingOperators).length
     });
@@ -9579,7 +8445,7 @@ var BaseTransferService = class {
       if (!share) {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
-      const pubkeyTweak = secp256k112.getPublicKey(
+      const pubkeyTweak = secp256k110.getPublicKey(
         numberToBytesBE4(share.share, 32),
         true
       );
@@ -9711,7 +8577,7 @@ var TransferService = class extends BaseTransferService {
         ...leaf.secretCipher
       ]);
       const payloadHash = sha25610(payload);
-      if (!secp256k112.verify(
+      if (!secp256k110.verify(
         leaf.signature,
         payloadHash,
         transfer.senderIdentityPublicKey
@@ -10005,7 +8871,7 @@ var TransferService = class extends BaseTransferService {
       {
         first: leaf.keyDerivation,
         second: leaf.newKeyDerivation,
-        curveOrder: secp256k112.CURVE.n,
+        curveOrder: secp256k110.CURVE.n,
         threshold: this.config.getThreshold(),
         numShares: Object.keys(signingOperators).length
       }
@@ -10016,7 +8882,7 @@ var TransferService = class extends BaseTransferService {
       if (!share) {
         throw new Error(`Share not found for operator ${operator.id}`);
       }
-      const pubkeyTweak = secp256k112.getPublicKey(
+      const pubkeyTweak = secp256k110.getPublicKey(
         numberToBytesBE4(share.share, 32)
       );
       pubkeySharesTweak.set(identifier, pubkeyTweak);
@@ -10988,7 +9854,7 @@ var CoopExitService = class extends BaseTransferService {
 };
 
 // src/services/lightning.ts
-import { secp256k1 as secp256k113 } from "@noble/curves/secp256k1";
+import { secp256k1 as secp256k111 } from "@noble/curves/secp256k1";
 import {
   bytesToNumberBE as bytesToNumberBE7,
   hexToBytes as hexToBytes9,
@@ -11079,7 +9945,7 @@ var LightningService = class {
     const crypto = getCrypto();
     const randBytes = crypto.getRandomValues(new Uint8Array(32));
     const preimage = numberToBytesBE5(
-      bytesToNumberBE7(randBytes) % secp256k113.CURVE.n,
+      bytesToNumberBE7(randBytes) % secp256k111.CURVE.n,
       32
     );
     return await this.createLightningInvoiceWithPreImage({
@@ -11116,7 +9982,7 @@ var LightningService = class {
     }
     const shares = await this.config.signer.splitSecretWithProofs({
       secret: preimage,
-      curveOrder: secp256k113.CURVE.n,
+      curveOrder: secp256k111.CURVE.n,
       threshold: this.config.getThreshold(),
       numShares: Object.keys(this.config.getSigningOperators()).length
     });
@@ -12108,47 +10974,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     senderPublicKey,
     expiryTime
   }) {
-    const MAX_SATS_AMOUNT = 21e14;
-    if (amount && (amount < 0 || amount > MAX_SATS_AMOUNT)) {
-      throw new ValidationError(
-        `Amount must be between 0 and ${MAX_SATS_AMOUNT} sats`,
-        {
-          field: "amount",
-          value: amount,
-          expected: `less than or equal to ${MAX_SATS_AMOUNT}`
-        }
-      );
-    }
-    const protoPayment = {
-      $case: "satsPayment",
-      satsPayment: {
-        amount
-      }
-    };
-    const invoiceFields = {
-      version: 1,
-      id: uuidv7obj().bytes,
-      paymentType: protoPayment,
-      memo,
-      senderPublicKey: senderPublicKey ? hexToBytes11(senderPublicKey) : void 0,
-      expiryTime: expiryTime ?? void 0
-    };
-    validateSparkInvoiceFields(invoiceFields);
-    const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const hash = HashSparkInvoice(
-      invoiceFields,
-      identityPublicKey,
-      this.config.getNetworkType()
-    );
-    const signature = await this.config.signer.signSchnorrWithIdentityKey(hash);
-    return encodeSparkAddressWithSignature(
-      {
-        identityPublicKey: bytesToHex10(identityPublicKey),
-        network: this.config.getNetworkType(),
-        sparkInvoiceFields: invoiceFields
-      },
-      signature
-    );
+    throw new NotImplementedError("Invoice functionality is not enabled");
   }
   /**
    * Creates a Spark invoice for a tokens payment on Spark.
@@ -12168,52 +10994,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     senderPublicKey,
     expiryTime
   }) {
-    const MAX_UINT128 = BigInt(2 ** 128 - 1);
-    if (amount && (amount < 0 || amount > MAX_UINT128)) {
-      throw new ValidationError(`Amount must be between 0 and ${MAX_UINT128}`, {
-        field: "amount",
-        value: amount,
-        expected: `greater than or equal to 0 and less than or equal to ${MAX_UINT128}`
-      });
-    }
-    let decodedTokenIdentifier = void 0;
-    if (tokenIdentifier) {
-      decodedTokenIdentifier = decodeBech32mTokenIdentifier(
-        tokenIdentifier,
-        this.config.getNetworkType()
-      ).tokenIdentifier;
-    }
-    const protoPayment = {
-      $case: "tokensPayment",
-      tokensPayment: {
-        tokenIdentifier: decodedTokenIdentifier ?? void 0,
-        amount: amount ? numberToVarBytesBE(amount) : void 0
-      }
-    };
-    const invoiceFields = {
-      version: 1,
-      id: uuidv7obj().bytes,
-      paymentType: protoPayment,
-      memo: memo ?? void 0,
-      senderPublicKey: senderPublicKey ? hexToBytes11(senderPublicKey) : void 0,
-      expiryTime: expiryTime ?? void 0
-    };
-    validateSparkInvoiceFields(invoiceFields);
-    const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-    const hash = HashSparkInvoice(
-      invoiceFields,
-      identityPublicKey,
-      this.config.getNetworkType()
-    );
-    const signature = await this.config.signer.signSchnorrWithIdentityKey(hash);
-    return encodeSparkAddressWithSignature(
-      {
-        identityPublicKey: bytesToHex10(identityPublicKey),
-        network: this.config.getNetworkType(),
-        sparkInvoiceFields: invoiceFields
-      },
-      signature
-    );
+    throw new NotImplementedError("Invoice functionality is not enabled");
   }
   /**
    * Initializes the wallet using either a mnemonic phrase or a raw seed.
@@ -12538,7 +11319,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       }
       const sspClient = this.getSspClient();
       const cpfpAdaptorPubkey = bytesToHex10(
-        secp256k114.getPublicKey(cpfpAdaptorPrivateKey)
+        secp256k112.getPublicKey(cpfpAdaptorPrivateKey)
       );
       if (!cpfpAdaptorPubkey) {
         throw new Error("Failed to generate CPFP adaptor pubkey");
@@ -12546,13 +11327,13 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       let directAdaptorPubkey;
       if (directAdaptorPrivateKey.length > 0) {
         directAdaptorPubkey = bytesToHex10(
-          secp256k114.getPublicKey(directAdaptorPrivateKey)
+          secp256k112.getPublicKey(directAdaptorPrivateKey)
         );
       }
       let directFromCpfpAdaptorPubkey;
       if (directFromCpfpAdaptorPrivateKey.length > 0) {
         directFromCpfpAdaptorPubkey = bytesToHex10(
-          secp256k114.getPublicKey(directFromCpfpAdaptorPrivateKey)
+          secp256k112.getPublicKey(directFromCpfpAdaptorPrivateKey)
         );
       }
       let request = null;
@@ -14167,10 +12948,30 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
       if (!invoice2) {
         throw new Error("Failed to create lightning invoice");
       }
+      const decodedInvoice = decodeInvoice(invoice2.invoice.encodedInvoice);
+      if (invoice2.invoice.paymentHash !== bytesToHex10(paymentHash) || decodedInvoice.paymentHash !== bytesToHex10(paymentHash)) {
+        throw new ValidationError("Payment hash mismatch", {
+          field: "paymentHash",
+          value: invoice2.invoice.paymentHash,
+          expected: bytesToHex10(paymentHash)
+        });
+      }
+      if (decodedInvoice.amountMSats === null && amountSats2 !== 0) {
+        throw new ValidationError("Amount mismatch", {
+          field: "amountMSats",
+          value: "null",
+          expected: amountSats2 * 1e3
+        });
+      }
+      if (decodedInvoice.amountMSats !== null && decodedInvoice.amountMSats !== BigInt(amountSats2 * 1e3)) {
+        throw new ValidationError("Amount mismatch", {
+          field: "amountMSats",
+          value: decodedInvoice.amountMSats,
+          expected: amountSats2 * 1e3
+        });
+      }
       if (includeSparkAddress) {
-        const sparkFallbackAddress = decodeInvoice(
-          invoice2.invoice.encodedInvoice
-        ).fallbackAddress;
+        const sparkFallbackAddress = decodedInvoice.fallbackAddress;
         if (!sparkFallbackAddress) {
           throw new ValidationError(
             "No spark fallback address found in lightning invoice",
@@ -14192,6 +12993,14 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
             }
           );
         }
+      } else if (decodedInvoice.fallbackAddress !== void 0) {
+        throw new ValidationError(
+          "Spark fallback address found in lightning invoice but includeSparkAddress is false",
+          {
+            field: "sparkFallbackAddress",
+            value: decodedInvoice.fallbackAddress
+          }
+        );
       }
       return invoice2;
     };
@@ -14359,91 +13168,7 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     });
   }
   async fulfillSparkInvoice(sparkInvoices) {
-    if (!Array.isArray(sparkInvoices) || sparkInvoices.length === 0) {
-      throw new ValidationError("No Spark invoices provided", {
-        field: "sparkInvoices",
-        value: sparkInvoices,
-        expected: "Non-empty array"
-      });
-    }
-    const satsTransactionSuccess = [];
-    const satsTransactionErrors = [];
-    const tokenTransactionSuccess = [];
-    const tokenTransactionErrors = [];
-    const { satsInvoices, tokenInvoices, invalidInvoices } = await this.groupSparkInvoicesByPaymentType(sparkInvoices);
-    if (invalidInvoices.length > 0) {
-      return {
-        satsTransactionSuccess,
-        satsTransactionErrors,
-        tokenTransactionSuccess,
-        tokenTransactionErrors,
-        invalidInvoices
-      };
-    }
-    if (tokenInvoices.size > 0) {
-      await this.syncTokenOutputs();
-      const tokenTransferTasks = [];
-      for (const [identifierHex, decodedInvoices] of tokenInvoices.entries()) {
-        const tokenIdentifier = hexToBytes11(identifierHex);
-        const tokenIdB32 = encodeBech32mTokenIdentifier({
-          tokenIdentifier,
-          network: this.config.getNetworkType()
-        });
-        const receiverOutputs = decodedInvoices.map((d) => ({
-          tokenIdentifier: tokenIdB32,
-          tokenAmount: d.amount,
-          receiverSparkAddress: d.invoice
-        }));
-        tokenTransferTasks.push(
-          this.tokenTransactionService.tokenTransfer({ tokenOutputs: this.tokenOutputs, receiverOutputs }).then((txid) => ({
-            ok: true,
-            tokenIdentifier: tokenIdB32,
-            txid
-          })).catch((e) => ({
-            ok: false,
-            tokenIdentifier: tokenIdB32,
-            error: e instanceof Error ? e : new Error(String(e))
-          }))
-        );
-      }
-      const results = await Promise.all(tokenTransferTasks);
-      for (const r of results) {
-        if (r.ok) {
-          tokenTransactionSuccess.push({
-            tokenIdentifier: r.tokenIdentifier,
-            txid: r.txid
-          });
-        } else {
-          tokenTransactionErrors.push({
-            tokenIdentifier: r.tokenIdentifier,
-            error: r.error
-          });
-        }
-      }
-    }
-    if (satsInvoices.length > 0) {
-      const transfers = await this.transferWithInvoice(satsInvoices);
-      for (const transfer of transfers) {
-        if (transfer.ok) {
-          satsTransactionSuccess.push({
-            invoice: transfer.param.sparkInvoice ?? "",
-            transferResponse: transfer.transfer
-          });
-        } else {
-          satsTransactionErrors.push({
-            invoice: transfer.param.sparkInvoice ?? "",
-            error: transfer.error
-          });
-        }
-      }
-    }
-    return {
-      satsTransactionSuccess,
-      satsTransactionErrors,
-      tokenTransactionSuccess,
-      tokenTransactionErrors,
-      invalidInvoices
-    };
+    throw new NotImplementedError("Invoice functionality is not enabled");
   }
   async groupSparkInvoicesByPaymentType(sparkInvoices) {
     const satsInvoices = [];
@@ -14580,6 +13305,9 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     });
     return { satsInvoices, tokenInvoices, invalidInvoices };
   }
+  async querySparkInvoices(invoices) {
+    throw new NotImplementedError("Invoice functionality is not enabled");
+  }
   /**
    * Gets fee estimate for sending Lightning payments.
    *
@@ -15641,6 +14369,27 @@ async function isTxBroadcast(txid, baseUrl, network) {
   return true;
 }
 
+// src/utils/response-validation.ts
+function collectResponses(responses) {
+  const successfulResponses = responses.filter(
+    (result) => result.status === "fulfilled"
+  ).map((result) => result.value);
+  const failedResponses = responses.filter(
+    (result) => result.status === "rejected"
+  );
+  if (failedResponses.length > 0) {
+    const errors = failedResponses.map((result) => result.reason).join("\n");
+    throw new NetworkError(
+      `${failedResponses.length} out of ${responses.length} requests failed, please try again`,
+      {
+        errorCount: failedResponses.length,
+        errors
+      }
+    );
+  }
+  return successfulResponses;
+}
+
 // src/utils/unilateral-exit.ts
 import { bytesToHex as bytesToHex11, hexToBytes as hexToBytes12 } from "@noble/curves/utils";
 import { ripemd160 } from "@noble/hashes/legacy";
@@ -16157,6 +14906,7 @@ __export(utils_exports, {
   addPublicKeys: () => addPublicKeys,
   applyAdaptorToSignature: () => applyAdaptorToSignature,
   applyAdditiveTweakToPublicKey: () => applyAdditiveTweakToPublicKey,
+  assertBech32: () => assertBech32,
   bech32mDecode: () => bech32mDecode,
   bigIntToPrivateKey: () => bigIntToPrivateKey,
   checkIfSelectedOutputsAreAvailable: () => checkIfSelectedOutputsAreAvailable,
@@ -16219,6 +14969,7 @@ __export(utils_exports, {
   getTxId: () => getTxId,
   getTxIdNoReverse: () => getTxIdNoReverse,
   isEphemeralAnchorOutput: () => isEphemeralAnchorOutput,
+  isLegacySparkAddress: () => isLegacySparkAddress,
   isSafeForNumber: () => isSafeForNumber,
   isTxBroadcast: () => isTxBroadcast,
   isValidPublicKey: () => isValidPublicKey,
@@ -16331,15 +15082,16 @@ export {
   encodeSparkAddress,
   encodeSparkAddressWithSignature,
   decodeSparkAddress,
+  getNetworkFromSparkAddress,
+  isLegacySparkAddress,
   isValidSparkAddress,
   isValidPublicKey,
   validateSparkInvoiceFields,
   validateSparkInvoiceSignature,
-  getNetworkFromSparkAddress,
   toProtoTimestamp,
+  assertBech32,
   bech32mDecode,
   isSafeForNumber,
-  collectResponses,
   encodeBech32mTokenIdentifier,
   decodeBech32mTokenIdentifier,
   getNetworkFromBech32mTokenIdentifier,
@@ -16356,6 +15108,7 @@ export {
   SparkWallet,
   getLatestDepositTxId,
   isTxBroadcast,
+  collectResponses,
   isEphemeralAnchorOutput,
   constructUnilateralExitTxs,
   constructUnilateralExitFeeBumpPackages,