@buildonspark/spark-sdk 0.1.45 → 0.1.47

package/dist/chunk-C2S227QR.js

@@ -1,2336 +0,0 @@
-import {
-  calculateAvailableTokenAmount,
-  checkIfSelectedOutputsAreAvailable,
-  collectResponses
-} from "./chunk-HWJWKEIU.js";
-import {
-  decodeSparkAddress
-} from "./chunk-KMUMFYFX.js";
-import {
-  bigIntToPrivateKey,
-  recoverSecret
-} from "./chunk-QNNSEJ4P.js";
-import {
-  InternalValidationError,
-  NetworkError,
-  ValidationError
-} from "./chunk-GSI4OLXZ.js";
-import {
-  Buffer
-} from "./chunk-MVRQ5US7.js";
-
-// src/services/token-transactions.ts
-import {
-  bytesToHex,
-  bytesToNumberBE,
-  numberToBytesBE
-} from "@noble/curves/abstract/utils";
-import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
-
-// src/utils/token-hashing.ts
-import { sha256 } from "@noble/hashes/sha2";
-function hashTokenTransaction(tokenTransaction, partialHash = false) {
-  switch (tokenTransaction.version) {
-    case 0:
-      return hashTokenTransactionV0(tokenTransaction, partialHash);
-    case 1:
-      return hashTokenTransactionV1(tokenTransaction, partialHash);
-    default:
-      throw new ValidationError("invalid token transaction version", {
-        field: "tokenTransaction.version",
-        value: tokenTransaction.version
-      });
-  }
-}
-function hashTokenTransactionV0(tokenTransaction, partialHash = false) {
-  if (!tokenTransaction) {
-    throw new ValidationError("token transaction cannot be nil", {
-      field: "tokenTransaction"
-    });
-  }
-  let allHashes = [];
-  if (tokenTransaction.tokenInputs?.$case === "transferInput") {
-    if (!tokenTransaction.tokenInputs.transferInput.outputsToSpend) {
-      throw new ValidationError("outputs to spend cannot be null", {
-        field: "tokenInputs.transferInput.outputsToSpend"
-      });
-    }
-    if (tokenTransaction.tokenInputs.transferInput.outputsToSpend.length === 0) {
-      throw new ValidationError("outputs to spend cannot be empty", {
-        field: "tokenInputs.transferInput.outputsToSpend"
-      });
-    }
-    for (const [
-      i,
-      output
-    ] of tokenTransaction.tokenInputs.transferInput.outputsToSpend.entries()) {
-      if (!output) {
-        throw new ValidationError(`output cannot be null at index ${i}`, {
-          field: `tokenInputs.transferInput.outputsToSpend[${i}]`,
-          index: i
-        });
-      }
-      const hashObj2 = sha256.create();
-      if (output.prevTokenTransactionHash) {
-        const prevHash = output.prevTokenTransactionHash;
-        if (output.prevTokenTransactionHash.length !== 32) {
-          throw new ValidationError(
-            `invalid previous transaction hash length at index ${i}`,
-            {
-              field: `tokenInputs.transferInput.outputsToSpend[${i}].prevTokenTransactionHash`,
-              value: prevHash,
-              expectedLength: 32,
-              actualLength: prevHash.length,
-              index: i
-            }
-          );
-        }
-        hashObj2.update(output.prevTokenTransactionHash);
-      }
-      const voutBytes = new Uint8Array(4);
-      new DataView(voutBytes.buffer).setUint32(
-        0,
-        output.prevTokenTransactionVout,
-        false
-      );
-      hashObj2.update(voutBytes);
-      allHashes.push(hashObj2.digest());
-    }
-  }
-  if (tokenTransaction.tokenInputs?.$case === "mintInput") {
-    const hashObj2 = sha256.create();
-    if (tokenTransaction.tokenInputs.mintInput.issuerPublicKey) {
-      const issuerPubKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-      if (issuerPubKey.length === 0) {
-        throw new ValidationError("issuer public key cannot be empty", {
-          field: "tokenInputs.mintInput.issuerPublicKey",
-          value: issuerPubKey,
-          expectedLength: 1,
-          actualLength: 0
-        });
-      }
-      hashObj2.update(issuerPubKey);
-      let timestampValue = 0;
-      const mintInput = tokenTransaction.tokenInputs.mintInput;
-      if ("issuerProvidedTimestamp" in mintInput) {
-        const v0MintInput = mintInput;
-        if (v0MintInput.issuerProvidedTimestamp != 0) {
-          timestampValue = v0MintInput.issuerProvidedTimestamp;
-        }
-      } else if ("clientCreatedTimestamp" in tokenTransaction && tokenTransaction.clientCreatedTimestamp) {
-        timestampValue = tokenTransaction.clientCreatedTimestamp.getTime();
-      }
-      if (timestampValue != 0) {
-        const timestampBytes = new Uint8Array(8);
-        new DataView(timestampBytes.buffer).setBigUint64(
-          0,
-          BigInt(timestampValue),
-          true
-          // true for little-endian to match Go implementation
-        );
-        hashObj2.update(timestampBytes);
-      }
-      allHashes.push(hashObj2.digest());
-    }
-  }
-  if (tokenTransaction.tokenInputs?.$case === "createInput") {
-    const issuerPubKeyHashObj = sha256.create();
-    const createInput = tokenTransaction.tokenInputs.createInput;
-    if (!createInput.issuerPublicKey || createInput.issuerPublicKey.length === 0) {
-      throw new ValidationError("issuer public key cannot be nil or empty", {
-        field: "tokenInputs.createInput.issuerPublicKey"
-      });
-    }
-    issuerPubKeyHashObj.update(createInput.issuerPublicKey);
-    allHashes.push(issuerPubKeyHashObj.digest());
-    const tokenNameHashObj = sha256.create();
-    if (!createInput.tokenName || createInput.tokenName.length === 0) {
-      throw new ValidationError("token name cannot be empty", {
-        field: "tokenInputs.createInput.tokenName"
-      });
-    }
-    if (createInput.tokenName.length > 20) {
-      throw new ValidationError("token name cannot be longer than 20 bytes", {
-        field: "tokenInputs.createInput.tokenName",
-        value: createInput.tokenName,
-        expectedLength: 20,
-        actualLength: createInput.tokenName.length
-      });
-    }
-    const tokenNameBytes = new Uint8Array(20);
-    const tokenNameEncoder = new TextEncoder();
-    tokenNameBytes.set(tokenNameEncoder.encode(createInput.tokenName));
-    tokenNameHashObj.update(tokenNameBytes);
-    allHashes.push(tokenNameHashObj.digest());
-    const tokenTickerHashObj = sha256.create();
-    if (!createInput.tokenTicker || createInput.tokenTicker.length === 0) {
-      throw new ValidationError("token ticker cannot be empty", {
-        field: "tokenInputs.createInput.tokenTicker"
-      });
-    }
-    if (createInput.tokenTicker.length > 6) {
-      throw new ValidationError("token ticker cannot be longer than 6 bytes", {
-        field: "tokenInputs.createInput.tokenTicker",
-        value: createInput.tokenTicker,
-        expectedLength: 6,
-        actualLength: createInput.tokenTicker.length
-      });
-    }
-    const tokenTickerBytes = new Uint8Array(6);
-    const tokenTickerEncoder = new TextEncoder();
-    tokenTickerBytes.set(tokenTickerEncoder.encode(createInput.tokenTicker));
-    tokenTickerHashObj.update(tokenTickerBytes);
-    allHashes.push(tokenTickerHashObj.digest());
-    const decimalsHashObj = sha256.create();
-    const decimalsBytes = new Uint8Array(4);
-    new DataView(decimalsBytes.buffer).setUint32(
-      0,
-      createInput.decimals,
-      false
-    );
-    decimalsHashObj.update(decimalsBytes);
-    allHashes.push(decimalsHashObj.digest());
-    const maxSupplyHashObj = sha256.create();
-    if (!createInput.maxSupply) {
-      throw new ValidationError("max supply cannot be nil", {
-        field: "tokenInputs.createInput.maxSupply"
-      });
-    }
-    if (createInput.maxSupply.length !== 16) {
-      throw new ValidationError("max supply must be exactly 16 bytes", {
-        field: "tokenInputs.createInput.maxSupply",
-        value: createInput.maxSupply,
-        expectedLength: 16,
-        actualLength: createInput.maxSupply.length
-      });
-    }
-    maxSupplyHashObj.update(createInput.maxSupply);
-    allHashes.push(maxSupplyHashObj.digest());
-    const isFreezableHashObj = sha256.create();
-    const isFreezableByte = new Uint8Array([createInput.isFreezable ? 1 : 0]);
-    isFreezableHashObj.update(isFreezableByte);
-    allHashes.push(isFreezableHashObj.digest());
-    const creationEntityHashObj = sha256.create();
-    if (!partialHash && createInput.creationEntityPublicKey) {
-      creationEntityHashObj.update(createInput.creationEntityPublicKey);
-    }
-    allHashes.push(creationEntityHashObj.digest());
-  }
-  if (!tokenTransaction.tokenOutputs) {
-    throw new ValidationError("token outputs cannot be null", {
-      field: "tokenOutputs"
-    });
-  }
-  if (tokenTransaction.tokenOutputs.length === 0 && tokenTransaction.tokenInputs?.$case !== "createInput") {
-    throw new ValidationError("token outputs cannot be empty", {
-      field: "tokenOutputs"
-    });
-  }
-  for (const [i, output] of tokenTransaction.tokenOutputs.entries()) {
-    if (!output) {
-      throw new ValidationError(`output cannot be null at index ${i}`, {
-        field: `tokenOutputs[${i}]`,
-        index: i
-      });
-    }
-    const hashObj2 = sha256.create();
-    if (output.id && !partialHash) {
-      if (output.id.length === 0) {
-        throw new ValidationError(`output ID at index ${i} cannot be empty`, {
-          field: `tokenOutputs[${i}].id`,
-          index: i
-        });
-      }
-      hashObj2.update(new TextEncoder().encode(output.id));
-    }
-    if (output.ownerPublicKey) {
-      if (output.ownerPublicKey.length === 0) {
-        throw new ValidationError(
-          `owner public key at index ${i} cannot be empty`,
-          {
-            field: `tokenOutputs[${i}].ownerPublicKey`,
-            index: i
-          }
-        );
-      }
-      hashObj2.update(output.ownerPublicKey);
-    }
-    if (!partialHash) {
-      const revPubKey = output.revocationCommitment;
-      if (revPubKey) {
-        if (revPubKey.length === 0) {
-          throw new ValidationError(
-            `revocation commitment at index ${i} cannot be empty`,
-            {
-              field: `tokenOutputs[${i}].revocationCommitment`,
-              index: i
-            }
-          );
-        }
-        hashObj2.update(revPubKey);
-      }
-      const bondBytes = new Uint8Array(8);
-      new DataView(bondBytes.buffer).setBigUint64(
-        0,
-        BigInt(output.withdrawBondSats),
-        false
-      );
-      hashObj2.update(bondBytes);
-      const locktimeBytes = new Uint8Array(8);
-      new DataView(locktimeBytes.buffer).setBigUint64(
-        0,
-        BigInt(output.withdrawRelativeBlockLocktime),
-        false
-      );
-      hashObj2.update(locktimeBytes);
-    }
-    if (output.tokenPublicKey) {
-      if (output.tokenPublicKey.length === 0) {
-        throw new ValidationError(
-          `token public key at index ${i} cannot be empty`,
-          {
-            field: `tokenOutputs[${i}].tokenPublicKey`,
-            index: i
-          }
-        );
-      }
-      hashObj2.update(output.tokenPublicKey);
-    }
-    if (output.tokenAmount) {
-      if (output.tokenAmount.length === 0) {
-        throw new ValidationError(
-          `token amount at index ${i} cannot be empty`,
-          {
-            field: `tokenOutputs[${i}].tokenAmount`,
-            index: i
-          }
-        );
-      }
-      if (output.tokenAmount.length > 16) {
-        throw new ValidationError(
-          `token amount at index ${i} exceeds maximum length`,
-          {
-            field: `tokenOutputs[${i}].tokenAmount`,
-            value: output.tokenAmount,
-            expectedLength: 16,
-            actualLength: output.tokenAmount.length,
-            index: i
-          }
-        );
-      }
-      hashObj2.update(output.tokenAmount);
-    }
-    allHashes.push(hashObj2.digest());
-  }
-  if (!tokenTransaction.sparkOperatorIdentityPublicKeys) {
-    throw new ValidationError(
-      "spark operator identity public keys cannot be null",
-      {}
-    );
-  }
-  const sortedPubKeys = [
-    ...tokenTransaction.sparkOperatorIdentityPublicKeys || []
-  ].sort((a, b) => {
-    for (let i = 0; i < a.length && i < b.length; i++) {
-      if (a[i] !== b[i]) return a[i] - b[i];
-    }
-    return a.length - b.length;
-  });
-  for (const [i, pubKey] of sortedPubKeys.entries()) {
-    if (!pubKey) {
-      throw new ValidationError(
-        `operator public key at index ${i} cannot be null`,
-        {
-          field: `sparkOperatorIdentityPublicKeys[${i}]`,
-          index: i
-        }
-      );
-    }
-    if (pubKey.length === 0) {
-      throw new ValidationError(
-        `operator public key at index ${i} cannot be empty`,
-        {
-          field: `sparkOperatorIdentityPublicKeys[${i}]`,
-          index: i
-        }
-      );
-    }
-    const hashObj2 = sha256.create();
-    hashObj2.update(pubKey);
-    allHashes.push(hashObj2.digest());
-  }
-  const hashObj = sha256.create();
-  let networkBytes = new Uint8Array(4);
-  new DataView(networkBytes.buffer).setUint32(
-    0,
-    tokenTransaction.network.valueOf(),
-    false
-    // false for big-endian
-  );
-  hashObj.update(networkBytes);
-  allHashes.push(hashObj.digest());
-  const finalHashObj = sha256.create();
-  const concatenatedHashes = new Uint8Array(
-    allHashes.reduce((sum, hash) => sum + hash.length, 0)
-  );
-  let offset = 0;
-  for (const hash of allHashes) {
-    concatenatedHashes.set(hash, offset);
-    offset += hash.length;
-  }
-  finalHashObj.update(concatenatedHashes);
-  return finalHashObj.digest();
-}
-function hashTokenTransactionV1(tokenTransaction, partialHash = false) {
-  if (!tokenTransaction) {
-    throw new ValidationError("token transaction cannot be nil", {
-      field: "tokenTransaction"
-    });
-  }
-  let allHashes = [];
-  const versionHashObj = sha256.create();
-  const versionBytes = new Uint8Array(4);
-  new DataView(versionBytes.buffer).setUint32(
-    0,
-    tokenTransaction.version,
-    false
-    // false for big-endian
-  );
-  versionHashObj.update(versionBytes);
-  allHashes.push(versionHashObj.digest());
-  const typeHashObj = sha256.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 = sha256.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 = sha256.create();
-      if (output.prevTokenTransactionHash) {
-        const prevHash = output.prevTokenTransactionHash;
-        if (output.prevTokenTransactionHash.length !== 32) {
-          throw new ValidationError(
-            `invalid previous transaction hash length at index ${i}`,
-            {
-              field: `tokenInputs.transferInput.outputsToSpend[${i}].prevTokenTransactionHash`,
-              value: prevHash,
-              expectedLength: 32,
-              actualLength: prevHash.length,
-              index: i
-            }
-          );
-        }
-        hashObj2.update(output.prevTokenTransactionHash);
-      }
-      const voutBytes = new Uint8Array(4);
-      new DataView(voutBytes.buffer).setUint32(
-        0,
-        output.prevTokenTransactionVout,
-        false
-      );
-      hashObj2.update(voutBytes);
-      allHashes.push(hashObj2.digest());
-    }
-  } else if (tokenTransaction.tokenInputs?.$case === "mintInput") {
-    const hashObj2 = sha256.create();
-    if (tokenTransaction.tokenInputs.mintInput.issuerPublicKey) {
-      const issuerPubKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-      if (issuerPubKey.length === 0) {
-        throw new ValidationError("issuer public key cannot be empty", {
-          field: "tokenInputs.mintInput.issuerPublicKey",
-          value: issuerPubKey,
-          expectedLength: 1,
-          actualLength: 0
-        });
-      }
-      hashObj2.update(issuerPubKey);
-      allHashes.push(hashObj2.digest());
-      const tokenIdentifierHashObj = sha256.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 = sha256.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 = sha256.create();
-    if (!createInput.tokenName || createInput.tokenName.length === 0) {
-      throw new ValidationError("token name cannot be empty", {
-        field: "tokenInputs.createInput.tokenName"
-      });
-    }
-    if (createInput.tokenName.length > 20) {
-      throw new ValidationError("token name cannot be longer than 20 bytes", {
-        field: "tokenInputs.createInput.tokenName",
-        value: createInput.tokenName,
-        expectedLength: 20,
-        actualLength: createInput.tokenName.length
-      });
-    }
-    const tokenNameEncoder = new TextEncoder();
-    tokenNameHashObj.update(tokenNameEncoder.encode(createInput.tokenName));
-    allHashes.push(tokenNameHashObj.digest());
-    const tokenTickerHashObj = sha256.create();
-    if (!createInput.tokenTicker || createInput.tokenTicker.length === 0) {
-      throw new ValidationError("token ticker cannot be empty", {
-        field: "tokenInputs.createInput.tokenTicker"
-      });
-    }
-    if (createInput.tokenTicker.length > 6) {
-      throw new ValidationError("token ticker cannot be longer than 6 bytes", {
-        field: "tokenInputs.createInput.tokenTicker",
-        value: createInput.tokenTicker,
-        expectedLength: 6,
-        actualLength: createInput.tokenTicker.length
-      });
-    }
-    const tokenTickerEncoder = new TextEncoder();
-    tokenTickerHashObj.update(
-      tokenTickerEncoder.encode(createInput.tokenTicker)
-    );
-    allHashes.push(tokenTickerHashObj.digest());
-    const decimalsHashObj = sha256.create();
-    const decimalsBytes = new Uint8Array(4);
-    new DataView(decimalsBytes.buffer).setUint32(
-      0,
-      createInput.decimals,
-      false
-    );
-    decimalsHashObj.update(decimalsBytes);
-    allHashes.push(decimalsHashObj.digest());
-    const maxSupplyHashObj = sha256.create();
-    if (!createInput.maxSupply) {
-      throw new ValidationError("max supply cannot be nil", {
-        field: "tokenInputs.createInput.maxSupply"
-      });
-    }
-    if (createInput.maxSupply.length !== 16) {
-      throw new ValidationError("max supply must be exactly 16 bytes", {
-        field: "tokenInputs.createInput.maxSupply",
-        value: createInput.maxSupply,
-        expectedLength: 16,
-        actualLength: createInput.maxSupply.length
-      });
-    }
-    maxSupplyHashObj.update(createInput.maxSupply);
-    allHashes.push(maxSupplyHashObj.digest());
-    const isFreezableHashObj = sha256.create();
-    isFreezableHashObj.update(
-      new Uint8Array([createInput.isFreezable ? 1 : 0])
-    );
-    allHashes.push(isFreezableHashObj.digest());
-    const creationEntityHashObj = sha256.create();
-    if (!partialHash && createInput.creationEntityPublicKey) {
-      creationEntityHashObj.update(createInput.creationEntityPublicKey);
-    }
-    allHashes.push(creationEntityHashObj.digest());
-  }
-  if (!tokenTransaction.tokenOutputs) {
-    throw new ValidationError("token outputs cannot be null", {
-      field: "tokenOutputs"
-    });
-  }
-  const outputsLenHashObj = sha256.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 = sha256.create();
-    if (output.id && !partialHash) {
-      if (output.id.length === 0) {
-        throw new ValidationError(`output ID at index ${i} cannot be empty`, {
-          field: `tokenOutputs[${i}].id`,
-          index: i
-        });
-      }
-      hashObj2.update(new TextEncoder().encode(output.id));
-    }
-    if (output.ownerPublicKey) {
-      if (output.ownerPublicKey.length === 0) {
-        throw new ValidationError(
-          `owner public key at index ${i} cannot be empty`,
-          {
-            field: `tokenOutputs[${i}].ownerPublicKey`,
-            index: i
-          }
-        );
-      }
-      hashObj2.update(output.ownerPublicKey);
-    }
-    if (!partialHash) {
-      const revPubKey = output.revocationCommitment;
-      if (revPubKey) {
-        if (revPubKey.length === 0) {
-          throw new ValidationError(
-            `revocation commitment at index ${i} cannot be empty`,
-            {
-              field: `tokenOutputs[${i}].revocationCommitment`,
-              index: i
-            }
-          );
-        }
-        hashObj2.update(revPubKey);
-      }
-      const bondBytes = new Uint8Array(8);
-      new DataView(bondBytes.buffer).setBigUint64(
-        0,
-        BigInt(output.withdrawBondSats),
-        false
-      );
-      hashObj2.update(bondBytes);
-      const locktimeBytes = new Uint8Array(8);
-      new DataView(locktimeBytes.buffer).setBigUint64(
-        0,
-        BigInt(output.withdrawRelativeBlockLocktime),
-        false
-      );
-      hashObj2.update(locktimeBytes);
-    }
-    if (!output.tokenPublicKey || 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 = sha256.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 = sha256.create();
-    hashObj2.update(pubKey);
-    allHashes.push(hashObj2.digest());
-  }
-  const hashObj = sha256.create();
-  let networkBytes = new Uint8Array(4);
-  new DataView(networkBytes.buffer).setUint32(
-    0,
-    tokenTransaction.network.valueOf(),
-    false
-    // false for big-endian
-  );
-  hashObj.update(networkBytes);
-  allHashes.push(hashObj.digest());
-  const clientTimestampHashObj = sha256.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 = sha256.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 = sha256.create();
-  const concatenatedHashes = new Uint8Array(
-    allHashes.reduce((sum, hash) => sum + hash.length, 0)
-  );
-  let offset = 0;
-  for (const hash of allHashes) {
-    concatenatedHashes.set(hash, offset);
-    offset += hash.length;
-  }
-  finalHashObj.update(concatenatedHashes);
-  return finalHashObj.digest();
-}
-function hashOperatorSpecificTokenTransactionSignablePayload(payload) {
-  if (!payload) {
-    throw new ValidationError(
-      "operator specific token transaction signable payload cannot be null",
-      {
-        field: "payload"
-      }
-    );
-  }
-  let allHashes = [];
-  if (payload.finalTokenTransactionHash) {
-    const hashObj2 = sha256.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 = sha256.create();
-  hashObj.update(payload.operatorIdentityPublicKey);
-  allHashes.push(hashObj.digest());
-  const finalHashObj = sha256.create();
-  const concatenatedHashes = new Uint8Array(
-    allHashes.reduce((sum, hash) => sum + hash.length, 0)
-  );
-  let offset = 0;
-  for (const hash of allHashes) {
-    concatenatedHashes.set(hash, offset);
-    offset += hash.length;
-  }
-  finalHashObj.update(concatenatedHashes);
-  return finalHashObj.digest();
-}
-
-// 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",
-      {
-        keyshareInfo: keyshareInfo.ownerIdentifiers
-      }
-    );
-  }
-  for (const identifier of keyshareInfo.ownerIdentifiers) {
-    if (!signingOperators[identifier]) {
-      throw new InternalValidationError(
-        `Keyshare operator ${identifier} not found in signing operator list`,
-        {
-          keyshareInfo: identifier,
-          signingOperators: Object.keys(signingOperators)
-        }
-      );
-    }
-  }
-}
-function validateTokenTransaction(finalTokenTransaction, partialTokenTransaction, signingOperators, keyshareInfo, expectedWithdrawBondSats, expectedWithdrawRelativeBlockLocktime, expectedThreshold) {
-  if (finalTokenTransaction.network !== partialTokenTransaction.network) {
-    throw new InternalValidationError(
-      "Network mismatch in response token transaction",
-      {
-        value: finalTokenTransaction.network,
-        expected: partialTokenTransaction.network
-      }
-    );
-  }
-  if (!finalTokenTransaction.tokenInputs) {
-    throw new InternalValidationError(
-      "Token inputs missing in final transaction",
-      {
-        value: finalTokenTransaction
-      }
-    );
-  }
-  if (!partialTokenTransaction.tokenInputs) {
-    throw new InternalValidationError(
-      "Token inputs missing in partial transaction",
-      {
-        value: partialTokenTransaction
-      }
-    );
-  }
-  if (finalTokenTransaction.tokenInputs.$case !== partialTokenTransaction.tokenInputs.$case) {
-    throw new InternalValidationError(
-      `Transaction type mismatch: final transaction has ${finalTokenTransaction.tokenInputs.$case}, partial transaction has ${partialTokenTransaction.tokenInputs.$case}`,
-      {
-        value: finalTokenTransaction.tokenInputs.$case,
-        expected: partialTokenTransaction.tokenInputs.$case
-      }
-    );
-  }
-  if (finalTokenTransaction.sparkOperatorIdentityPublicKeys.length !== partialTokenTransaction.sparkOperatorIdentityPublicKeys.length) {
-    throw new InternalValidationError(
-      "Spark operator identity public keys count mismatch",
-      {
-        value: finalTokenTransaction.sparkOperatorIdentityPublicKeys.length,
-        expected: partialTokenTransaction.sparkOperatorIdentityPublicKeys.length
-      }
-    );
-  }
-  if (partialTokenTransaction.tokenInputs.$case === "mintInput" && finalTokenTransaction.tokenInputs.$case === "mintInput") {
-    const finalMintInput = finalTokenTransaction.tokenInputs.mintInput;
-    const partialMintInput = partialTokenTransaction.tokenInputs.mintInput;
-    if (!areByteArraysEqual(
-      finalMintInput.issuerPublicKey,
-      partialMintInput.issuerPublicKey
-    )) {
-      throw new InternalValidationError(
-        "Issuer public key mismatch in mint input",
-        {
-          value: finalMintInput.issuerPublicKey.toString(),
-          expected: partialMintInput.issuerPublicKey.toString()
-        }
-      );
-    }
-  } else if (partialTokenTransaction.tokenInputs.$case === "transferInput" && finalTokenTransaction.tokenInputs.$case === "transferInput") {
-    const finalTransferInput = finalTokenTransaction.tokenInputs.transferInput;
-    const partialTransferInput = partialTokenTransaction.tokenInputs.transferInput;
-    if (finalTransferInput.outputsToSpend.length !== partialTransferInput.outputsToSpend.length) {
-      throw new InternalValidationError(
-        "Outputs to spend count mismatch in transfer input",
-        {
-          value: finalTransferInput.outputsToSpend.length,
-          expected: partialTransferInput.outputsToSpend.length
-        }
-      );
-    }
-    for (let i = 0; i < finalTransferInput.outputsToSpend.length; i++) {
-      const finalOutput = finalTransferInput.outputsToSpend[i];
-      const partialOutput = partialTransferInput.outputsToSpend[i];
-      if (!finalOutput) {
-        throw new InternalValidationError(
-          "Token output to spend missing in final transaction",
-          {
-            outputIndex: i,
-            value: finalOutput
-          }
-        );
-      }
-      if (!partialOutput) {
-        throw new InternalValidationError(
-          "Token output to spend missing in partial transaction",
-          {
-            outputIndex: i,
-            value: partialOutput
-          }
-        );
-      }
-      if (!areByteArraysEqual(
-        finalOutput.prevTokenTransactionHash,
-        partialOutput.prevTokenTransactionHash
-      )) {
-        throw new InternalValidationError(
-          "Previous token transaction hash mismatch in transfer input",
-          {
-            outputIndex: i,
-            value: finalOutput.prevTokenTransactionHash.toString(),
-            expected: partialOutput.prevTokenTransactionHash.toString()
-          }
-        );
-      }
-      if (finalOutput.prevTokenTransactionVout !== partialOutput.prevTokenTransactionVout) {
-        throw new InternalValidationError(
-          "Previous token transaction vout mismatch in transfer input",
-          {
-            outputIndex: i,
-            value: finalOutput.prevTokenTransactionVout,
-            expected: partialOutput.prevTokenTransactionVout
-          }
-        );
-      }
-    }
-  }
-  if (finalTokenTransaction.tokenOutputs.length !== partialTokenTransaction.tokenOutputs.length) {
-    throw new InternalValidationError("Token outputs count mismatch", {
-      value: finalTokenTransaction.tokenOutputs.length,
-      expected: partialTokenTransaction.tokenOutputs.length
-    });
-  }
-  for (let i = 0; i < finalTokenTransaction.tokenOutputs.length; i++) {
-    const finalOutput = finalTokenTransaction.tokenOutputs[i];
-    const partialOutput = partialTokenTransaction.tokenOutputs[i];
-    if (!finalOutput) {
-      throw new InternalValidationError(
-        "Token output missing in final transaction",
-        {
-          outputIndex: i,
-          value: finalOutput
-        }
-      );
-    }
-    if (!partialOutput) {
-      throw new InternalValidationError(
-        "Token output missing in partial transaction",
-        {
-          outputIndex: i,
-          value: partialOutput
-        }
-      );
-    }
-    if (!areByteArraysEqual(
-      finalOutput.ownerPublicKey,
-      partialOutput.ownerPublicKey
-    )) {
-      throw new InternalValidationError(
-        "Owner public key mismatch in token output",
-        {
-          outputIndex: i,
-          value: finalOutput.ownerPublicKey.toString(),
-          expected: partialOutput.ownerPublicKey.toString()
-        }
-      );
-    }
-    if (finalOutput.tokenPublicKey !== void 0 && partialOutput.tokenPublicKey !== void 0 && !areByteArraysEqual(
-      finalOutput.tokenPublicKey,
-      partialOutput.tokenPublicKey
-    )) {
-      throw new InternalValidationError(
-        "Token public key mismatch in token output",
-        {
-          outputIndex: i,
-          value: finalOutput.tokenPublicKey.toString(),
-          expected: partialOutput.tokenPublicKey.toString()
-        }
-      );
-    }
-    if (!areByteArraysEqual(finalOutput.tokenAmount, partialOutput.tokenAmount)) {
-      throw new InternalValidationError(
-        "Token amount mismatch in token output",
-        {
-          outputIndex: i,
-          value: finalOutput.tokenAmount.toString(),
-          expected: partialOutput.tokenAmount.toString()
-        }
-      );
-    }
-    if (finalOutput.withdrawBondSats !== void 0) {
-      if (finalOutput.withdrawBondSats !== expectedWithdrawBondSats) {
-        throw new InternalValidationError(
-          "Withdraw bond sats mismatch in token output",
-          {
-            outputIndex: i,
-            value: finalOutput.withdrawBondSats,
-            expected: expectedWithdrawBondSats
-          }
-        );
-      }
-    }
-    if (finalOutput.withdrawRelativeBlockLocktime !== void 0) {
-      if (finalOutput.withdrawRelativeBlockLocktime !== expectedWithdrawRelativeBlockLocktime) {
-        throw new InternalValidationError(
-          "Withdraw relative block locktime mismatch in token output",
-          {
-            outputIndex: i,
-            value: finalOutput.withdrawRelativeBlockLocktime,
-            expected: expectedWithdrawRelativeBlockLocktime
-          }
-        );
-      }
-    }
-    if (keyshareInfo.threshold !== expectedThreshold) {
-      throw new InternalValidationError(
-        "Threshold mismatch: expected " + expectedThreshold + " but got " + keyshareInfo.threshold,
-        {
-          field: "threshold",
-          value: keyshareInfo.threshold,
-          expected: expectedThreshold
-        }
-      );
-    }
-  }
-  if (keyshareInfo.ownerIdentifiers.length !== Object.keys(signingOperators).length) {
-    throw new InternalValidationError(
-      `Keyshare operator count (${keyshareInfo.ownerIdentifiers.length}) does not match signing operator count (${Object.keys(signingOperators).length})`,
-      {
-        keyshareInfo: keyshareInfo.ownerIdentifiers.length,
-        signingOperators: Object.keys(signingOperators).length
-      }
-    );
-  }
-  if (hasDuplicates(keyshareInfo.ownerIdentifiers)) {
-    throw new InternalValidationError(
-      "Duplicate ownerIdentifiers found in keyshareInfo",
-      {
-        keyshareInfo: keyshareInfo.ownerIdentifiers
-      }
-    );
-  }
-  for (const identifier of keyshareInfo.ownerIdentifiers) {
-    if (!signingOperators[identifier]) {
-      throw new InternalValidationError(
-        `Keyshare operator ${identifier} not found in signing operator list`,
-        {
-          keyshareInfo: identifier,
-          signingOperators: Object.keys(signingOperators)
-        }
-      );
-    }
-  }
-  if (finalTokenTransaction.clientCreatedTimestamp.getTime() !== partialTokenTransaction.clientCreatedTimestamp.getTime()) {
-    throw new InternalValidationError("Client created timestamp mismatch", {
-      value: finalTokenTransaction.clientCreatedTimestamp,
-      expected: partialTokenTransaction.clientCreatedTimestamp
-    });
-  }
-}
-
-// src/services/token-transactions.ts
-import { hexToBytes } from "@noble/hashes/utils";
-
-// src/utils/token-keyshares.ts
-import { secp256k1 } from "@noble/curves/secp256k1";
-function recoverRevocationSecretFromKeyshares(keyshares, threshold) {
-  const shares = keyshares.map((keyshare) => ({
-    fieldModulus: BigInt("0x" + secp256k1.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/services/token-transactions.ts
-var MAX_TOKEN_OUTPUTS = 500;
-var TokenTransactionService = class {
-  config;
-  connectionManager;
-  constructor(config, connectionManager) {
-    this.config = config;
-    this.connectionManager = connectionManager;
-  }
-  async tokenTransfer(tokenOutputs, receiverOutputs, outputSelectionStrategy = "SMALL_FIRST", selectedOutputs) {
-    if (receiverOutputs.length === 0) {
-      throw new ValidationError("No receiver outputs provided", {
-        field: "receiverOutputs",
-        value: receiverOutputs,
-        expected: "Non-empty array"
-      });
-    }
-    const totalTokenAmount = receiverOutputs.reduce(
-      (sum, transfer) => sum + transfer.tokenAmount,
-      0n
-    );
-    let outputsToUse;
-    if (selectedOutputs) {
-      outputsToUse = selectedOutputs;
-      if (!checkIfSelectedOutputsAreAvailable(
-        outputsToUse,
-        tokenOutputs,
-        hexToBytes(receiverOutputs[0].tokenPublicKey)
-      )) {
-        throw new ValidationError(
-          "One or more selected TTXOs are not available",
-          {
-            field: "selectedOutputs",
-            value: selectedOutputs,
-            expected: "Available TTXOs"
-          }
-        );
-      }
-    } else {
-      outputsToUse = this.selectTokenOutputs(
-        tokenOutputs.get(receiverOutputs[0].tokenPublicKey),
-        totalTokenAmount,
-        outputSelectionStrategy
-      );
-    }
-    if (outputsToUse.length > MAX_TOKEN_OUTPUTS) {
-      const availableOutputs = tokenOutputs.get(
-        receiverOutputs[0].tokenPublicKey
-      );
-      const sortedOutputs = [...availableOutputs];
-      this.sortTokenOutputsByStrategy(sortedOutputs, outputSelectionStrategy);
-      const maxOutputsToUse = sortedOutputs.slice(0, MAX_TOKEN_OUTPUTS);
-      const maxAmount = calculateAvailableTokenAmount(maxOutputsToUse);
-      throw new ValidationError(
-        `Cannot transfer more than ${MAX_TOKEN_OUTPUTS} TTXOs in a single transaction (${outputsToUse.length} selected). Maximum transferable amount is: ${maxAmount}`,
-        {
-          field: "outputsToUse",
-          value: outputsToUse.length,
-          expected: `Less than or equal to ${MAX_TOKEN_OUTPUTS}, with maximum transferable amount of ${maxAmount}`
-        }
-      );
-    }
-    const tokenOutputData = receiverOutputs.map((transfer) => {
-      const receiverAddress = decodeSparkAddress(
-        transfer.receiverSparkAddress,
-        this.config.getNetworkType()
-      );
-      return {
-        receiverSparkAddress: hexToBytes(receiverAddress.identityPublicKey),
-        tokenPublicKey: hexToBytes(transfer.tokenPublicKey),
-        tokenAmount: transfer.tokenAmount
-      };
-    });
-    let tokenTransaction;
-    if (this.config.getTokenTransactionVersion() === "V0") {
-      tokenTransaction = await this.constructTransferTokenTransactionV0(
-        outputsToUse,
-        tokenOutputData
-      );
-    } else {
-      tokenTransaction = await this.constructTransferTokenTransaction(
-        outputsToUse,
-        tokenOutputData
-      );
-    }
-    const txId = await this.broadcastTokenTransaction(
-      tokenTransaction,
-      outputsToUse.map((output) => output.output.ownerPublicKey),
-      outputsToUse.map((output) => output.output.revocationCommitment)
-    );
-    return txId;
-  }
-  async constructTransferTokenTransactionV0(selectedOutputs, tokenOutputData) {
-    selectedOutputs.sort(
-      (a, b) => a.previousTransactionVout - b.previousTransactionVout
-    );
-    const availableTokenAmount = calculateAvailableTokenAmount(selectedOutputs);
-    const totalRequestedAmount = tokenOutputData.reduce(
-      (sum, output) => sum + output.tokenAmount,
-      0n
-    );
-    const tokenOutputs = tokenOutputData.map((output) => ({
-      ownerPublicKey: output.receiverSparkAddress,
-      tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: numberToBytesBE(output.tokenAmount, 16)
-    }));
-    if (availableTokenAmount > totalRequestedAmount) {
-      const changeAmount = availableTokenAmount - totalRequestedAmount;
-      const firstTokenPublicKey = tokenOutputData[0].tokenPublicKey;
-      tokenOutputs.push({
-        ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
-        tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: numberToBytesBE(changeAmount, 16)
-      });
-    }
-    return {
-      network: this.config.getNetworkProto(),
-      tokenInputs: {
-        $case: "transferInput",
-        transferInput: {
-          outputsToSpend: selectedOutputs.map((output) => ({
-            prevTokenTransactionHash: output.previousTransactionHash,
-            prevTokenTransactionVout: output.previousTransactionVout
-          }))
-        }
-      },
-      tokenOutputs,
-      sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys()
-    };
-  }
-  async constructTransferTokenTransaction(selectedOutputs, tokenOutputData) {
-    selectedOutputs.sort(
-      (a, b) => a.previousTransactionVout - b.previousTransactionVout
-    );
-    const availableTokenAmount = calculateAvailableTokenAmount(selectedOutputs);
-    const totalRequestedAmount = tokenOutputData.reduce(
-      (sum, output) => sum + output.tokenAmount,
-      0n
-    );
-    const tokenOutputs = tokenOutputData.map((output) => ({
-      ownerPublicKey: output.receiverSparkAddress,
-      tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: numberToBytesBE(output.tokenAmount, 16)
-    }));
-    if (availableTokenAmount > totalRequestedAmount) {
-      const changeAmount = availableTokenAmount - totalRequestedAmount;
-      const firstTokenPublicKey = tokenOutputData[0].tokenPublicKey;
-      tokenOutputs.push({
-        ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
-        tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: numberToBytesBE(changeAmount, 16)
-      });
-    }
-    return {
-      version: 1,
-      network: this.config.getNetworkProto(),
-      tokenInputs: {
-        $case: "transferInput",
-        transferInput: {
-          outputsToSpend: selectedOutputs.map((output) => ({
-            prevTokenTransactionHash: output.previousTransactionHash,
-            prevTokenTransactionVout: output.previousTransactionVout
-          }))
-        }
-      },
-      tokenOutputs,
-      sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys(),
-      expiryTime: void 0,
-      clientCreatedTimestamp: /* @__PURE__ */ new Date()
-    };
-  }
-  collectOperatorIdentityPublicKeys() {
-    const operatorKeys = [];
-    for (const [_, operator] of Object.entries(
-      this.config.getSigningOperators()
-    )) {
-      operatorKeys.push(hexToBytes(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 = secp256k12.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: bytesToHex(outputsToSpendCommitments[outputIndex]),
-                outputIndex
-              }
-            )
-          );
-        }
-        revocationSecrets.push({
-          inputIndex: outputIndex,
-          revocationSecret
-        });
-      }
-      if (errors.length > 0) {
-        throw new ValidationError(
-          "Multiple validation errors occurred across outputs",
-          {
-            field: "outputValidation",
-            value: errors
-          }
-        );
-      }
-      await this.finalizeTokenTransaction(
-        finalTokenTransaction,
-        revocationSecrets,
-        threshold
-      );
-    }
-    return bytesToHex(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 bytesToHex(finalTokenTransactionHash);
-  }
-  async startTokenTransactionV0(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    const partialTokenTransactionHash = hashTokenTransactionV0(
-      tokenTransaction,
-      true
-    );
-    const ownerSignaturesWithIndex = [];
-    if (tokenTransaction.tokenInputs.$case === "mintInput") {
-      const issuerPublicKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-      if (!issuerPublicKey) {
-        throw new ValidationError("Invalid mint input", {
-          field: "issuerPublicKey",
-          value: null,
-          expected: "Non-null issuer public key"
-        });
-      }
-      const ownerSignature = await this.signMessageWithKey(
-        partialTokenTransactionHash,
-        issuerPublicKey
-      );
-      ownerSignaturesWithIndex.push({
-        signature: ownerSignature,
-        inputIndex: 0
-      });
-    } else if (tokenTransaction.tokenInputs.$case === "transferInput") {
-      if (!outputsToSpendSigningPublicKeys || !outputsToSpendCommitments) {
-        throw new ValidationError("Invalid transfer input", {
-          field: "outputsToSpend",
-          value: {
-            signingPublicKeys: outputsToSpendSigningPublicKeys,
-            revocationPublicKeys: outputsToSpendCommitments
-          },
-          expected: "Non-null signing and revocation public keys"
-        });
-      }
-      for (const [i, key] of outputsToSpendSigningPublicKeys.entries()) {
-        if (!key) {
-          throw new ValidationError("Invalid signing key", {
-            field: "outputsToSpendSigningPublicKeys",
-            value: i,
-            expected: "Non-null signing key"
-          });
-        }
-        const ownerSignature = await this.signMessageWithKey(
-          partialTokenTransactionHash,
-          key
-        );
-        ownerSignaturesWithIndex.push({
-          signature: ownerSignature,
-          inputIndex: i
-        });
-      }
-    }
-    const startResponse = await sparkClient.start_token_transaction(
-      {
-        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        partialTokenTransaction: tokenTransaction,
-        tokenTransactionSignatures: {
-          ownerSignatures: ownerSignaturesWithIndex
-        }
-      },
-      {
-        retry: true,
-        retryableStatuses: ["UNKNOWN", "UNAVAILABLE", "CANCELLED", "INTERNAL"],
-        retryMaxAttempts: 3
-      }
-    );
-    if (!startResponse.finalTokenTransaction) {
-      throw new Error("Final token transaction missing in start response");
-    }
-    if (!startResponse.keyshareInfo) {
-      throw new Error("Keyshare info missing in start response");
-    }
-    validateTokenTransactionV0(
-      startResponse.finalTokenTransaction,
-      tokenTransaction,
-      signingOperators,
-      startResponse.keyshareInfo,
-      this.config.getExpectedWithdrawBondSats(),
-      this.config.getExpectedWithdrawRelativeBlockLocktime(),
-      this.config.getThreshold()
-    );
-    const finalTokenTransaction = startResponse.finalTokenTransaction;
-    const finalTokenTransactionHash = hashTokenTransactionV0(
-      finalTokenTransaction,
-      false
-    );
-    return {
-      finalTokenTransaction,
-      finalTokenTransactionHash,
-      threshold: startResponse.keyshareInfo.threshold
-    };
-  }
-  async startTokenTransaction(tokenTransaction, signingOperators, outputsToSpendSigningPublicKeys, outputsToSpendCommitments) {
-    const sparkClient = await this.connectionManager.createSparkTokenClient(
-      this.config.getCoordinatorAddress()
-    );
-    const partialTokenTransactionHash = hashTokenTransaction(
-      tokenTransaction,
-      true
-    );
-    const ownerSignaturesWithIndex = [];
-    if (tokenTransaction.tokenInputs.$case === "mintInput") {
-      const issuerPublicKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-      if (!issuerPublicKey) {
-        throw new ValidationError("Invalid mint input", {
-          field: "issuerPublicKey",
-          value: null,
-          expected: "Non-null issuer public key"
-        });
-      }
-      const ownerSignature = await this.signMessageWithKey(
-        partialTokenTransactionHash,
-        issuerPublicKey
-      );
-      ownerSignaturesWithIndex.push({
-        signature: ownerSignature,
-        inputIndex: 0
-      });
-    } else if (tokenTransaction.tokenInputs.$case === "transferInput") {
-      if (!outputsToSpendSigningPublicKeys || !outputsToSpendCommitments) {
-        throw new ValidationError("Invalid transfer input", {
-          field: "outputsToSpend",
-          value: {
-            signingPublicKeys: outputsToSpendSigningPublicKeys,
-            revocationPublicKeys: outputsToSpendCommitments
-          },
-          expected: "Non-null signing and revocation public keys"
-        });
-      }
-      for (const [i, key] of outputsToSpendSigningPublicKeys.entries()) {
-        if (!key) {
-          throw new ValidationError("Invalid signing key", {
-            field: "outputsToSpendSigningPublicKeys",
-            value: i,
-            expected: "Non-null signing key"
-          });
-        }
-        const ownerSignature = await this.signMessageWithKey(
-          partialTokenTransactionHash,
-          key
-        );
-        ownerSignaturesWithIndex.push({
-          signature: ownerSignature,
-          inputIndex: i
-        });
-      }
-    }
-    const startResponse = await sparkClient.start_transaction(
-      {
-        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
-        partialTokenTransaction: tokenTransaction,
-        validityDurationSeconds: await this.config.getTokenValidityDurationSeconds(),
-        partialTokenTransactionOwnerSignatures: 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");
-    }
-    validateTokenTransaction(
-      startResponse.finalTokenTransaction,
-      tokenTransaction,
-      signingOperators,
-      startResponse.keyshareInfo,
-      this.config.getExpectedWithdrawBondSats(),
-      this.config.getExpectedWithdrawRelativeBlockLocktime(),
-      this.config.getThreshold()
-    );
-    const finalTokenTransaction = startResponse.finalTokenTransaction;
-    const finalTokenTransactionHash = hashTokenTransaction(
-      finalTokenTransaction,
-      false
-    );
-    return {
-      finalTokenTransaction,
-      finalTokenTransactionHash,
-      threshold: startResponse.keyshareInfo.threshold
-    };
-  }
-  async signTokenTransactionV0(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
-    const soSignatures = await Promise.allSettled(
-      Object.entries(signingOperators).map(
-        async ([identifier, operator], index) => {
-          const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
-          const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-          const payload = {
-            finalTokenTransactionHash,
-            operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
-          };
-          const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
-          let operatorSpecificSignatures = [];
-          if (finalTokenTransaction.tokenInputs.$case === "mintInput") {
-            const issuerPublicKey = finalTokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-            if (!issuerPublicKey) {
-              throw new ValidationError("Invalid mint input", {
-                field: "issuerPublicKey",
-                value: null,
-                expected: "Non-null issuer public key"
-              });
-            }
-            const ownerSignature = await this.signMessageWithKey(
-              payloadHash,
-              issuerPublicKey
-            );
-            operatorSpecificSignatures.push({
-              ownerSignature: {
-                signature: ownerSignature,
-                inputIndex: 0
-              },
-              payload
-            });
-          }
-          if (finalTokenTransaction.tokenInputs.$case === "transferInput") {
-            const transferInput = finalTokenTransaction.tokenInputs.transferInput;
-            for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
-              let ownerSignature;
-              if (this.config.getTokenSignatures() === "SCHNORR") {
-                ownerSignature = await this.config.signer.signSchnorrWithIdentityKey(
-                  payloadHash
-                );
-              } else {
-                ownerSignature = await this.config.signer.signMessageWithIdentityKey(
-                  payloadHash
-                );
-              }
-              operatorSpecificSignatures.push({
-                ownerSignature: {
-                  signature: ownerSignature,
-                  inputIndex: i
-                },
-                payload
-              });
-            }
-          }
-          try {
-            const response = await internalSparkClient.sign_token_transaction(
-              {
-                finalTokenTransaction,
-                operatorSpecificSignatures,
-                identityPublicKey
-              },
-              {
-                retry: true,
-                retryableStatuses: [
-                  "UNKNOWN",
-                  "UNAVAILABLE",
-                  "CANCELLED",
-                  "INTERNAL"
-                ],
-                retryMaxAttempts: 3
-              }
-            );
-            return {
-              index,
-              identifier,
-              response
-            };
-          } catch (error) {
-            throw new NetworkError(
-              "Failed to sign token transaction",
-              {
-                operation: "sign_token_transaction",
-                errorCount: 1,
-                errors: error instanceof Error ? error.message : String(error)
-              },
-              error
-            );
-          }
-        }
-      )
-    );
-    const successfulSignatures = collectResponses(soSignatures);
-    return {
-      successfulSignatures
-    };
-  }
-  async signTokenTransaction(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
-    const coordinatorClient = await this.connectionManager.createSparkTokenClient(
-      this.config.getCoordinatorAddress()
-    );
-    const inputTtxoSignaturesPerOperator = await this.createSignaturesForOperators(
-      finalTokenTransaction,
-      finalTokenTransactionHash,
-      signingOperators
-    );
-    try {
-      await coordinatorClient.commit_transaction(
-        {
-          finalTokenTransaction,
-          finalTokenTransactionHash,
-          inputTtxoSignaturesPerOperator,
-          ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey()
-        },
-        {
-          retry: true,
-          retryableStatuses: [
-            "UNKNOWN",
-            "UNAVAILABLE",
-            "CANCELLED",
-            "INTERNAL"
-          ],
-          retryMaxAttempts: 3
-        }
-      );
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to sign token transaction",
-        {
-          operation: "sign_token_transaction",
-          errorCount: 1,
-          errors: error instanceof Error ? error.message : String(error)
-        },
-        error
-      );
-    }
-  }
-  async fetchOwnedTokenOutputs(params) {
-    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()
-    );
-    try {
-      const result = await tokenClient.query_token_outputs({
-        ownerPublicKeys,
-        issuerPublicKeys,
-        tokenIdentifiers,
-        network: this.config.getNetworkProto()
-      });
-      return result.outputsWithPreviousTransactionData;
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to fetch owned token outputs",
-        {
-          operation: "spark_token.query_token_outputs",
-          errorCount: 1,
-          errors: error instanceof Error ? error.message : String(error)
-        },
-        error
-      );
-    }
-  }
-  async queryTokenTransactionsV0(params) {
-    const {
-      ownerPublicKeys,
-      issuerPublicKeys,
-      tokenTransactionHashes,
-      tokenIdentifiers,
-      outputIds
-    } = params;
-    const sparkClient = await this.connectionManager.createSparkClient(
-      this.config.getCoordinatorAddress()
-    );
-    let queryParams = {
-      tokenPublicKeys: issuerPublicKeys?.map(hexToBytes),
-      ownerPublicKeys: ownerPublicKeys?.map(hexToBytes),
-      tokenIdentifiers: tokenIdentifiers?.map(hexToBytes),
-      tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes),
-      outputIds: outputIds || [],
-      limit: 100,
-      offset: 0
-    };
-    try {
-      const response = await sparkClient.query_token_transactions(queryParams);
-      return 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()
-        };
-        return {
-          tokenTransaction: v1TokenTransaction,
-          status: tx.status,
-          confirmationMetadata: tx.confirmationMetadata
-        };
-      });
-    } 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) {
-    const {
-      ownerPublicKeys,
-      issuerPublicKeys,
-      tokenTransactionHashes,
-      tokenIdentifiers,
-      outputIds
-    } = params;
-    const tokenClient = await this.connectionManager.createSparkTokenClient(
-      this.config.getCoordinatorAddress()
-    );
-    let queryParams = {
-      issuerPublicKeys: issuerPublicKeys?.map(hexToBytes),
-      ownerPublicKeys: ownerPublicKeys?.map(hexToBytes),
-      tokenIdentifiers: tokenIdentifiers?.map(hexToBytes),
-      tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes),
-      outputIds: outputIds || [],
-      limit: 100,
-      offset: 0
-    };
-    try {
-      const response = await tokenClient.query_token_transactions(queryParams);
-      return response.tokenTransactionsWithStatus;
-    } catch (error) {
-      throw new NetworkError(
-        "Failed to query token transactions",
-        {
-          operation: "spark_token.query_token_transactions",
-          errorCount: 1,
-          errors: error instanceof Error ? error.message : String(error)
-        },
-        error
-      );
-    }
-  }
-  async syncTokenOutputs(tokenOutputs) {
-    const unsortedTokenOutputs = await this.fetchOwnedTokenOutputs({
-      ownerPublicKeys: await this.config.signer.getTrackedPublicKeys()
-    });
-    unsortedTokenOutputs.forEach((output) => {
-      const tokenKey = bytesToHex(output.output.tokenPublicKey);
-      const index = output.previousTransactionVout;
-      tokenOutputs.set(tokenKey, [
-        { ...output, previousTransactionVout: index }
-      ]);
-    });
-  }
-  selectTokenOutputs(tokenOutputs, tokenAmount, strategy) {
-    if (calculateAvailableTokenAmount(tokenOutputs) < tokenAmount) {
-      throw new ValidationError("Insufficient token amount", {
-        field: "tokenAmount",
-        value: calculateAvailableTokenAmount(tokenOutputs),
-        expected: tokenAmount
-      });
-    }
-    const exactMatch = tokenOutputs.find(
-      (item) => bytesToNumberBE(item.output.tokenAmount) === tokenAmount
-    );
-    if (exactMatch) {
-      return [exactMatch];
-    }
-    this.sortTokenOutputsByStrategy(tokenOutputs, strategy);
-    let remainingAmount = tokenAmount;
-    const selectedOutputs = [];
-    for (const outputWithPreviousTransactionData of tokenOutputs) {
-      if (remainingAmount <= 0n) break;
-      selectedOutputs.push(outputWithPreviousTransactionData);
-      remainingAmount -= bytesToNumberBE(
-        outputWithPreviousTransactionData.output.tokenAmount
-      );
-    }
-    if (remainingAmount > 0n) {
-      throw new ValidationError("Insufficient funds", {
-        field: "remainingAmount",
-        value: remainingAmount
-      });
-    }
-    return selectedOutputs;
-  }
-  sortTokenOutputsByStrategy(tokenOutputs, strategy) {
-    if (strategy === "SMALL_FIRST") {
-      tokenOutputs.sort((a, b) => {
-        return Number(
-          bytesToNumberBE(a.output.tokenAmount) - bytesToNumberBE(b.output.tokenAmount)
-        );
-      });
-    } else {
-      tokenOutputs.sort((a, b) => {
-        return Number(
-          bytesToNumberBE(b.output.tokenAmount) - bytesToNumberBE(a.output.tokenAmount)
-        );
-      });
-    }
-  }
-  // Helper function for deciding if the signer public key is the identity public key
-  async signMessageWithKey(message, publicKey) {
-    const tokenSignatures = this.config.getTokenSignatures();
-    if (bytesToHex(publicKey) === bytesToHex(await this.config.signer.getIdentityPublicKey())) {
-      if (tokenSignatures === "SCHNORR") {
-        return await this.config.signer.signSchnorrWithIdentityKey(message);
-      } else {
-        return await this.config.signer.signMessageWithIdentityKey(message);
-      }
-    } else {
-      if (tokenSignatures === "SCHNORR") {
-        return await this.config.signer.signSchnorr(message, publicKey);
-      } else {
-        return await this.config.signer.signMessageWithPublicKey(
-          message,
-          publicKey
-        );
-      }
-    }
-  }
-  async finalizeTokenTransaction(finalTokenTransaction, revocationSecrets, threshold) {
-    const signingOperators = this.config.getSigningOperators();
-    const soResponses = await Promise.allSettled(
-      Object.entries(signingOperators).map(async ([identifier, operator]) => {
-        const internalSparkClient = await this.connectionManager.createSparkClient(operator.address);
-        const identityPublicKey = await this.config.signer.getIdentityPublicKey();
-        try {
-          const response = await internalSparkClient.finalize_token_transaction(
-            {
-              finalTokenTransaction,
-              revocationSecrets,
-              identityPublicKey
-            },
-            {
-              retry: true,
-              retryableStatuses: [
-                "UNKNOWN",
-                "UNAVAILABLE",
-                "CANCELLED",
-                "INTERNAL"
-              ],
-              retryMaxAttempts: 3
-            }
-          );
-          return {
-            identifier,
-            response
-          };
-        } catch (error) {
-          throw new NetworkError(
-            "Failed to finalize token transaction",
-            {
-              operation: "finalize_token_transaction",
-              errorCount: 1,
-              errors: error instanceof Error ? error.message : String(error)
-            },
-            error
-          );
-        }
-      })
-    );
-    collectResponses(soResponses);
-    return finalTokenTransaction;
-  }
-  async createSignaturesForOperators(finalTokenTransaction, finalTokenTransactionHash, signingOperators) {
-    const inputTtxoSignaturesPerOperator = [];
-    for (const [_, operator] of Object.entries(signingOperators)) {
-      let ttxoSignatures = [];
-      if (finalTokenTransaction.tokenInputs.$case === "mintInput") {
-        const issuerPublicKey = finalTokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-        if (!issuerPublicKey) {
-          throw new ValidationError("Invalid mint input", {
-            field: "issuerPublicKey",
-            value: null,
-            expected: "Non-null issuer public key"
-          });
-        }
-        const payload = {
-          finalTokenTransactionHash,
-          operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
-        };
-        const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
-        const ownerSignature = await this.signMessageWithKey(
-          payloadHash,
-          issuerPublicKey
-        );
-        ttxoSignatures.push({
-          signature: ownerSignature,
-          inputIndex: 0
-        });
-      } else if (finalTokenTransaction.tokenInputs.$case === "transferInput") {
-        const transferInput = finalTokenTransaction.tokenInputs.transferInput;
-        for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
-          const payload = {
-            finalTokenTransactionHash,
-            operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
-          };
-          const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
-          let ownerSignature;
-          if (this.config.getTokenSignatures() === "SCHNORR") {
-            ownerSignature = await this.config.signer.signSchnorrWithIdentityKey(payloadHash);
-          } else {
-            ownerSignature = await this.config.signer.signMessageWithIdentityKey(payloadHash);
-          }
-          ttxoSignatures.push({
-            signature: ownerSignature,
-            inputIndex: i
-          });
-        }
-      }
-      inputTtxoSignaturesPerOperator.push({
-        ttxoSignatures,
-        operatorIdentityPublicKey: hexToBytes(operator.identityPublicKey)
-      });
-    }
-    return inputTtxoSignaturesPerOperator;
-  }
-};
-function isTokenTransaction(tokenTransaction) {
-  return "version" in tokenTransaction && "expiryTime" in tokenTransaction;
-}
-
-export {
-  TokenTransactionService
-};