@buildonspark/spark-sdk 0.1.45 → 0.1.47

package/dist/services/token-transactions.cjs

@@ -1,2877 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/services/token-transactions.ts
-var token_transactions_exports = {};
-__export(token_transactions_exports, {
-  TokenTransactionService: () => TokenTransactionService
-});
-module.exports = __toCommonJS(token_transactions_exports);
-
-// buffer.js
-var import_buffer = require("buffer");
-if (typeof globalThis.Buffer === "undefined") {
-  globalThis.Buffer = import_buffer.Buffer;
-}
-if (typeof window !== "undefined") {
-  if (typeof window.global === "undefined") {
-    window.global = window;
-  }
-  if (typeof window.globalThis === "undefined") {
-    window.globalThis = window;
-  }
-}
-
-// src/services/token-transactions.ts
-var import_utils6 = require("@noble/curves/abstract/utils");
-var import_secp256k14 = require("@noble/curves/secp256k1");
-
-// src/utils/token-hashing.ts
-var import_sha2 = require("@noble/hashes/sha2");
-
-// src/errors/base.ts
-var import_utils = require("@noble/hashes/utils");
-var SparkSDKError = class extends Error {
-  context;
-  originalError;
-  constructor(message, context = {}, originalError) {
-    const msg = getMessage(message, context, originalError);
-    super(msg);
-    this.name = this.constructor.name;
-    this.context = context;
-    this.originalError = originalError;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  toString() {
-    return this.message;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      context: this.context,
-      originalError: this.originalError ? {
-        name: this.originalError.name,
-        message: this.originalError.message,
-        stack: this.originalError.stack
-      } : void 0,
-      stack: this.stack
-    };
-  }
-};
-function getMessage(message, context = {}, originalError) {
-  const contextStr = Object.entries(context).map(([key, value]) => `${key}: ${safeStringify(value)}`).join(", ");
-  const originalErrorStr = originalError ? `
-Original Error: ${originalError.message}` : "";
-  return `SparkSDKError: ${message}${contextStr ? `
-Context: ${contextStr}` : ""}${originalErrorStr}`;
-}
-function safeStringify(value) {
-  const replacer = (_, v) => {
-    if (typeof v === "bigint") {
-      return v.toString();
-    }
-    if (v instanceof Uint8Array) {
-      return formatUint8Array(v);
-    }
-    return v;
-  };
-  if (typeof value === "bigint") {
-    return `"${value.toString()}"`;
-  }
-  if (value instanceof Uint8Array) {
-    return `"${formatUint8Array(value)}"`;
-  }
-  try {
-    const result = JSON.stringify(value, replacer);
-    return result === void 0 ? String(value) : result;
-  } catch {
-    try {
-      return String(value);
-    } catch {
-      return "[Unserializable]";
-    }
-  }
-}
-function formatUint8Array(arr) {
-  return `Uint8Array(0x${(0, import_utils.bytesToHex)(arr)})`;
-}
-
-// src/errors/types.ts
-var NetworkError = class extends SparkSDKError {
-  constructor(message, context = {}, originalError) {
-    super(message, context, originalError);
-  }
-};
-var ValidationError = class extends SparkSDKError {
-  constructor(message, context = {}, originalError) {
-    super(message, context, originalError);
-  }
-};
-var InternalValidationError = class extends SparkSDKError {
-  constructor(message, context = {}, originalError) {
-    super(message, context, originalError);
-  }
-};
-
-// src/proto/spark_token.ts
-var import_wire5 = require("@bufbuild/protobuf/wire");
-
-// src/proto/google/protobuf/timestamp.ts
-var import_wire = require("@bufbuild/protobuf/wire");
-
-// src/proto/spark.ts
-var import_wire4 = require("@bufbuild/protobuf/wire");
-
-// src/proto/common.ts
-var import_wire2 = require("@bufbuild/protobuf/wire");
-
-// src/proto/google/protobuf/empty.ts
-var import_wire3 = require("@bufbuild/protobuf/wire");
-
-// src/proto/spark.ts
-function createBaseSparkAddress() {
-  return { identityPublicKey: new Uint8Array(0), paymentIntentFields: void 0 };
-}
-var SparkAddress = {
-  encode(message, writer = new import_wire4.BinaryWriter()) {
-    if (message.identityPublicKey.length !== 0) {
-      writer.uint32(10).bytes(message.identityPublicKey);
-    }
-    if (message.paymentIntentFields !== void 0) {
-      PaymentIntentFields.encode(message.paymentIntentFields, writer.uint32(18).fork()).join();
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
-    const end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseSparkAddress();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.identityPublicKey = reader.bytes();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-          message.paymentIntentFields = PaymentIntentFields.decode(reader, reader.uint32());
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      identityPublicKey: isSet(object.identityPublicKey) ? bytesFromBase64(object.identityPublicKey) : new Uint8Array(0),
-      paymentIntentFields: isSet(object.paymentIntentFields) ? PaymentIntentFields.fromJSON(object.paymentIntentFields) : void 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.identityPublicKey.length !== 0) {
-      obj.identityPublicKey = base64FromBytes(message.identityPublicKey);
-    }
-    if (message.paymentIntentFields !== void 0) {
-      obj.paymentIntentFields = PaymentIntentFields.toJSON(message.paymentIntentFields);
-    }
-    return obj;
-  },
-  create(base) {
-    return SparkAddress.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseSparkAddress();
-    message.identityPublicKey = object.identityPublicKey ?? new Uint8Array(0);
-    message.paymentIntentFields = object.paymentIntentFields !== void 0 && object.paymentIntentFields !== null ? PaymentIntentFields.fromPartial(object.paymentIntentFields) : void 0;
-    return message;
-  }
-};
-function createBasePaymentIntentFields() {
-  return { id: new Uint8Array(0), assetIdentifier: void 0, assetAmount: new Uint8Array(0), memo: void 0 };
-}
-var PaymentIntentFields = {
-  encode(message, writer = new import_wire4.BinaryWriter()) {
-    if (message.id.length !== 0) {
-      writer.uint32(10).bytes(message.id);
-    }
-    if (message.assetIdentifier !== void 0) {
-      writer.uint32(18).bytes(message.assetIdentifier);
-    }
-    if (message.assetAmount.length !== 0) {
-      writer.uint32(26).bytes(message.assetAmount);
-    }
-    if (message.memo !== void 0) {
-      writer.uint32(34).string(message.memo);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
-    const end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBasePaymentIntentFields();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.id = reader.bytes();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-          message.assetIdentifier = reader.bytes();
-          continue;
-        }
-        case 3: {
-          if (tag !== 26) {
-            break;
-          }
-          message.assetAmount = reader.bytes();
-          continue;
-        }
-        case 4: {
-          if (tag !== 34) {
-            break;
-          }
-          message.memo = reader.string();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      id: isSet(object.id) ? bytesFromBase64(object.id) : new Uint8Array(0),
-      assetIdentifier: isSet(object.assetIdentifier) ? bytesFromBase64(object.assetIdentifier) : void 0,
-      assetAmount: isSet(object.assetAmount) ? bytesFromBase64(object.assetAmount) : new Uint8Array(0),
-      memo: isSet(object.memo) ? globalThis.String(object.memo) : void 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.id.length !== 0) {
-      obj.id = base64FromBytes(message.id);
-    }
-    if (message.assetIdentifier !== void 0) {
-      obj.assetIdentifier = base64FromBytes(message.assetIdentifier);
-    }
-    if (message.assetAmount.length !== 0) {
-      obj.assetAmount = base64FromBytes(message.assetAmount);
-    }
-    if (message.memo !== void 0) {
-      obj.memo = message.memo;
-    }
-    return obj;
-  },
-  create(base) {
-    return PaymentIntentFields.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBasePaymentIntentFields();
-    message.id = object.id ?? new Uint8Array(0);
-    message.assetIdentifier = object.assetIdentifier ?? void 0;
-    message.assetAmount = object.assetAmount ?? new Uint8Array(0);
-    message.memo = object.memo ?? void 0;
-    return message;
-  }
-};
-function bytesFromBase64(b64) {
-  if (globalThis.Buffer) {
-    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
-  } else {
-    const bin = globalThis.atob(b64);
-    const arr = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; ++i) {
-      arr[i] = bin.charCodeAt(i);
-    }
-    return arr;
-  }
-}
-function base64FromBytes(arr) {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.from(arr).toString("base64");
-  } else {
-    const bin = [];
-    arr.forEach((byte) => {
-      bin.push(globalThis.String.fromCharCode(byte));
-    });
-    return globalThis.btoa(bin.join(""));
-  }
-}
-function isSet(value) {
-  return value !== null && value !== void 0;
-}
-
-// src/utils/token-hashing.ts
-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 = import_sha2.sha256.create();
-      if (output.prevTokenTransactionHash) {
-        const prevHash = output.prevTokenTransactionHash;
-        if (output.prevTokenTransactionHash.length !== 32) {
-          throw new ValidationError(
-            `invalid previous transaction hash length at index ${i}`,
-            {
-              field: `tokenInputs.transferInput.outputsToSpend[${i}].prevTokenTransactionHash`,
-              value: prevHash,
-              expectedLength: 32,
-              actualLength: prevHash.length,
-              index: i
-            }
-          );
-        }
-        hashObj2.update(output.prevTokenTransactionHash);
-      }
-      const voutBytes = new Uint8Array(4);
-      new DataView(voutBytes.buffer).setUint32(
-        0,
-        output.prevTokenTransactionVout,
-        false
-      );
-      hashObj2.update(voutBytes);
-      allHashes.push(hashObj2.digest());
-    }
-  }
-  if (tokenTransaction.tokenInputs?.$case === "mintInput") {
-    const hashObj2 = import_sha2.sha256.create();
-    if (tokenTransaction.tokenInputs.mintInput.issuerPublicKey) {
-      const issuerPubKey = tokenTransaction.tokenInputs.mintInput.issuerPublicKey;
-      if (issuerPubKey.length === 0) {
-        throw new ValidationError("issuer public key cannot be empty", {
-          field: "tokenInputs.mintInput.issuerPublicKey",
-          value: issuerPubKey,
-          expectedLength: 1,
-          actualLength: 0
-        });
-      }
-      hashObj2.update(issuerPubKey);
-      let timestampValue = 0;
-      const mintInput = tokenTransaction.tokenInputs.mintInput;
-      if ("issuerProvidedTimestamp" in mintInput) {
-        const v0MintInput = mintInput;
-        if (v0MintInput.issuerProvidedTimestamp != 0) {
-          timestampValue = v0MintInput.issuerProvidedTimestamp;
-        }
-      } else if ("clientCreatedTimestamp" in tokenTransaction && tokenTransaction.clientCreatedTimestamp) {
-        timestampValue = tokenTransaction.clientCreatedTimestamp.getTime();
-      }
-      if (timestampValue != 0) {
-        const timestampBytes = new Uint8Array(8);
-        new DataView(timestampBytes.buffer).setBigUint64(
-          0,
-          BigInt(timestampValue),
-          true
-          // true for little-endian to match Go implementation
-        );
-        hashObj2.update(timestampBytes);
-      }
-      allHashes.push(hashObj2.digest());
-    }
-  }
-  if (tokenTransaction.tokenInputs?.$case === "createInput") {
-    const issuerPubKeyHashObj = import_sha2.sha256.create();
-    const createInput = tokenTransaction.tokenInputs.createInput;
-    if (!createInput.issuerPublicKey || createInput.issuerPublicKey.length === 0) {
-      throw new ValidationError("issuer public key cannot be nil or empty", {
-        field: "tokenInputs.createInput.issuerPublicKey"
-      });
-    }
-    issuerPubKeyHashObj.update(createInput.issuerPublicKey);
-    allHashes.push(issuerPubKeyHashObj.digest());
-    const tokenNameHashObj = import_sha2.sha256.create();
-    if (!createInput.tokenName || createInput.tokenName.length === 0) {
-      throw new ValidationError("token name cannot be empty", {
-        field: "tokenInputs.createInput.tokenName"
-      });
-    }
-    if (createInput.tokenName.length > 20) {
-      throw new ValidationError("token name cannot be longer than 20 bytes", {
-        field: "tokenInputs.createInput.tokenName",
-        value: createInput.tokenName,
-        expectedLength: 20,
-        actualLength: createInput.tokenName.length
-      });
-    }
-    const tokenNameBytes = new Uint8Array(20);
-    const tokenNameEncoder = new TextEncoder();
-    tokenNameBytes.set(tokenNameEncoder.encode(createInput.tokenName));
-    tokenNameHashObj.update(tokenNameBytes);
-    allHashes.push(tokenNameHashObj.digest());
-    const tokenTickerHashObj = import_sha2.sha256.create();
-    if (!createInput.tokenTicker || createInput.tokenTicker.length === 0) {
-      throw new ValidationError("token ticker cannot be empty", {
-        field: "tokenInputs.createInput.tokenTicker"
-      });
-    }
-    if (createInput.tokenTicker.length > 6) {
-      throw new ValidationError("token ticker cannot be longer than 6 bytes", {
-        field: "tokenInputs.createInput.tokenTicker",
-        value: createInput.tokenTicker,
-        expectedLength: 6,
-        actualLength: createInput.tokenTicker.length
-      });
-    }
-    const tokenTickerBytes = new Uint8Array(6);
-    const tokenTickerEncoder = new TextEncoder();
-    tokenTickerBytes.set(tokenTickerEncoder.encode(createInput.tokenTicker));
-    tokenTickerHashObj.update(tokenTickerBytes);
-    allHashes.push(tokenTickerHashObj.digest());
-    const decimalsHashObj = import_sha2.sha256.create();
-    const decimalsBytes = new Uint8Array(4);
-    new DataView(decimalsBytes.buffer).setUint32(
-      0,
-      createInput.decimals,
-      false
-    );
-    decimalsHashObj.update(decimalsBytes);
-    allHashes.push(decimalsHashObj.digest());
-    const maxSupplyHashObj = import_sha2.sha256.create();
-    if (!createInput.maxSupply) {
-      throw new ValidationError("max supply cannot be nil", {
-        field: "tokenInputs.createInput.maxSupply"
-      });
-    }
-    if (createInput.maxSupply.length !== 16) {
-      throw new ValidationError("max supply must be exactly 16 bytes", {
-        field: "tokenInputs.createInput.maxSupply",
-        value: createInput.maxSupply,
-        expectedLength: 16,
-        actualLength: createInput.maxSupply.length
-      });
-    }
-    maxSupplyHashObj.update(createInput.maxSupply);
-    allHashes.push(maxSupplyHashObj.digest());
-    const isFreezableHashObj = import_sha2.sha256.create();
-    const isFreezableByte = new Uint8Array([createInput.isFreezable ? 1 : 0]);
-    isFreezableHashObj.update(isFreezableByte);
-    allHashes.push(isFreezableHashObj.digest());
-    const creationEntityHashObj = import_sha2.sha256.create();
-    if (!partialHash && createInput.creationEntityPublicKey) {
-      creationEntityHashObj.update(createInput.creationEntityPublicKey);
-    }
-    allHashes.push(creationEntityHashObj.digest());
-  }
-  if (!tokenTransaction.tokenOutputs) {
-    throw new ValidationError("token outputs cannot be null", {
-      field: "tokenOutputs"
-    });
-  }
-  if (tokenTransaction.tokenOutputs.length === 0 && tokenTransaction.tokenInputs?.$case !== "createInput") {
-    throw new ValidationError("token outputs cannot be empty", {
-      field: "tokenOutputs"
-    });
-  }
-  for (const [i, output] of tokenTransaction.tokenOutputs.entries()) {
-    if (!output) {
-      throw new ValidationError(`output cannot be null at index ${i}`, {
-        field: `tokenOutputs[${i}]`,
-        index: i
-      });
-    }
-    const hashObj2 = import_sha2.sha256.create();
-    if (output.id && !partialHash) {
-      if (output.id.length === 0) {
-        throw new ValidationError(`output ID at index ${i} cannot be empty`, {
-          field: `tokenOutputs[${i}].id`,
-          index: i
-        });
-      }
-      hashObj2.update(new TextEncoder().encode(output.id));
-    }
-    if (output.ownerPublicKey) {
-      if (output.ownerPublicKey.length === 0) {
-        throw new ValidationError(
-          `owner public key at index ${i} cannot be empty`,
-          {
-            field: `tokenOutputs[${i}].ownerPublicKey`,
-            index: i
-          }
-        );
-      }
-      hashObj2.update(output.ownerPublicKey);
-    }
-    if (!partialHash) {
-      const revPubKey = output.revocationCommitment;
-      if (revPubKey) {
-        if (revPubKey.length === 0) {
-          throw new ValidationError(
-            `revocation commitment at index ${i} cannot be empty`,
-            {
-              field: `tokenOutputs[${i}].revocationCommitment`,
-              index: i
-            }
-          );
-        }
-        hashObj2.update(revPubKey);
-      }
-      const bondBytes = new Uint8Array(8);
-      new DataView(bondBytes.buffer).setBigUint64(
-        0,
-        BigInt(output.withdrawBondSats),
-        false
-      );
-      hashObj2.update(bondBytes);
-      const locktimeBytes = new Uint8Array(8);
-      new DataView(locktimeBytes.buffer).setBigUint64(
-        0,
-        BigInt(output.withdrawRelativeBlockLocktime),
-        false
-      );
-      hashObj2.update(locktimeBytes);
-    }
-    if (output.tokenPublicKey) {
-      if (output.tokenPublicKey.length === 0) {
-        throw new ValidationError(
-          `token public key at index ${i} cannot be empty`,
-          {
-            field: `tokenOutputs[${i}].tokenPublicKey`,
-            index: i
-          }
-        );
-      }
-      hashObj2.update(output.tokenPublicKey);
-    }
-    if (output.tokenAmount) {
-      if (output.tokenAmount.length === 0) {
-        throw new ValidationError(
-          `token amount at index ${i} cannot be empty`,
-          {
-            field: `tokenOutputs[${i}].tokenAmount`,
-            index: i
-          }
-        );
-      }
-      if (output.tokenAmount.length > 16) {
-        throw new ValidationError(
-          `token amount at index ${i} exceeds maximum length`,
-          {
-            field: `tokenOutputs[${i}].tokenAmount`,
-            value: output.tokenAmount,
-            expectedLength: 16,
-            actualLength: output.tokenAmount.length,
-            index: i
-          }
-        );
-      }
-      hashObj2.update(output.tokenAmount);
-    }
-    allHashes.push(hashObj2.digest());
-  }
-  if (!tokenTransaction.sparkOperatorIdentityPublicKeys) {
-    throw new ValidationError(
-      "spark operator identity public keys cannot be null",
-      {}
-    );
-  }
-  const sortedPubKeys = [
-    ...tokenTransaction.sparkOperatorIdentityPublicKeys || []
-  ].sort((a, b) => {
-    for (let i = 0; i < a.length && i < b.length; i++) {
-      if (a[i] !== b[i]) return a[i] - b[i];
-    }
-    return a.length - b.length;
-  });
-  for (const [i, pubKey] of sortedPubKeys.entries()) {
-    if (!pubKey) {
-      throw new ValidationError(
-        `operator public key at index ${i} cannot be null`,
-        {
-          field: `sparkOperatorIdentityPublicKeys[${i}]`,
-          index: i
-        }
-      );
-    }
-    if (pubKey.length === 0) {
-      throw new ValidationError(
-        `operator public key at index ${i} cannot be empty`,
-        {
-          field: `sparkOperatorIdentityPublicKeys[${i}]`,
-          index: i
-        }
-      );
-    }
-    const hashObj2 = import_sha2.sha256.create();
-    hashObj2.update(pubKey);
-    allHashes.push(hashObj2.digest());
-  }
-  const hashObj = import_sha2.sha256.create();
-  let networkBytes = new Uint8Array(4);
-  new DataView(networkBytes.buffer).setUint32(
-    0,
-    tokenTransaction.network.valueOf(),
-    false
-    // false for big-endian
-  );
-  hashObj.update(networkBytes);
-  allHashes.push(hashObj.digest());
-  const finalHashObj = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.sha256.create();
-    const decimalsBytes = new Uint8Array(4);
-    new DataView(decimalsBytes.buffer).setUint32(
-      0,
-      createInput.decimals,
-      false
-    );
-    decimalsHashObj.update(decimalsBytes);
-    allHashes.push(decimalsHashObj.digest());
-    const maxSupplyHashObj = import_sha2.sha256.create();
-    if (!createInput.maxSupply) {
-      throw new ValidationError("max supply cannot be nil", {
-        field: "tokenInputs.createInput.maxSupply"
-      });
-    }
-    if (createInput.maxSupply.length !== 16) {
-      throw new ValidationError("max supply must be exactly 16 bytes", {
-        field: "tokenInputs.createInput.maxSupply",
-        value: createInput.maxSupply,
-        expectedLength: 16,
-        actualLength: createInput.maxSupply.length
-      });
-    }
-    maxSupplyHashObj.update(createInput.maxSupply);
-    allHashes.push(maxSupplyHashObj.digest());
-    const isFreezableHashObj = import_sha2.sha256.create();
-    isFreezableHashObj.update(
-      new Uint8Array([createInput.isFreezable ? 1 : 0])
-    );
-    allHashes.push(isFreezableHashObj.digest());
-    const creationEntityHashObj = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.sha256.create();
-    hashObj2.update(pubKey);
-    allHashes.push(hashObj2.digest());
-  }
-  const hashObj = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.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 = import_sha2.sha256.create();
-  hashObj.update(payload.operatorIdentityPublicKey);
-  allHashes.push(hashObj.digest());
-  const finalHashObj = import_sha2.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-transactions.ts
-var import_utils2 = require("@noble/curves/abstract/utils");
-function calculateAvailableTokenAmount(outputLeaves) {
-  return outputLeaves.reduce(
-    (sum, output) => sum + BigInt((0, import_utils2.bytesToNumberBE)(output.output.tokenAmount)),
-    BigInt(0)
-  );
-}
-function checkIfSelectedOutputsAreAvailable(selectedOutputs, tokenOutputs, tokenPublicKey) {
-  const tokenPubKeyHex = (0, import_utils2.bytesToHex)(tokenPublicKey);
-  const tokenOutputsAvailable = tokenOutputs.get(tokenPubKeyHex);
-  if (!tokenOutputsAvailable) {
-    return false;
-  }
-  if (selectedOutputs.length === 0 || tokenOutputsAvailable.length < selectedOutputs.length) {
-    return false;
-  }
-  const availableOutputIds = new Set(
-    tokenOutputsAvailable.map((output) => output.output.id)
-  );
-  for (const selectedOutput of selectedOutputs) {
-    if (!selectedOutput.output?.id || !availableOutputIds.has(selectedOutput.output.id)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// 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
-var import_utils7 = require("@noble/hashes/utils");
-
-// src/address/address.ts
-var import_secp256k1 = require("@noble/curves/secp256k1");
-var import_utils3 = require("@noble/hashes/utils");
-var import_base2 = require("@scure/base");
-var import_uuidv7 = require("uuidv7");
-var import_utils4 = require("@noble/curves/abstract/utils");
-var AddressNetwork = {
-  MAINNET: "sp",
-  TESTNET: "spt",
-  REGTEST: "sprt",
-  SIGNET: "sps",
-  LOCAL: "spl"
-};
-function decodeSparkAddress(address, network) {
-  try {
-    const decoded = import_base2.bech32m.decode(address, 500);
-    if (decoded.prefix !== AddressNetwork[network]) {
-      throw new ValidationError("Invalid Spark address prefix", {
-        field: "address",
-        value: address,
-        expected: `prefix='${AddressNetwork[network]}'`
-      });
-    }
-    const payload = SparkAddress.decode(import_base2.bech32m.fromWords(decoded.words));
-    const publicKey = (0, import_utils3.bytesToHex)(payload.identityPublicKey);
-    isValidPublicKey(publicKey);
-    const paymentIntentFields = payload.paymentIntentFields;
-    return {
-      identityPublicKey: publicKey,
-      network,
-      paymentIntentFields: paymentIntentFields && {
-        id: import_uuidv7.UUID.ofInner(paymentIntentFields.id).toString(),
-        assetIdentifier: paymentIntentFields.assetIdentifier ? (0, import_utils3.bytesToHex)(paymentIntentFields.assetIdentifier) : void 0,
-        assetAmount: (0, import_utils4.bytesToNumberBE)(paymentIntentFields.assetAmount),
-        memo: paymentIntentFields.memo
-      }
-    };
-  } catch (error) {
-    if (error instanceof ValidationError) {
-      throw error;
-    }
-    throw new ValidationError(
-      "Failed to decode Spark address",
-      {
-        field: "address",
-        value: address
-      },
-      error
-    );
-  }
-}
-function isValidPublicKey(publicKey) {
-  try {
-    const point = import_secp256k1.secp256k1.ProjectivePoint.fromHex(publicKey);
-    point.assertValidity();
-  } catch (error) {
-    throw new ValidationError(
-      "Invalid public key",
-      {
-        field: "publicKey",
-        value: publicKey
-      },
-      error
-    );
-  }
-}
-
-// 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-keyshares.ts
-var import_secp256k13 = require("@noble/curves/secp256k1");
-
-// src/utils/secret-sharing.ts
-var import_utils5 = require("@noble/curves/abstract/utils");
-var import_secp256k12 = require("@noble/curves/secp256k1");
-
-// src/utils/crypto.ts
-var import_crypto = __toESM(require("crypto"), 1);
-var getCrypto = () => {
-  let cryptoImpl = typeof window !== "undefined" ? window.crypto : typeof global !== "undefined" && global.crypto ? global.crypto : import_crypto.default;
-  return cryptoImpl;
-};
-
-// src/utils/secret-sharing.ts
-var crypto = getCrypto();
-function modInverse(a, m) {
-  a = (a % m + m) % m;
-  let [old_r, r] = [a, m];
-  let [old_s, s] = [1n, 0n];
-  let [old_t, t] = [0n, 1n];
-  while (r !== 0n) {
-    const quotient = old_r / r;
-    [old_r, r] = [r, old_r - quotient * r];
-    [old_s, s] = [s, old_s - quotient * s];
-    [old_t, t] = [t, old_t - quotient * t];
-  }
-  if (old_r !== 1n) {
-    throw new ValidationError("Modular inverse does not exist", {
-      field: "modInverse",
-      value: `a: ${a}, m: ${m}`,
-      expected: "a and m must be coprime"
-    });
-  }
-  return (old_s % m + m) % m;
-}
-function fieldDiv(numerator, denominator, fieldModulus) {
-  if (denominator === 0n) {
-    throw new ValidationError("Division by zero", {
-      field: "denominator",
-      value: "0",
-      expected: "Non-zero value"
-    });
-  }
-  const inverse = modInverse(denominator, fieldModulus);
-  return numerator * inverse % fieldModulus;
-}
-function computerLagrangeCoefficients(index, points) {
-  let numerator = 1n;
-  let denominator = 1n;
-  let fieldModulus = points[0]?.fieldModulus;
-  if (!fieldModulus) {
-    throw new ValidationError("Field modulus is undefined", {
-      field: "fieldModulus",
-      value: "undefined",
-      expected: "A valid field modulus"
-    });
-  }
-  for (const point of points) {
-    if (point.index === index) {
-      continue;
-    }
-    numerator = numerator * point.index;
-    const value = point.index - index;
-    denominator = denominator * value;
-  }
-  return fieldDiv(numerator, denominator, fieldModulus);
-}
-function recoverSecret(shares) {
-  if (shares.length === 0) return 0n;
-  const threshold = shares[0]?.threshold;
-  const fieldModulus = shares[0]?.fieldModulus;
-  if (!threshold || !fieldModulus) {
-    throw new ValidationError("Shares are not valid", {
-      field: "shares",
-      value: "Missing threshold or fieldModulus",
-      expected: "Valid shares with threshold and fieldModulus"
-    });
-  }
-  if (shares.length < threshold) {
-    throw new ValidationError("Not enough shares to recover secret", {
-      field: "shares",
-      value: shares.length,
-      expected: `At least ${threshold} shares`
-    });
-  }
-  let result = 0n;
-  for (const share of shares) {
-    const coeff = computerLagrangeCoefficients(share.index, shares);
-    const item = share.share * coeff % fieldModulus;
-    result = (result + item) % fieldModulus;
-  }
-  return result;
-}
-function bigIntToPrivateKey(value) {
-  const hex = value.toString(16).padStart(64, "0");
-  const bytes = new Uint8Array(32);
-  for (let i = 0; i < 32; i++) {
-    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-
-// src/utils/token-keyshares.ts
-function recoverRevocationSecretFromKeyshares(keyshares, threshold) {
-  const shares = keyshares.map((keyshare) => ({
-    fieldModulus: BigInt("0x" + import_secp256k13.secp256k1.CURVE.n.toString(16)),
-    // secp256k1 curve order
-    threshold,
-    index: BigInt(keyshare.operatorIndex),
-    share: BigInt(
-      "0x" + import_buffer.Buffer.from(keyshare.keyshare.keyshare).toString("hex")
-    ),
-    proofs: []
-  }));
-  const recoveredSecret = recoverSecret(shares);
-  return bigIntToPrivateKey(recoveredSecret);
-}
-
-// src/services/token-transactions.ts
-var MAX_TOKEN_OUTPUTS = 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,
-        (0, import_utils7.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: (0, import_utils7.hexToBytes)(receiverAddress.identityPublicKey),
-        tokenPublicKey: (0, import_utils7.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: (0, import_utils6.numberToBytesBE)(output.tokenAmount, 16)
-    }));
-    if (availableTokenAmount > totalRequestedAmount) {
-      const changeAmount = availableTokenAmount - totalRequestedAmount;
-      const firstTokenPublicKey = tokenOutputData[0].tokenPublicKey;
-      tokenOutputs.push({
-        ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
-        tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils6.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: (0, import_utils6.numberToBytesBE)(output.tokenAmount, 16)
-    }));
-    if (availableTokenAmount > totalRequestedAmount) {
-      const changeAmount = availableTokenAmount - totalRequestedAmount;
-      const firstTokenPublicKey = tokenOutputData[0].tokenPublicKey;
-      tokenOutputs.push({
-        ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
-        tokenPublicKey: firstTokenPublicKey,
-        tokenAmount: (0, import_utils6.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((0, import_utils7.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 = import_secp256k14.secp256k1.getPublicKey(
-          revocationSecret,
-          true
-        );
-        if (!outputsToSpendCommitments || !outputsToSpendCommitments[outputIndex] || !derivedRevocationCommitment.every(
-          (byte, i) => byte === outputsToSpendCommitments[outputIndex][i]
-        )) {
-          errors.push(
-            new InternalValidationError(
-              "Revocation commitment verification failed",
-              {
-                field: "revocationCommitment",
-                value: derivedRevocationCommitment,
-                expected: (0, import_utils6.bytesToHex)(outputsToSpendCommitments[outputIndex]),
-                outputIndex
-              }
-            )
-          );
-        }
-        revocationSecrets.push({
-          inputIndex: outputIndex,
-          revocationSecret
-        });
-      }
-      if (errors.length > 0) {
-        throw new ValidationError(
-          "Multiple validation errors occurred across outputs",
-          {
-            field: "outputValidation",
-            value: errors
-          }
-        );
-      }
-      await this.finalizeTokenTransaction(
-        finalTokenTransaction,
-        revocationSecrets,
-        threshold
-      );
-    }
-    return (0, import_utils6.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 (0, import_utils6.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: (0, import_utils7.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(import_utils7.hexToBytes),
-      ownerPublicKeys: ownerPublicKeys?.map(import_utils7.hexToBytes),
-      tokenIdentifiers: tokenIdentifiers?.map(import_utils7.hexToBytes),
-      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils7.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(import_utils7.hexToBytes),
-      ownerPublicKeys: ownerPublicKeys?.map(import_utils7.hexToBytes),
-      tokenIdentifiers: tokenIdentifiers?.map(import_utils7.hexToBytes),
-      tokenTransactionHashes: tokenTransactionHashes?.map(import_utils7.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 = (0, import_utils6.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) => (0, import_utils6.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 -= (0, import_utils6.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(
-          (0, import_utils6.bytesToNumberBE)(a.output.tokenAmount) - (0, import_utils6.bytesToNumberBE)(b.output.tokenAmount)
-        );
-      });
-    } else {
-      tokenOutputs.sort((a, b) => {
-        return Number(
-          (0, import_utils6.bytesToNumberBE)(b.output.tokenAmount) - (0, import_utils6.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 ((0, import_utils6.bytesToHex)(publicKey) === (0, import_utils6.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: (0, import_utils7.hexToBytes)(operator.identityPublicKey)
-        };
-        const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
-        const ownerSignature = await this.signMessageWithKey(
-          payloadHash,
-          issuerPublicKey
-        );
-        ttxoSignatures.push({
-          signature: ownerSignature,
-          inputIndex: 0
-        });
-      } else if (finalTokenTransaction.tokenInputs.$case === "transferInput") {
-        const transferInput = finalTokenTransaction.tokenInputs.transferInput;
-        for (let i = 0; i < transferInput.outputsToSpend.length; i++) {
-          const payload = {
-            finalTokenTransactionHash,
-            operatorIdentityPublicKey: (0, import_utils7.hexToBytes)(operator.identityPublicKey)
-          };
-          const payloadHash = await hashOperatorSpecificTokenTransactionSignablePayload(payload);
-          let ownerSignature;
-          if (this.config.getTokenSignatures() === "SCHNORR") {
-            ownerSignature = await this.config.signer.signSchnorrWithIdentityKey(payloadHash);
-          } else {
-            ownerSignature = await this.config.signer.signMessageWithIdentityKey(payloadHash);
-          }
-          ttxoSignatures.push({
-            signature: ownerSignature,
-            inputIndex: i
-          });
-        }
-      }
-      inputTtxoSignaturesPerOperator.push({
-        ttxoSignatures,
-        operatorIdentityPublicKey: (0, import_utils7.hexToBytes)(operator.identityPublicKey)
-      });
-    }
-    return inputTtxoSignaturesPerOperator;
-  }
-};
-function isTokenTransaction(tokenTransaction) {
-  return "version" in tokenTransaction && "expiryTime" in tokenTransaction;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  TokenTransactionService
-});