@buildonspark/spark-sdk 0.1.46 → 0.1.47

package/dist/utils/index.cjs

@@ -1,2947 +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 = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __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 || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
-  mod2
-));
-var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
-
-// src/utils/index.ts
-var utils_exports = {};
-__export(utils_exports, {
-  DEFAULT_FEE_SATS: () => DEFAULT_FEE_SATS,
-  LRC_WALLET_NETWORK: () => LRC_WALLET_NETWORK,
-  LRC_WALLET_NETWORK_TYPE: () => LRC_WALLET_NETWORK_TYPE,
-  Network: () => Network2,
-  NetworkToProto: () => NetworkToProto,
-  addPrivateKeys: () => addPrivateKeys,
-  addPublicKeys: () => addPublicKeys,
-  applyAdaptorToSignature: () => applyAdaptorToSignature,
-  applyAdditiveTweakToPublicKey: () => applyAdditiveTweakToPublicKey,
-  bigIntToPrivateKey: () => bigIntToPrivateKey,
-  calculateAvailableTokenAmount: () => calculateAvailableTokenAmount,
-  checkIfSelectedOutputsAreAvailable: () => checkIfSelectedOutputsAreAvailable,
-  checkIfValidSequence: () => checkIfValidSequence,
-  collectResponses: () => collectResponses,
-  computeTaprootKeyNoScript: () => computeTaprootKeyNoScript,
-  computerLagrangeCoefficients: () => computerLagrangeCoefficients,
-  constructFeeBumpTx: () => constructFeeBumpTx,
-  constructUnilateralExitFeeBumpPackages: () => constructUnilateralExitFeeBumpPackages,
-  constructUnilateralExitTxs: () => constructUnilateralExitTxs,
-  createRefundTx: () => createRefundTx,
-  createSigningCommitment: () => createSigningCommitment,
-  createSigningNonce: () => createSigningNonce,
-  decodeBytesToSigningCommitment: () => decodeBytesToSigningCommitment,
-  decodeBytesToSigningNonce: () => decodeBytesToSigningNonce,
-  encodeSigningCommitmentToBytes: () => encodeSigningCommitmentToBytes,
-  encodeSigningNonceToBytes: () => encodeSigningNonceToBytes,
-  evaluatePolynomial: () => evaluatePolynomial,
-  fieldDiv: () => fieldDiv,
-  filterTokenBalanceForTokenPublicKey: () => filterTokenBalanceForTokenPublicKey,
-  generateAdaptorFromSignature: () => generateAdaptorFromSignature,
-  generatePolynomialForSecretSharing: () => generatePolynomialForSecretSharing,
-  generateSignatureFromExistingAdaptor: () => generateSignatureFromExistingAdaptor,
-  getCurrentTimelock: () => getCurrentTimelock,
-  getEphemeralAnchorOutput: () => getEphemeralAnchorOutput,
-  getLatestDepositTxId: () => getLatestDepositTxId,
-  getNetwork: () => getNetwork,
-  getNetworkFromAddress: () => getNetworkFromAddress,
-  getNetworkFromString: () => getNetworkFromString,
-  getNextTransactionSequence: () => getNextTransactionSequence,
-  getP2TRAddressFromPkScript: () => getP2TRAddressFromPkScript,
-  getP2TRAddressFromPublicKey: () => getP2TRAddressFromPublicKey,
-  getP2TRScriptFromPublicKey: () => getP2TRScriptFromPublicKey,
-  getP2WPKHAddressFromPublicKey: () => getP2WPKHAddressFromPublicKey,
-  getRandomBigInt: () => getRandomBigInt,
-  getRandomSigningNonce: () => getRandomSigningNonce,
-  getSigHashFromTx: () => getSigHashFromTx,
-  getSigningCommitmentFromNonce: () => getSigningCommitmentFromNonce,
-  getSparkAddressFromTaproot: () => getSparkAddressFromTaproot,
-  getTransactionSequence: () => getTransactionSequence,
-  getTransferPackageSigningPayload: () => getTransferPackageSigningPayload,
-  getTxFromRawTxBytes: () => getTxFromRawTxBytes,
-  getTxFromRawTxHex: () => getTxFromRawTxHex,
-  getTxId: () => getTxId,
-  getTxIdNoReverse: () => getTxIdNoReverse,
-  isEphemeralAnchorOutput: () => isEphemeralAnchorOutput,
-  isTxBroadcast: () => isTxBroadcast,
-  lastKeyWithTarget: () => lastKeyWithTarget,
-  maybeApplyFee: () => maybeApplyFee,
-  modInverse: () => modInverse,
-  proofOfPossessionMessageHashForDepositAddress: () => proofOfPossessionMessageHashForDepositAddress,
-  recoverSecret: () => recoverSecret,
-  splitSecret: () => splitSecret,
-  splitSecretWithProofs: () => splitSecretWithProofs,
-  subtractPrivateKeys: () => subtractPrivateKeys,
-  subtractPublicKeys: () => subtractPublicKeys,
-  sumOfPrivateKeys: () => sumOfPrivateKeys,
-  validateOutboundAdaptorSignature: () => validateOutboundAdaptorSignature,
-  validateShare: () => validateShare
-});
-module.exports = __toCommonJS(utils_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/utils/adaptor-signature.ts
-var import_modular = require("@noble/curves/abstract/modular");
-var import_utils2 = require("@noble/curves/abstract/utils");
-var import_secp256k1 = require("@noble/curves/secp256k1");
-
-// 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);
-  }
-};
-
-// src/utils/adaptor-signature.ts
-function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
-  const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils2.bytesToNumberBE)(s);
-  const tBigInt = (0, import_utils2.bytesToNumberBE)(adaptorPrivateKeyBytes);
-  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k1.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils2.numberToBytesBE)(newS, 32)]);
-  return newSignature;
-}
-function generateAdaptorFromSignature(signature) {
-  const adaptorPrivateKey = import_secp256k1.secp256k1.utils.randomPrivateKey();
-  const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils2.bytesToNumberBE)(s);
-  const tBigInt = (0, import_utils2.bytesToNumberBE)(adaptorPrivateKey);
-  const newS = (0, import_modular.mod)(sBigInt - tBigInt, import_secp256k1.secp256k1.CURVE.n);
-  const newSignature = new Uint8Array([...r, ...(0, import_utils2.numberToBytesBE)(newS, 32)]);
-  return {
-    adaptorSignature: newSignature,
-    adaptorPrivateKey
-  };
-}
-function validateOutboundAdaptorSignature(pubkey, hash, signature, adaptorPubkey) {
-  return schnorrVerifyWithAdaptor(
-    signature,
-    hash,
-    pubkey,
-    adaptorPubkey,
-    false
-  );
-}
-function applyAdaptorToSignature(pubkey, hash, signature, adaptorPrivateKeyBytes) {
-  const { r, s } = parseSignature(signature);
-  const sBigInt = (0, import_utils2.bytesToNumberBE)(s);
-  const adaptorPrivateKey = (0, import_utils2.bytesToNumberBE)(adaptorPrivateKeyBytes);
-  const newS = (0, import_modular.mod)(sBigInt + adaptorPrivateKey, import_secp256k1.secp256k1.CURVE.n);
-  const newSig = new Uint8Array([...r, ...(0, import_utils2.numberToBytesBE)(newS, 32)]);
-  if (import_secp256k1.schnorr.verify(newSig, hash, pubkey)) {
-    return newSig;
-  }
-  const altS = (0, import_modular.mod)(sBigInt - adaptorPrivateKey, import_secp256k1.secp256k1.CURVE.n);
-  const altSig = new Uint8Array([...r, ...(0, import_utils2.numberToBytesBE)(altS, 32)]);
-  if (import_secp256k1.schnorr.verify(altSig, hash, pubkey)) {
-    return altSig;
-  }
-  throw new Error("Cannot apply adaptor to signature");
-}
-function schnorrVerifyWithAdaptor(signature, hash, pubKeyBytes, adaptorPubkey, inbound) {
-  if (hash.length !== 32) {
-    throw new Error(`wrong size for message (got ${hash.length}, want 32)`);
-  }
-  const pubKey = import_secp256k1.schnorr.utils.lift_x((0, import_utils2.bytesToNumberBE)(pubKeyBytes));
-  pubKey.assertValidity();
-  const { r, s } = parseSignature(signature);
-  const commitmenet = import_secp256k1.schnorr.utils.taggedHash(
-    "BIP0340/challenge",
-    r,
-    pubKey.toRawBytes().slice(1),
-    hash
-  );
-  if (commitmenet.length > 32) {
-    throw new Error("hash of (r || P || m) too big");
-  }
-  const e = (0, import_modular.mod)((0, import_utils2.bytesToNumberBE)(commitmenet), import_secp256k1.secp256k1.CURVE.n);
-  const negE = (0, import_modular.mod)(-e, import_secp256k1.secp256k1.CURVE.n);
-  const R = import_secp256k1.secp256k1.ProjectivePoint.BASE.multiplyAndAddUnsafe(
-    pubKey,
-    (0, import_utils2.bytesToNumberBE)(s),
-    negE
-  );
-  if (!R) {
-    throw new Error("R is undefined");
-  }
-  R.assertValidity();
-  const adaptorPoint = import_secp256k1.secp256k1.ProjectivePoint.fromHex(adaptorPubkey);
-  const newR = R.add(adaptorPoint);
-  if (!inbound && newR.equals(import_secp256k1.secp256k1.ProjectivePoint.ZERO)) {
-    throw new Error("calculated R point is the point at infinity");
-  }
-  newR.assertValidity();
-  if (!newR.hasEvenY()) {
-    throw new Error("calculated R y-value is odd");
-  }
-  const rNum = (0, import_utils2.bytesToNumberBE)(r);
-  if (newR.toAffine().x !== rNum) {
-    throw new Error("calculated R point was not given R");
-  }
-  return true;
-}
-function parseSignature(signature) {
-  if (signature.length < 64) {
-    throw new ValidationError("Signature too short", {
-      expectedLength: 64,
-      actualLength: signature.length
-    });
-  }
-  if (signature.length > 64) {
-    throw new ValidationError("Signature too long", {
-      expectedLength: 64,
-      actualLength: signature.length
-    });
-  }
-  const r = signature.slice(0, 32);
-  const s = signature.slice(32, 64);
-  if ((0, import_utils2.bytesToNumberBE)(r) >= import_secp256k1.secp256k1.CURVE.Fp.ORDER) {
-    throw new ValidationError("Invalid signature: r >= field prime", {
-      rValue: (0, import_utils2.bytesToNumberBE)(r),
-      fieldPrime: import_secp256k1.secp256k1.CURVE.Fp.ORDER
-    });
-  }
-  if ((0, import_utils2.bytesToNumberBE)(s) >= import_secp256k1.secp256k1.CURVE.n) {
-    throw new ValidationError("Invalid signature: s >= group order", {
-      sValue: (0, import_utils2.bytesToNumberBE)(s),
-      groupOrder: import_secp256k1.secp256k1.CURVE.n
-    });
-  }
-  return { r, s };
-}
-
-// src/utils/bitcoin.ts
-var import_utils3 = require("@noble/curves/abstract/utils");
-var import_secp256k12 = require("@noble/curves/secp256k1");
-var import_sha2 = require("@noble/hashes/sha2");
-var btc2 = __toESM(require("@scure/btc-signer"), 1);
-
-// src/utils/network.ts
-var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
-var btc = __toESM(require("@scure/btc-signer"), 1);
-var bitcoin = __toESM(require("bitcoinjs-lib"), 1);
-
-// src/proto/spark.ts
-var import_wire4 = require("@bufbuild/protobuf/wire");
-
-// src/proto/common.ts
-var import_wire = require("@bufbuild/protobuf/wire");
-
-// src/proto/google/protobuf/empty.ts
-var import_wire2 = require("@bufbuild/protobuf/wire");
-
-// src/proto/google/protobuf/timestamp.ts
-var import_wire3 = require("@bufbuild/protobuf/wire");
-function createBaseTimestamp() {
-  return { seconds: 0, nanos: 0 };
-}
-var Timestamp = {
-  encode(message, writer = new import_wire3.BinaryWriter()) {
-    if (message.seconds !== 0) {
-      writer.uint32(8).int64(message.seconds);
-    }
-    if (message.nanos !== 0) {
-      writer.uint32(16).int32(message.nanos);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof import_wire3.BinaryReader ? input : new import_wire3.BinaryReader(input);
-    const end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseTimestamp();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 8) {
-            break;
-          }
-          message.seconds = longToNumber(reader.int64());
-          continue;
-        }
-        case 2: {
-          if (tag !== 16) {
-            break;
-          }
-          message.nanos = reader.int32();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      seconds: isSet(object.seconds) ? globalThis.Number(object.seconds) : 0,
-      nanos: isSet(object.nanos) ? globalThis.Number(object.nanos) : 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.seconds !== 0) {
-      obj.seconds = Math.round(message.seconds);
-    }
-    if (message.nanos !== 0) {
-      obj.nanos = Math.round(message.nanos);
-    }
-    return obj;
-  },
-  create(base) {
-    return Timestamp.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseTimestamp();
-    message.seconds = object.seconds ?? 0;
-    message.nanos = object.nanos ?? 0;
-    return message;
-  }
-};
-function longToNumber(int64) {
-  const num = globalThis.Number(int64.toString());
-  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
-    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
-  }
-  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
-    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
-  }
-  return num;
-}
-function isSet(value) {
-  return value !== null && value !== void 0;
-}
-
-// src/proto/spark.ts
-function networkFromJSON(object) {
-  switch (object) {
-    case 0:
-    case "UNSPECIFIED":
-      return 0 /* UNSPECIFIED */;
-    case 1:
-    case "MAINNET":
-      return 1 /* MAINNET */;
-    case 2:
-    case "REGTEST":
-      return 2 /* REGTEST */;
-    case 3:
-    case "TESTNET":
-      return 3 /* TESTNET */;
-    case 4:
-    case "SIGNET":
-      return 4 /* SIGNET */;
-    case -1:
-    case "UNRECOGNIZED":
-    default:
-      return -1 /* UNRECOGNIZED */;
-  }
-}
-function networkToJSON(object) {
-  switch (object) {
-    case 0 /* UNSPECIFIED */:
-      return "UNSPECIFIED";
-    case 1 /* MAINNET */:
-      return "MAINNET";
-    case 2 /* REGTEST */:
-      return "REGTEST";
-    case 3 /* TESTNET */:
-      return "TESTNET";
-    case 4 /* SIGNET */:
-      return "SIGNET";
-    case -1 /* UNRECOGNIZED */:
-    default:
-      return "UNRECOGNIZED";
-  }
-}
-function createBaseSigningKeyshare() {
-  return { ownerIdentifiers: [], threshold: 0, publicKey: new Uint8Array(0), publicShares: {}, updatedTime: void 0 };
-}
-var SigningKeyshare = {
-  encode(message, writer = new import_wire4.BinaryWriter()) {
-    for (const v of message.ownerIdentifiers) {
-      writer.uint32(10).string(v);
-    }
-    if (message.threshold !== 0) {
-      writer.uint32(16).uint32(message.threshold);
-    }
-    if (message.publicKey.length !== 0) {
-      writer.uint32(26).bytes(message.publicKey);
-    }
-    Object.entries(message.publicShares).forEach(([key, value]) => {
-      SigningKeyshare_PublicSharesEntry.encode({ key, value }, writer.uint32(34).fork()).join();
-    });
-    if (message.updatedTime !== void 0) {
-      Timestamp.encode(toTimestamp(message.updatedTime), writer.uint32(42).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 = createBaseSigningKeyshare();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.ownerIdentifiers.push(reader.string());
-          continue;
-        }
-        case 2: {
-          if (tag !== 16) {
-            break;
-          }
-          message.threshold = reader.uint32();
-          continue;
-        }
-        case 3: {
-          if (tag !== 26) {
-            break;
-          }
-          message.publicKey = reader.bytes();
-          continue;
-        }
-        case 4: {
-          if (tag !== 34) {
-            break;
-          }
-          const entry4 = SigningKeyshare_PublicSharesEntry.decode(reader, reader.uint32());
-          if (entry4.value !== void 0) {
-            message.publicShares[entry4.key] = entry4.value;
-          }
-          continue;
-        }
-        case 5: {
-          if (tag !== 42) {
-            break;
-          }
-          message.updatedTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      ownerIdentifiers: globalThis.Array.isArray(object?.ownerIdentifiers) ? object.ownerIdentifiers.map((e) => globalThis.String(e)) : [],
-      threshold: isSet2(object.threshold) ? globalThis.Number(object.threshold) : 0,
-      publicKey: isSet2(object.publicKey) ? bytesFromBase64(object.publicKey) : new Uint8Array(0),
-      publicShares: isObject(object.publicShares) ? Object.entries(object.publicShares).reduce((acc, [key, value]) => {
-        acc[key] = bytesFromBase64(value);
-        return acc;
-      }, {}) : {},
-      updatedTime: isSet2(object.updatedTime) ? fromJsonTimestamp(object.updatedTime) : void 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.ownerIdentifiers?.length) {
-      obj.ownerIdentifiers = message.ownerIdentifiers;
-    }
-    if (message.threshold !== 0) {
-      obj.threshold = Math.round(message.threshold);
-    }
-    if (message.publicKey.length !== 0) {
-      obj.publicKey = base64FromBytes(message.publicKey);
-    }
-    if (message.publicShares) {
-      const entries = Object.entries(message.publicShares);
-      if (entries.length > 0) {
-        obj.publicShares = {};
-        entries.forEach(([k, v]) => {
-          obj.publicShares[k] = base64FromBytes(v);
-        });
-      }
-    }
-    if (message.updatedTime !== void 0) {
-      obj.updatedTime = message.updatedTime.toISOString();
-    }
-    return obj;
-  },
-  create(base) {
-    return SigningKeyshare.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseSigningKeyshare();
-    message.ownerIdentifiers = object.ownerIdentifiers?.map((e) => e) || [];
-    message.threshold = object.threshold ?? 0;
-    message.publicKey = object.publicKey ?? new Uint8Array(0);
-    message.publicShares = Object.entries(object.publicShares ?? {}).reduce(
-      (acc, [key, value]) => {
-        if (value !== void 0) {
-          acc[key] = value;
-        }
-        return acc;
-      },
-      {}
-    );
-    message.updatedTime = object.updatedTime ?? void 0;
-    return message;
-  }
-};
-function createBaseSigningKeyshare_PublicSharesEntry() {
-  return { key: "", value: new Uint8Array(0) };
-}
-var SigningKeyshare_PublicSharesEntry = {
-  encode(message, writer = new import_wire4.BinaryWriter()) {
-    if (message.key !== "") {
-      writer.uint32(10).string(message.key);
-    }
-    if (message.value.length !== 0) {
-      writer.uint32(18).bytes(message.value);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
-    const end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseSigningKeyshare_PublicSharesEntry();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.key = reader.string();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-          message.value = reader.bytes();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      key: isSet2(object.key) ? globalThis.String(object.key) : "",
-      value: isSet2(object.value) ? bytesFromBase64(object.value) : new Uint8Array(0)
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.key !== "") {
-      obj.key = message.key;
-    }
-    if (message.value.length !== 0) {
-      obj.value = base64FromBytes(message.value);
-    }
-    return obj;
-  },
-  create(base) {
-    return SigningKeyshare_PublicSharesEntry.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseSigningKeyshare_PublicSharesEntry();
-    message.key = object.key ?? "";
-    message.value = object.value ?? new Uint8Array(0);
-    return message;
-  }
-};
-function createBaseTreeNode() {
-  return {
-    id: "",
-    treeId: "",
-    value: 0,
-    parentNodeId: void 0,
-    nodeTx: new Uint8Array(0),
-    refundTx: new Uint8Array(0),
-    vout: 0,
-    verifyingPublicKey: new Uint8Array(0),
-    ownerIdentityPublicKey: new Uint8Array(0),
-    signingKeyshare: void 0,
-    status: "",
-    network: 0,
-    createdTime: void 0,
-    updatedTime: void 0,
-    ownerSigningPublicKey: new Uint8Array(0),
-    directTx: new Uint8Array(0),
-    directRefundTx: new Uint8Array(0),
-    directFromCpfpRefundTx: new Uint8Array(0)
-  };
-}
-var TreeNode = {
-  encode(message, writer = new import_wire4.BinaryWriter()) {
-    if (message.id !== "") {
-      writer.uint32(10).string(message.id);
-    }
-    if (message.treeId !== "") {
-      writer.uint32(18).string(message.treeId);
-    }
-    if (message.value !== 0) {
-      writer.uint32(24).uint64(message.value);
-    }
-    if (message.parentNodeId !== void 0) {
-      writer.uint32(34).string(message.parentNodeId);
-    }
-    if (message.nodeTx.length !== 0) {
-      writer.uint32(42).bytes(message.nodeTx);
-    }
-    if (message.refundTx.length !== 0) {
-      writer.uint32(50).bytes(message.refundTx);
-    }
-    if (message.vout !== 0) {
-      writer.uint32(56).uint32(message.vout);
-    }
-    if (message.verifyingPublicKey.length !== 0) {
-      writer.uint32(66).bytes(message.verifyingPublicKey);
-    }
-    if (message.ownerIdentityPublicKey.length !== 0) {
-      writer.uint32(74).bytes(message.ownerIdentityPublicKey);
-    }
-    if (message.signingKeyshare !== void 0) {
-      SigningKeyshare.encode(message.signingKeyshare, writer.uint32(82).fork()).join();
-    }
-    if (message.status !== "") {
-      writer.uint32(90).string(message.status);
-    }
-    if (message.network !== 0) {
-      writer.uint32(96).int32(message.network);
-    }
-    if (message.createdTime !== void 0) {
-      Timestamp.encode(toTimestamp(message.createdTime), writer.uint32(106).fork()).join();
-    }
-    if (message.updatedTime !== void 0) {
-      Timestamp.encode(toTimestamp(message.updatedTime), writer.uint32(114).fork()).join();
-    }
-    if (message.ownerSigningPublicKey.length !== 0) {
-      writer.uint32(122).bytes(message.ownerSigningPublicKey);
-    }
-    if (message.directTx.length !== 0) {
-      writer.uint32(130).bytes(message.directTx);
-    }
-    if (message.directRefundTx.length !== 0) {
-      writer.uint32(138).bytes(message.directRefundTx);
-    }
-    if (message.directFromCpfpRefundTx.length !== 0) {
-      writer.uint32(146).bytes(message.directFromCpfpRefundTx);
-    }
-    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 = createBaseTreeNode();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.id = reader.string();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-          message.treeId = reader.string();
-          continue;
-        }
-        case 3: {
-          if (tag !== 24) {
-            break;
-          }
-          message.value = longToNumber2(reader.uint64());
-          continue;
-        }
-        case 4: {
-          if (tag !== 34) {
-            break;
-          }
-          message.parentNodeId = reader.string();
-          continue;
-        }
-        case 5: {
-          if (tag !== 42) {
-            break;
-          }
-          message.nodeTx = reader.bytes();
-          continue;
-        }
-        case 6: {
-          if (tag !== 50) {
-            break;
-          }
-          message.refundTx = reader.bytes();
-          continue;
-        }
-        case 7: {
-          if (tag !== 56) {
-            break;
-          }
-          message.vout = reader.uint32();
-          continue;
-        }
-        case 8: {
-          if (tag !== 66) {
-            break;
-          }
-          message.verifyingPublicKey = reader.bytes();
-          continue;
-        }
-        case 9: {
-          if (tag !== 74) {
-            break;
-          }
-          message.ownerIdentityPublicKey = reader.bytes();
-          continue;
-        }
-        case 10: {
-          if (tag !== 82) {
-            break;
-          }
-          message.signingKeyshare = SigningKeyshare.decode(reader, reader.uint32());
-          continue;
-        }
-        case 11: {
-          if (tag !== 90) {
-            break;
-          }
-          message.status = reader.string();
-          continue;
-        }
-        case 12: {
-          if (tag !== 96) {
-            break;
-          }
-          message.network = reader.int32();
-          continue;
-        }
-        case 13: {
-          if (tag !== 106) {
-            break;
-          }
-          message.createdTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
-          continue;
-        }
-        case 14: {
-          if (tag !== 114) {
-            break;
-          }
-          message.updatedTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
-          continue;
-        }
-        case 15: {
-          if (tag !== 122) {
-            break;
-          }
-          message.ownerSigningPublicKey = reader.bytes();
-          continue;
-        }
-        case 16: {
-          if (tag !== 130) {
-            break;
-          }
-          message.directTx = reader.bytes();
-          continue;
-        }
-        case 17: {
-          if (tag !== 138) {
-            break;
-          }
-          message.directRefundTx = reader.bytes();
-          continue;
-        }
-        case 18: {
-          if (tag !== 146) {
-            break;
-          }
-          message.directFromCpfpRefundTx = reader.bytes();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      id: isSet2(object.id) ? globalThis.String(object.id) : "",
-      treeId: isSet2(object.treeId) ? globalThis.String(object.treeId) : "",
-      value: isSet2(object.value) ? globalThis.Number(object.value) : 0,
-      parentNodeId: isSet2(object.parentNodeId) ? globalThis.String(object.parentNodeId) : void 0,
-      nodeTx: isSet2(object.nodeTx) ? bytesFromBase64(object.nodeTx) : new Uint8Array(0),
-      refundTx: isSet2(object.refundTx) ? bytesFromBase64(object.refundTx) : new Uint8Array(0),
-      vout: isSet2(object.vout) ? globalThis.Number(object.vout) : 0,
-      verifyingPublicKey: isSet2(object.verifyingPublicKey) ? bytesFromBase64(object.verifyingPublicKey) : new Uint8Array(0),
-      ownerIdentityPublicKey: isSet2(object.ownerIdentityPublicKey) ? bytesFromBase64(object.ownerIdentityPublicKey) : new Uint8Array(0),
-      signingKeyshare: isSet2(object.signingKeyshare) ? SigningKeyshare.fromJSON(object.signingKeyshare) : void 0,
-      status: isSet2(object.status) ? globalThis.String(object.status) : "",
-      network: isSet2(object.network) ? networkFromJSON(object.network) : 0,
-      createdTime: isSet2(object.createdTime) ? fromJsonTimestamp(object.createdTime) : void 0,
-      updatedTime: isSet2(object.updatedTime) ? fromJsonTimestamp(object.updatedTime) : void 0,
-      ownerSigningPublicKey: isSet2(object.ownerSigningPublicKey) ? bytesFromBase64(object.ownerSigningPublicKey) : new Uint8Array(0),
-      directTx: isSet2(object.directTx) ? bytesFromBase64(object.directTx) : new Uint8Array(0),
-      directRefundTx: isSet2(object.directRefundTx) ? bytesFromBase64(object.directRefundTx) : new Uint8Array(0),
-      directFromCpfpRefundTx: isSet2(object.directFromCpfpRefundTx) ? bytesFromBase64(object.directFromCpfpRefundTx) : new Uint8Array(0)
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.id !== "") {
-      obj.id = message.id;
-    }
-    if (message.treeId !== "") {
-      obj.treeId = message.treeId;
-    }
-    if (message.value !== 0) {
-      obj.value = Math.round(message.value);
-    }
-    if (message.parentNodeId !== void 0) {
-      obj.parentNodeId = message.parentNodeId;
-    }
-    if (message.nodeTx.length !== 0) {
-      obj.nodeTx = base64FromBytes(message.nodeTx);
-    }
-    if (message.refundTx.length !== 0) {
-      obj.refundTx = base64FromBytes(message.refundTx);
-    }
-    if (message.vout !== 0) {
-      obj.vout = Math.round(message.vout);
-    }
-    if (message.verifyingPublicKey.length !== 0) {
-      obj.verifyingPublicKey = base64FromBytes(message.verifyingPublicKey);
-    }
-    if (message.ownerIdentityPublicKey.length !== 0) {
-      obj.ownerIdentityPublicKey = base64FromBytes(message.ownerIdentityPublicKey);
-    }
-    if (message.signingKeyshare !== void 0) {
-      obj.signingKeyshare = SigningKeyshare.toJSON(message.signingKeyshare);
-    }
-    if (message.status !== "") {
-      obj.status = message.status;
-    }
-    if (message.network !== 0) {
-      obj.network = networkToJSON(message.network);
-    }
-    if (message.createdTime !== void 0) {
-      obj.createdTime = message.createdTime.toISOString();
-    }
-    if (message.updatedTime !== void 0) {
-      obj.updatedTime = message.updatedTime.toISOString();
-    }
-    if (message.ownerSigningPublicKey.length !== 0) {
-      obj.ownerSigningPublicKey = base64FromBytes(message.ownerSigningPublicKey);
-    }
-    if (message.directTx.length !== 0) {
-      obj.directTx = base64FromBytes(message.directTx);
-    }
-    if (message.directRefundTx.length !== 0) {
-      obj.directRefundTx = base64FromBytes(message.directRefundTx);
-    }
-    if (message.directFromCpfpRefundTx.length !== 0) {
-      obj.directFromCpfpRefundTx = base64FromBytes(message.directFromCpfpRefundTx);
-    }
-    return obj;
-  },
-  create(base) {
-    return TreeNode.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseTreeNode();
-    message.id = object.id ?? "";
-    message.treeId = object.treeId ?? "";
-    message.value = object.value ?? 0;
-    message.parentNodeId = object.parentNodeId ?? void 0;
-    message.nodeTx = object.nodeTx ?? new Uint8Array(0);
-    message.refundTx = object.refundTx ?? new Uint8Array(0);
-    message.vout = object.vout ?? 0;
-    message.verifyingPublicKey = object.verifyingPublicKey ?? new Uint8Array(0);
-    message.ownerIdentityPublicKey = object.ownerIdentityPublicKey ?? new Uint8Array(0);
-    message.signingKeyshare = object.signingKeyshare !== void 0 && object.signingKeyshare !== null ? SigningKeyshare.fromPartial(object.signingKeyshare) : void 0;
-    message.status = object.status ?? "";
-    message.network = object.network ?? 0;
-    message.createdTime = object.createdTime ?? void 0;
-    message.updatedTime = object.updatedTime ?? void 0;
-    message.ownerSigningPublicKey = object.ownerSigningPublicKey ?? new Uint8Array(0);
-    message.directTx = object.directTx ?? new Uint8Array(0);
-    message.directRefundTx = object.directRefundTx ?? new Uint8Array(0);
-    message.directFromCpfpRefundTx = object.directFromCpfpRefundTx ?? new Uint8Array(0);
-    return message;
-  }
-};
-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: isSet2(object.identityPublicKey) ? bytesFromBase64(object.identityPublicKey) : new Uint8Array(0),
-      paymentIntentFields: isSet2(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: isSet2(object.id) ? bytesFromBase64(object.id) : new Uint8Array(0),
-      assetIdentifier: isSet2(object.assetIdentifier) ? bytesFromBase64(object.assetIdentifier) : void 0,
-      assetAmount: isSet2(object.assetAmount) ? bytesFromBase64(object.assetAmount) : new Uint8Array(0),
-      memo: isSet2(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 toTimestamp(date) {
-  const seconds = Math.trunc(date.getTime() / 1e3);
-  const nanos = date.getTime() % 1e3 * 1e6;
-  return { seconds, nanos };
-}
-function fromTimestamp(t) {
-  let millis = (t.seconds || 0) * 1e3;
-  millis += (t.nanos || 0) / 1e6;
-  return new globalThis.Date(millis);
-}
-function fromJsonTimestamp(o) {
-  if (o instanceof globalThis.Date) {
-    return o;
-  } else if (typeof o === "string") {
-    return new globalThis.Date(o);
-  } else {
-    return fromTimestamp(Timestamp.fromJSON(o));
-  }
-}
-function longToNumber2(int64) {
-  const num = globalThis.Number(int64.toString());
-  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
-    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
-  }
-  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
-    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
-  }
-  return num;
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function isSet2(value) {
-  return value !== null && value !== void 0;
-}
-
-// src/graphql/objects/BitcoinNetwork.ts
-var BitcoinNetwork = /* @__PURE__ */ ((BitcoinNetwork2) => {
-  BitcoinNetwork2["FUTURE_VALUE"] = "FUTURE_VALUE";
-  BitcoinNetwork2["MAINNET"] = "MAINNET";
-  BitcoinNetwork2["REGTEST"] = "REGTEST";
-  BitcoinNetwork2["SIGNET"] = "SIGNET";
-  BitcoinNetwork2["TESTNET"] = "TESTNET";
-  return BitcoinNetwork2;
-})(BitcoinNetwork || {});
-var BitcoinNetwork_default = BitcoinNetwork;
-
-// src/utils/network.ts
-var Network2 = /* @__PURE__ */ ((Network4) => {
-  Network4[Network4["MAINNET"] = 0] = "MAINNET";
-  Network4[Network4["TESTNET"] = 1] = "TESTNET";
-  Network4[Network4["SIGNET"] = 2] = "SIGNET";
-  Network4[Network4["REGTEST"] = 3] = "REGTEST";
-  Network4[Network4["LOCAL"] = 4] = "LOCAL";
-  return Network4;
-})(Network2 || {});
-var NetworkToProto = {
-  [0 /* MAINNET */]: 1 /* MAINNET */,
-  [1 /* TESTNET */]: 3 /* TESTNET */,
-  [2 /* SIGNET */]: 4 /* SIGNET */,
-  [3 /* REGTEST */]: 2 /* REGTEST */,
-  [4 /* LOCAL */]: 2 /* REGTEST */
-};
-var NetworkConfig = {
-  [0 /* MAINNET */]: btc.NETWORK,
-  [1 /* TESTNET */]: btc.TEST_NETWORK,
-  [2 /* SIGNET */]: btc.TEST_NETWORK,
-  [3 /* REGTEST */]: { ...btc.TEST_NETWORK, bech32: "bcrt" },
-  [4 /* LOCAL */]: { ...btc.TEST_NETWORK, bech32: "bcrt" }
-};
-var getNetwork = (network) => NetworkConfig[network];
-var LRC_WALLET_NETWORK = Object.freeze({
-  [0 /* MAINNET */]: bitcoin.networks.bitcoin,
-  [1 /* TESTNET */]: bitcoin.networks.testnet,
-  [2 /* SIGNET */]: bitcoin.networks.testnet,
-  [3 /* REGTEST */]: bitcoin.networks.regtest,
-  [4 /* LOCAL */]: bitcoin.networks.regtest
-});
-var LRC_WALLET_NETWORK_TYPE = Object.freeze({
-  [0 /* MAINNET */]: import_lrc20_sdk.NetworkType.MAINNET,
-  [1 /* TESTNET */]: import_lrc20_sdk.NetworkType.TESTNET,
-  [2 /* SIGNET */]: import_lrc20_sdk.NetworkType.TESTNET,
-  [3 /* REGTEST */]: import_lrc20_sdk.NetworkType.REGTEST,
-  [4 /* LOCAL */]: import_lrc20_sdk.NetworkType.LOCAL
-});
-function getNetworkFromAddress(address2) {
-  try {
-    const decoded = bitcoin.address.fromBech32(address2);
-    if (decoded.prefix === "bc") {
-      return "MAINNET" /* MAINNET */;
-    } else if (decoded.prefix === "bcrt") {
-      return "REGTEST" /* REGTEST */;
-    }
-  } catch (err) {
-    throw new ValidationError(
-      "Invalid Bitcoin address",
-      {
-        field: "address",
-        value: address2,
-        expected: "Valid Bech32 address with prefix 'bc' or 'bcrt'"
-      },
-      err instanceof Error ? err : void 0
-    );
-  }
-  return null;
-}
-function getNetworkFromString(network) {
-  const net = (network ?? "REGTEST").toUpperCase();
-  if (net === "MAINNET") return 0 /* MAINNET */;
-  if (net === "TESTNET") return 1 /* TESTNET */;
-  if (net === "SIGNET") return 2 /* SIGNET */;
-  if (net === "LOCAL") return 4 /* LOCAL */;
-  return 3 /* REGTEST */;
-}
-
-// src/utils/bitcoin.ts
-function computeTaprootKeyNoScript(pubkey) {
-  if (pubkey.length !== 32) {
-    throw new ValidationError("Public key must be 32 bytes", {
-      field: "pubkey",
-      value: pubkey.length,
-      expected: 32
-    });
-  }
-  const taggedHash = import_secp256k12.schnorr.utils.taggedHash("TapTweak", pubkey);
-  const tweak = (0, import_utils3.bytesToNumberBE)(taggedHash);
-  const P = import_secp256k12.schnorr.utils.lift_x(import_secp256k12.schnorr.utils.bytesToNumberBE(pubkey));
-  const Q = P.add(import_secp256k12.secp256k1.ProjectivePoint.fromPrivateKey(tweak));
-  return Q.toRawBytes();
-}
-function getP2TRScriptFromPublicKey(pubKey, network) {
-  if (pubKey.length !== 33) {
-    throw new ValidationError("Public key must be 33 bytes", {
-      field: "pubKey",
-      value: pubKey.length,
-      expected: 33
-    });
-  }
-  const internalKey = import_secp256k12.secp256k1.ProjectivePoint.fromHex(pubKey);
-  const script = btc2.p2tr(
-    internalKey.toRawBytes().slice(1, 33),
-    void 0,
-    getNetwork(network)
-  ).script;
-  if (!script) {
-    throw new ValidationError("Failed to get P2TR script", {
-      field: "script",
-      value: "null"
-    });
-  }
-  return script;
-}
-function getP2TRAddressFromPublicKey(pubKey, network) {
-  if (pubKey.length !== 33) {
-    throw new ValidationError("Public key must be 33 bytes", {
-      field: "pubKey",
-      value: pubKey.length,
-      expected: 33
-    });
-  }
-  const internalKey = import_secp256k12.secp256k1.ProjectivePoint.fromHex(pubKey);
-  const address2 = btc2.p2tr(
-    internalKey.toRawBytes().slice(1, 33),
-    void 0,
-    getNetwork(network)
-  ).address;
-  if (!address2) {
-    throw new ValidationError("Failed to get P2TR address", {
-      field: "address",
-      value: "null"
-    });
-  }
-  return address2;
-}
-function getP2TRAddressFromPkScript(pkScript, network) {
-  if (pkScript.length !== 34 || pkScript[0] !== 81 || pkScript[1] !== 32) {
-    throw new ValidationError("Invalid pkscript", {
-      field: "pkScript",
-      value: (0, import_utils3.bytesToHex)(pkScript),
-      expected: "34 bytes starting with 0x51 0x20"
-    });
-  }
-  const parsedScript = btc2.OutScript.decode(pkScript);
-  return btc2.Address(getNetwork(network)).encode(parsedScript);
-}
-function getP2WPKHAddressFromPublicKey(pubKey, network) {
-  if (pubKey.length !== 33) {
-    throw new ValidationError("Public key must be 33 bytes", {
-      field: "pubKey",
-      value: pubKey.length,
-      expected: 33
-    });
-  }
-  const address2 = btc2.p2wpkh(pubKey, getNetwork(network)).address;
-  if (!address2) {
-    throw new ValidationError("Failed to get P2WPKH address", {
-      field: "address",
-      value: "null"
-    });
-  }
-  return address2;
-}
-function getTxFromRawTxHex(rawTxHex) {
-  const txBytes = (0, import_utils3.hexToBytes)(rawTxHex);
-  const tx = btc2.Transaction.fromRaw(txBytes, {
-    allowUnknownOutputs: true
-  });
-  if (!tx) {
-    throw new ValidationError("Failed to parse transaction", {
-      field: "tx",
-      value: "null"
-    });
-  }
-  return tx;
-}
-function getTxFromRawTxBytes(rawTxBytes) {
-  const tx = btc2.Transaction.fromRaw(rawTxBytes, {
-    allowUnknownOutputs: true
-  });
-  if (!tx) {
-    throw new ValidationError("Failed to parse transaction", {
-      field: "tx",
-      value: "null"
-    });
-  }
-  return tx;
-}
-function getSigHashFromTx(tx, inputIndex, prevOutput) {
-  const prevScript = prevOutput.script;
-  if (!prevScript) {
-    throw new ValidationError("No script found in prevOutput", {
-      field: "prevScript",
-      value: "null"
-    });
-  }
-  const amount = prevOutput.amount;
-  if (!amount) {
-    throw new ValidationError("No amount found in prevOutput", {
-      field: "amount",
-      value: "null"
-    });
-  }
-  return tx.preimageWitnessV1(
-    inputIndex,
-    new Array(tx.inputsLength).fill(prevScript),
-    btc2.SigHash.DEFAULT,
-    new Array(tx.inputsLength).fill(amount)
-  );
-}
-function getTxId(tx) {
-  return (0, import_utils3.bytesToHex)((0, import_sha2.sha256)((0, import_sha2.sha256)(tx.toBytes(true))).reverse());
-}
-function getTxIdNoReverse(tx) {
-  return (0, import_utils3.bytesToHex)((0, import_sha2.sha256)((0, import_sha2.sha256)(tx.toBytes(true))));
-}
-
-// src/utils/keys.ts
-var import_utils4 = require("@noble/curves/abstract/utils");
-var import_secp256k13 = require("@noble/curves/secp256k1");
-function addPublicKeys(a, b) {
-  if (a.length !== 33 || b.length !== 33) {
-    throw new ValidationError("Public keys must be 33 bytes", {
-      field: "publicKeys",
-      value: `a: ${a.length}, b: ${b.length}`,
-      expected: 33
-    });
-  }
-  const pubkeyA = import_secp256k13.secp256k1.ProjectivePoint.fromHex(a);
-  const pubkeyB = import_secp256k13.secp256k1.ProjectivePoint.fromHex(b);
-  return pubkeyA.add(pubkeyB).toRawBytes(true);
-}
-function applyAdditiveTweakToPublicKey(pubkey, tweak) {
-  if (pubkey.length !== 33) {
-    throw new ValidationError("Public key must be 33 bytes", {
-      field: "pubkey",
-      value: pubkey.length,
-      expected: 33
-    });
-  }
-  if (tweak.length !== 32) {
-    throw new ValidationError("Tweak must be 32 bytes", {
-      field: "tweak",
-      value: tweak.length,
-      expected: 32
-    });
-  }
-  const pubkeyPoint = import_secp256k13.secp256k1.ProjectivePoint.fromHex(pubkey);
-  const privTweek = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(tweak);
-  const pubTweek = import_secp256k13.secp256k1.getPublicKey(privTweek, true);
-  const tweekPoint = import_secp256k13.secp256k1.ProjectivePoint.fromHex(pubTweek);
-  return pubkeyPoint.add(tweekPoint).toRawBytes(true);
-}
-function subtractPublicKeys(a, b) {
-  if (a.length !== 33 || b.length !== 33) {
-    throw new ValidationError("Public keys must be 33 bytes", {
-      field: "publicKeys",
-      value: `a: ${a.length}, b: ${b.length}`,
-      expected: 33
-    });
-  }
-  const pubkeyA = import_secp256k13.secp256k1.ProjectivePoint.fromHex(a);
-  const pubkeyB = import_secp256k13.secp256k1.ProjectivePoint.fromHex(b);
-  return pubkeyA.subtract(pubkeyB).toRawBytes(true);
-}
-function addPrivateKeys(a, b) {
-  if (a.length !== 32 || b.length !== 32) {
-    throw new ValidationError("Private keys must be 32 bytes", {
-      field: "privateKeys",
-      value: `a: ${a.length}, b: ${b.length}`,
-      expected: 32
-    });
-  }
-  const privA = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(a);
-  const privB = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(b);
-  const sum = (privA + privB) % import_secp256k13.secp256k1.CURVE.n;
-  return (0, import_utils4.numberToBytesBE)(sum, 32);
-}
-function subtractPrivateKeys(a, b) {
-  if (a.length !== 32 || b.length !== 32) {
-    throw new ValidationError("Private keys must be 32 bytes", {
-      field: "privateKeys",
-      value: `a: ${a.length}, b: ${b.length}`,
-      expected: 32
-    });
-  }
-  const privA = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(a);
-  const privB = import_secp256k13.secp256k1.utils.normPrivateKeyToScalar(b);
-  const sum = (import_secp256k13.secp256k1.CURVE.n - privB + privA) % import_secp256k13.secp256k1.CURVE.n;
-  return (0, import_utils4.numberToBytesBE)(sum, 32);
-}
-function sumOfPrivateKeys(keys) {
-  return keys.reduce((sum, key) => {
-    if (key.length !== 32) {
-      throw new ValidationError("Private keys must be 32 bytes", {
-        field: "privateKey",
-        value: key.length,
-        expected: 32
-      });
-    }
-    return addPrivateKeys(sum, key);
-  });
-}
-function lastKeyWithTarget(target, keys) {
-  if (target.length !== 32) {
-    throw new ValidationError("Target must be 32 bytes", {
-      field: "target",
-      value: target.length,
-      expected: 32
-    });
-  }
-  const sum = sumOfPrivateKeys(keys);
-  return subtractPrivateKeys(target, sum);
-}
-
-// src/tests/isHermeticTest.ts
-var import_core = require("@lightsparkdev/core");
-var import_fs = __toESM(require("fs"), 1);
-function isHermeticTest() {
-  if (import_core.isNode) {
-    return (import_fs.default?.existsSync?.("/tmp/spark_hermetic") ?? false) || process.env.HERMETIC_TEST === "true";
-  }
-  return typeof process !== "undefined" && process.env?.HERMETIC_TEST === "true" || false;
-}
-
-// src/services/wallet-config.ts
-var SSP_IDENTITY_PUBLIC_KEYS = {
-  LOCAL: "028c094a432d46a0ac95349d792c2e3730bd60c29188db716f56a99e39b95338b4",
-  REGTEST: {
-    PROD: "022bf283544b16c0622daecb79422007d167eca6ce9f0c98c0c49833b1f7170bfe"
-  },
-  MAINNET: {
-    PROD: "023e33e2920326f64ea31058d44777442d97d7d5cbfcf54e3060bc1695e5261c93"
-  }
-};
-var URL_CONFIG = {
-  LOCAL: {
-    SSP: "http://127.0.0.1:5000",
-    ELECTRS: "http://127.0.0.1:30000",
-    LRC20: "http://127.0.0.1:18530",
-    LRC20_NODE: "http://127.0.0.1:18332"
-  },
-  REGTEST: {
-    PROD: {
-      SSP: "https://api.lightspark.com",
-      ELECTRS: "https://regtest-mempool.us-west-2.sparkinfra.net/api",
-      LRC20: "https://regtest.lrc20.lightspark.com:443",
-      LRC20_NODE: "https://regtest.lrc20.lightspark.com"
-    }
-  },
-  MAINNET: {
-    PROD: {
-      SSP: "https://api.lightspark.com",
-      ELECTRS: "https://mempool.space/api",
-      LRC20: "https://mainnet.lrc20.lightspark.com:443",
-      LRC20_NODE: "https://mainnet.lrc20.lightspark.com"
-    }
-  }
-};
-var ELECTRS_CREDENTIALS = {
-  username: "spark-sdk",
-  password: "mCMk1JqlBNtetUNy"
-};
-function getElectrsUrl(network) {
-  switch (network) {
-    case "LOCAL":
-      return isHermeticTest() ? "http://mempool.minikube.local/api" : URL_CONFIG.LOCAL.ELECTRS;
-    case "REGTEST":
-      return URL_CONFIG.REGTEST.PROD.ELECTRS;
-    case "MAINNET":
-      return URL_CONFIG.MAINNET.PROD.ELECTRS;
-    default:
-      return URL_CONFIG.LOCAL.ELECTRS;
-  }
-}
-function getLrc20Url(network) {
-  switch (network) {
-    case "LOCAL":
-      return URL_CONFIG.LOCAL.LRC20;
-    case "REGTEST":
-      return URL_CONFIG.REGTEST.PROD.LRC20;
-    case "MAINNET":
-      return URL_CONFIG.MAINNET.PROD.LRC20;
-    default:
-      return URL_CONFIG.LOCAL.LRC20;
-  }
-}
-function getLrc20NodeUrl(network) {
-  switch (network) {
-    case "LOCAL":
-      return URL_CONFIG.LOCAL.LRC20_NODE;
-    case "REGTEST":
-      return URL_CONFIG.REGTEST.PROD.LRC20_NODE;
-    case "MAINNET":
-      return URL_CONFIG.MAINNET.PROD.LRC20_NODE;
-    default:
-      return URL_CONFIG.LOCAL.LRC20_NODE;
-  }
-}
-function getSspIdentityPublicKey(network) {
-  switch (network) {
-    case "LOCAL":
-      return SSP_IDENTITY_PUBLIC_KEYS.LOCAL;
-    case "REGTEST":
-      return SSP_IDENTITY_PUBLIC_KEYS.REGTEST.PROD;
-    case "MAINNET":
-      return SSP_IDENTITY_PUBLIC_KEYS.MAINNET.PROD;
-    default:
-      return SSP_IDENTITY_PUBLIC_KEYS.LOCAL;
-  }
-}
-function getSspUrl(network) {
-  switch (network) {
-    case "LOCAL":
-      return isHermeticTest() ? "http://app.minikube.local" : URL_CONFIG.LOCAL.SSP;
-    case "REGTEST":
-      return URL_CONFIG.REGTEST.PROD.SSP;
-    case "MAINNET":
-      return URL_CONFIG.MAINNET.PROD.SSP;
-    default:
-      return URL_CONFIG.LOCAL.SSP;
-  }
-}
-function getSspSchemaEndpoint(network) {
-  switch (network) {
-    case "LOCAL":
-      return "graphql/spark/rc";
-  }
-  return;
-}
-var PROD_PUBKEYS = [
-  "03dfbdff4b6332c220f8fa2ba8ed496c698ceada563fa01b67d9983bfc5c95e763",
-  "03e625e9768651c9be268e287245cc33f96a68ce9141b0b4769205db027ee8ed77",
-  "022eda13465a59205413086130a65dc0ed1b8f8e51937043161f8be0c369b1a410"
-];
-function getLocalFrostSignerAddress() {
-  return isHermeticTest() ? "localhost:9999" : "unix:///tmp/frost_0.sock";
-}
-var BASE_CONFIG = {
-  network: "LOCAL",
-  lrc20Address: getLrc20Url("LOCAL"),
-  coodinatorIdentifier: "0000000000000000000000000000000000000000000000000000000000000001",
-  frostSignerAddress: getLocalFrostSignerAddress(),
-  threshold: 2,
-  signingOperators: getLocalSigningOperators(),
-  tokenSignatures: "SCHNORR",
-  tokenTransactionVersion: "V1",
-  tokenValidityDurationSeconds: 180,
-  electrsUrl: getElectrsUrl("LOCAL"),
-  expectedWithdrawBondSats: 1e4,
-  expectedWithdrawRelativeBlockLocktime: 1e3,
-  lrc20ApiConfig: {
-    electrsUrl: getElectrsUrl("LOCAL"),
-    lrc20NodeUrl: getLrc20NodeUrl("LOCAL"),
-    electrsCredentials: ELECTRS_CREDENTIALS
-  },
-  sspClientOptions: {
-    baseUrl: getSspUrl("LOCAL"),
-    identityPublicKey: getSspIdentityPublicKey("LOCAL"),
-    schemaEndpoint: getSspSchemaEndpoint("LOCAL")
-  }
-};
-var LOCAL_WALLET_CONFIG = {
-  ...BASE_CONFIG,
-  threshold: 3
-};
-var LOCAL_WALLET_CONFIG_SCHNORR = {
-  ...LOCAL_WALLET_CONFIG,
-  threshold: 3
-  // 3 for issuance tests.
-};
-var LOCAL_WALLET_CONFIG_ECDSA = {
-  ...LOCAL_WALLET_CONFIG,
-  tokenSignatures: "ECDSA",
-  threshold: 3
-  // 3 for issuance tests.
-};
-var REGTEST_WALLET_CONFIG = {
-  ...BASE_CONFIG,
-  network: "REGTEST",
-  lrc20Address: getLrc20Url("REGTEST"),
-  signingOperators: getSigningOperators(),
-  electrsUrl: getElectrsUrl("REGTEST"),
-  lrc20ApiConfig: {
-    electrsUrl: getElectrsUrl("REGTEST"),
-    lrc20NodeUrl: getLrc20NodeUrl("REGTEST"),
-    electrsCredentials: ELECTRS_CREDENTIALS
-  },
-  expectedWithdrawBondSats: 1e4,
-  expectedWithdrawRelativeBlockLocktime: 1e3,
-  sspClientOptions: {
-    baseUrl: getSspUrl("REGTEST"),
-    identityPublicKey: getSspIdentityPublicKey("REGTEST")
-  }
-};
-var MAINNET_WALLET_CONFIG = {
-  ...BASE_CONFIG,
-  network: "MAINNET",
-  lrc20Address: getLrc20Url("MAINNET"),
-  signingOperators: getSigningOperators(),
-  electrsUrl: getElectrsUrl("MAINNET"),
-  lrc20ApiConfig: {
-    electrsUrl: getElectrsUrl("MAINNET"),
-    lrc20NodeUrl: getLrc20NodeUrl("MAINNET")
-  },
-  expectedWithdrawBondSats: 1e4,
-  expectedWithdrawRelativeBlockLocktime: 1e3,
-  sspClientOptions: {
-    baseUrl: getSspUrl("MAINNET"),
-    identityPublicKey: getSspIdentityPublicKey("MAINNET")
-  }
-};
-function getSigningOperators() {
-  return {
-    "0000000000000000000000000000000000000000000000000000000000000001": {
-      id: 0,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000001",
-      address: "https://0.spark.lightspark.com",
-      identityPublicKey: PROD_PUBKEYS[0]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000002": {
-      id: 1,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000002",
-      address: "https://1.spark.lightspark.com",
-      identityPublicKey: PROD_PUBKEYS[1]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000003": {
-      id: 2,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000003",
-      address: "https://2.spark.flashnet.xyz",
-      identityPublicKey: PROD_PUBKEYS[2]
-    }
-  };
-}
-function getLocalSigningOperators() {
-  const pubkeys = [
-    "0322ca18fc489ae25418a0e768273c2c61cabb823edfb14feb891e9bec62016510",
-    "0341727a6c41b168f07eb50865ab8c397a53c7eef628ac1020956b705e43b6cb27",
-    "0305ab8d485cc752394de4981f8a5ae004f2becfea6f432c9a59d5022d8764f0a6",
-    "0352aef4d49439dedd798ac4aef1e7ebef95f569545b647a25338398c1247ffdea",
-    "02c05c88cc8fc181b1ba30006df6a4b0597de6490e24514fbdd0266d2b9cd3d0ba"
-  ];
-  return {
-    "0000000000000000000000000000000000000000000000000000000000000001": {
-      id: 0,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000001",
-      address: "https://localhost:8535",
-      identityPublicKey: pubkeys[0]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000002": {
-      id: 1,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000002",
-      address: "https://localhost:8536",
-      identityPublicKey: pubkeys[1]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000003": {
-      id: 2,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000003",
-      address: "https://localhost:8537",
-      identityPublicKey: pubkeys[2]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000004": {
-      id: 3,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000004",
-      address: "https://localhost:8538",
-      identityPublicKey: pubkeys[3]
-    },
-    "0000000000000000000000000000000000000000000000000000000000000005": {
-      id: 4,
-      identifier: "0000000000000000000000000000000000000000000000000000000000000005",
-      address: "https://localhost:8539",
-      identityPublicKey: pubkeys[4]
-    }
-  };
-}
-
-// src/graphql/objects/ClaimStaticDeposit.ts
-var import_core2 = require("@lightsparkdev/core");
-
-// src/graphql/objects/CoopExitFeeQuote.ts
-var import_core3 = require("@lightsparkdev/core");
-
-// src/graphql/objects/LeavesSwapRequest.ts
-var import_core4 = require("@lightsparkdev/core");
-
-// src/graphql/objects/LightningReceiveRequest.ts
-var import_core5 = require("@lightsparkdev/core");
-
-// src/graphql/objects/LightningSendRequest.ts
-var import_core6 = require("@lightsparkdev/core");
-
-// src/graphql/objects/SparkWalletUser.ts
-var import_core8 = require("@lightsparkdev/core");
-
-// src/graphql/objects/UserRequest.ts
-var import_core7 = require("@lightsparkdev/core");
-
-// src/types/sdk-types.ts
-var import_utils5 = require("@noble/curves/abstract/utils");
-
-// src/utils/mempool.ts
-async function getLatestDepositTxId(address2) {
-  const network = getNetworkFromAddress(address2);
-  const baseUrl = network === BitcoinNetwork_default.REGTEST ? getElectrsUrl("REGTEST") : getElectrsUrl("MAINNET");
-  const headers = {};
-  if (network === BitcoinNetwork_default.REGTEST) {
-    const auth = btoa(
-      `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
-    );
-    headers["Authorization"] = `Basic ${auth}`;
-  }
-  const response = await fetch(`${baseUrl}/address/${address2}/txs`, {
-    headers
-  });
-  const addressTxs = await response.json();
-  if (addressTxs && addressTxs.length > 0) {
-    const latestTx = addressTxs[0];
-    const outputIndex = latestTx.vout.findIndex(
-      (output) => output.scriptpubkey_address === address2
-    );
-    if (outputIndex === -1) {
-      return null;
-    }
-    return latestTx.txid;
-  }
-  return null;
-}
-async function isTxBroadcast(txid, baseUrl, network) {
-  const headers = {};
-  if (network === 3 /* REGTEST */) {
-    const auth = btoa(
-      `${ELECTRS_CREDENTIALS.username}:${ELECTRS_CREDENTIALS.password}`
-    );
-    headers["Authorization"] = `Basic ${auth}`;
-  }
-  const response = await fetch(`${baseUrl}/tx/${txid}`, {
-    headers
-  });
-  const tx = await response.json();
-  if (tx.error) {
-    return false;
-  }
-  return true;
-}
-
-// src/utils/proof.ts
-var import_sha22 = require("@noble/hashes/sha2");
-function proofOfPossessionMessageHashForDepositAddress(userPubkey, operatorPubkey, depositAddress) {
-  const encoder = new TextEncoder();
-  const depositAddressBytes = encoder.encode(depositAddress);
-  const proofMsg = new Uint8Array([
-    ...userPubkey,
-    ...operatorPubkey,
-    ...depositAddressBytes
-  ]);
-  return (0, import_sha22.sha256)(proofMsg);
-}
-
-// 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/secret-sharing.ts
-var import_utils6 = require("@noble/curves/abstract/utils");
-var import_secp256k14 = 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 getRandomBigInt(max) {
-  const byteLength = max.toString(2).length + 7 >> 3;
-  const maxBigInt = max;
-  const mask = (1n << BigInt(max.toString(2).length)) - 1n;
-  while (true) {
-    const randBytes = crypto.getRandomValues(new Uint8Array(byteLength + 1));
-    const randValue = BigInt("0x" + (0, import_utils6.bytesToHex)(randBytes)) & mask;
-    if (randValue < maxBigInt) {
-      return randValue;
-    }
-  }
-}
-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 evaluatePolynomial(polynomial, x) {
-  let result = 0n;
-  for (let i = 0; i < polynomial.coefficients.length; i++) {
-    const coeff = polynomial.coefficients[i];
-    if (!coeff) {
-      throw new ValidationError("Coefficient is undefined", {
-        field: "coefficient",
-        value: "undefined",
-        expected: "A valid bigint coefficient"
-      });
-    }
-    const xPow = x ** BigInt(i) % polynomial.fieldModulus;
-    result = (result + xPow * coeff) % polynomial.fieldModulus;
-  }
-  return result;
-}
-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 generatePolynomialForSecretSharing(fieldModulus, secret, degree) {
-  const coefficients = new Array(degree);
-  const proofs = new Array(degree);
-  coefficients[0] = secret;
-  proofs[0] = import_secp256k14.secp256k1.ProjectivePoint.fromPrivateKey(secret).toRawBytes(true);
-  for (let i = 1; i < degree; i++) {
-    const coefficient = getRandomBigInt(fieldModulus);
-    coefficients[i] = coefficient;
-    proofs[i] = import_secp256k14.secp256k1.ProjectivePoint.fromPrivateKey(coefficient).toRawBytes(true);
-  }
-  return {
-    fieldModulus,
-    coefficients,
-    proofs
-  };
-}
-function splitSecret(fieldModulus, secret, threshold, numberOfShares) {
-  const polynomial = generatePolynomialForSecretSharing(
-    fieldModulus,
-    secret,
-    threshold
-  );
-  const shares = [];
-  for (let i = 1; i <= numberOfShares; i++) {
-    const share = evaluatePolynomial(polynomial, BigInt(i));
-    shares.push({
-      fieldModulus,
-      threshold,
-      index: BigInt(i),
-      share
-    });
-  }
-  return shares;
-}
-function splitSecretWithProofs(secret, fieldModulus, threshold, numberOfShares) {
-  const polynomial = generatePolynomialForSecretSharing(
-    fieldModulus,
-    secret,
-    threshold
-  );
-  const shares = [];
-  for (let i = 1; i <= numberOfShares; i++) {
-    const share = evaluatePolynomial(polynomial, BigInt(i));
-    shares.push({
-      fieldModulus,
-      threshold,
-      index: BigInt(i),
-      share,
-      proofs: polynomial.proofs
-    });
-  }
-  return shares;
-}
-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 validateShare(share) {
-  const targetPubkey = import_secp256k14.secp256k1.ProjectivePoint.fromPrivateKey(
-    share.share
-  ).toRawBytes(true);
-  let resultPubkey = share.proofs[0];
-  if (!resultPubkey) {
-    throw new ValidationError("Result pubkey is not valid", {
-      field: "resultPubkey",
-      value: "null",
-      expected: "Valid public key bytes"
-    });
-  }
-  for (let i = 1; i < share.proofs.length; i++) {
-    const pubkey = share.proofs[i];
-    if (!pubkey) {
-      throw new ValidationError("Pubkey is not valid", {
-        field: "pubkey",
-        value: "null",
-        expected: "Valid public key bytes"
-      });
-    }
-    const value = share.index ** BigInt(i) % share.fieldModulus;
-    const scaledPoint = import_secp256k14.secp256k1.ProjectivePoint.fromHex(pubkey).multiply(value);
-    resultPubkey = import_secp256k14.secp256k1.ProjectivePoint.fromHex(resultPubkey).add(scaledPoint).toRawBytes(true);
-  }
-  if (!(0, import_utils6.equalBytes)(resultPubkey, targetPubkey)) {
-    throw new ValidationError("Share is not valid", {
-      field: "share",
-      value: "Invalid proof",
-      expected: "Valid share with matching proofs"
-    });
-  }
-}
-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/signing.ts
-var import_secp256k15 = require("@noble/curves/secp256k1");
-function getRandomSigningNonce() {
-  const binding = import_secp256k15.secp256k1.utils.randomPrivateKey();
-  const hiding = import_secp256k15.secp256k1.utils.randomPrivateKey();
-  return createSigningNonce(binding, hiding);
-}
-function createSigningNonce(binding, hiding) {
-  if (binding.length !== 32 || hiding.length !== 32) {
-    throw new ValidationError("Invalid nonce length", {
-      field: "nonce",
-      value: `binding: ${binding.length}, hiding: ${hiding.length}`,
-      expected: "Both binding and hiding should be 32 bytes"
-    });
-  }
-  return {
-    binding,
-    hiding
-  };
-}
-function getSigningCommitmentFromNonce(nonce) {
-  const bindingPubKey = import_secp256k15.secp256k1.getPublicKey(nonce.binding, true);
-  const hidingPubKey = import_secp256k15.secp256k1.getPublicKey(nonce.hiding, true);
-  return {
-    binding: bindingPubKey,
-    hiding: hidingPubKey
-  };
-}
-function encodeSigningNonceToBytes(nonce) {
-  return new Uint8Array([...nonce.binding, ...nonce.hiding]);
-}
-function decodeBytesToSigningNonce(bytes) {
-  if (bytes.length !== 64) {
-    throw new ValidationError("Invalid nonce length", {
-      field: "bytes",
-      value: bytes.length,
-      expected: "64 bytes (32 bytes for binding + 32 bytes for hiding)"
-    });
-  }
-  return {
-    binding: bytes.slice(32, 64),
-    hiding: bytes.slice(0, 32)
-  };
-}
-function createSigningCommitment(binding, hiding) {
-  if (binding.length !== 33 || hiding.length !== 33) {
-    throw new ValidationError("Invalid nonce commitment length", {
-      field: "commitment",
-      value: `binding: ${binding.length}, hiding: ${hiding.length}`,
-      expected: "Both binding and hiding should be 33 bytes (compressed public keys)"
-    });
-  }
-  return {
-    binding,
-    hiding
-  };
-}
-function encodeSigningCommitmentToBytes(commitment) {
-  if (commitment.binding.length !== 33 || commitment.hiding.length !== 33) {
-    throw new ValidationError("Invalid nonce commitment length", {
-      field: "commitment",
-      value: `binding: ${commitment.binding.length}, hiding: ${commitment.hiding.length}`,
-      expected: "Both binding and hiding should be 33 bytes (compressed public keys)"
-    });
-  }
-  return new Uint8Array([...commitment.binding, ...commitment.hiding]);
-}
-function decodeBytesToSigningCommitment(bytes) {
-  if (bytes.length !== 66) {
-    throw new ValidationError("Invalid nonce commitment length", {
-      field: "bytes",
-      value: bytes.length,
-      expected: "66 bytes (33 bytes for binding + 33 bytes for hiding)"
-    });
-  }
-  return {
-    binding: bytes.slice(33, 66),
-    hiding: bytes.slice(0, 33)
-  };
-}
-
-// src/utils/token-transactions.ts
-var import_utils7 = require("@noble/curves/abstract/utils");
-function calculateAvailableTokenAmount(outputLeaves) {
-  return outputLeaves.reduce(
-    (sum, output) => sum + BigInt((0, import_utils7.bytesToNumberBE)(output.output.tokenAmount)),
-    BigInt(0)
-  );
-}
-function checkIfSelectedOutputsAreAvailable(selectedOutputs, tokenOutputs, tokenPublicKey) {
-  const tokenPubKeyHex = (0, import_utils7.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;
-}
-function filterTokenBalanceForTokenPublicKey(tokenBalances, publicKey) {
-  if (!tokenBalances) {
-    return { balance: 0n };
-  }
-  const tokenBalance = [...tokenBalances.entries()].find(
-    ([, info]) => info.tokenMetadata.tokenPublicKey === publicKey
-  );
-  if (!tokenBalance) {
-    return {
-      balance: 0n
-    };
-  }
-  return {
-    balance: tokenBalance[1].balance
-  };
-}
-
-// src/utils/transfer_package.ts
-var import_utils8 = require("@noble/curves/abstract/utils");
-var import_sha23 = require("@noble/hashes/sha2");
-function getTransferPackageSigningPayload(transferID, transferPackage) {
-  const encryptedPayload = transferPackage.keyTweakPackage;
-  const pairs = Object.entries(
-    encryptedPayload
-  ).map(([key, value]) => ({ key, value }));
-  pairs.sort((a, b) => a.key.localeCompare(b.key));
-  const encoder = new TextEncoder();
-  let message = (0, import_utils8.hexToBytes)(transferID.replaceAll("-", ""));
-  for (const pair of pairs) {
-    const keyPart = encoder.encode(pair.key + ":");
-    const separator = encoder.encode(";");
-    message = new Uint8Array([
-      ...message,
-      ...keyPart,
-      ...pair.value,
-      ...separator
-    ]);
-  }
-  return (0, import_sha23.sha256)(message);
-}
-
-// src/utils/transaction.ts
-var import_btc_signer = require("@scure/btc-signer");
-var TIME_LOCK_INTERVAL = 100;
-var ESTIMATED_TX_SIZE = 191;
-var DEFAULT_SATS_PER_VBYTE = 5;
-var DEFAULT_FEE_SATS = ESTIMATED_TX_SIZE * DEFAULT_SATS_PER_VBYTE;
-function maybeApplyFee(amount) {
-  if (amount > BigInt(DEFAULT_FEE_SATS)) {
-    return amount - BigInt(DEFAULT_FEE_SATS);
-  }
-  return amount;
-}
-function createRefundTx(sequence, nodeOutPoint, amountSats, receivingPubkey, network) {
-  const newRefundTx = new import_btc_signer.Transaction({
-    version: 3,
-    allowUnknownOutputs: true
-  });
-  newRefundTx.addInput({
-    ...nodeOutPoint,
-    sequence
-  });
-  const refundPkScript = getP2TRScriptFromPublicKey(receivingPubkey, network);
-  newRefundTx.addOutput({
-    script: refundPkScript,
-    amount: amountSats
-  });
-  newRefundTx.addOutput(getEphemeralAnchorOutput());
-  return newRefundTx;
-}
-function getCurrentTimelock(currSequence) {
-  return (currSequence || 0) & 65535;
-}
-function getTransactionSequence(currSequence) {
-  const timelock = getCurrentTimelock(currSequence);
-  return 1 << 30 | timelock;
-}
-function checkIfValidSequence(currSequence) {
-  const TIME_LOCK_ACTIVE = (currSequence || 0) & 2147483648;
-  if (TIME_LOCK_ACTIVE !== 0) {
-    throw new ValidationError("Timelock not active", {
-      field: "currSequence",
-      value: currSequence
-    });
-  }
-  const RELATIVE_TIME_LOCK_ACTIVE = (currSequence || 0) & 4194304;
-  if (RELATIVE_TIME_LOCK_ACTIVE !== 0) {
-    throw new ValidationError("Block based timelock not active", {
-      field: "currSequence",
-      value: currSequence
-    });
-  }
-}
-function getNextTransactionSequence(currSequence, forRefresh) {
-  const currentTimelock = getCurrentTimelock(currSequence);
-  const nextTimelock = currentTimelock - TIME_LOCK_INTERVAL;
-  if (forRefresh && nextTimelock <= 100 && currentTimelock > 0) {
-    return {
-      nextSequence: 1 << 30 | nextTimelock,
-      needRefresh: true
-    };
-  }
-  if (nextTimelock < 0) {
-    throw new ValidationError("timelock interval is less than 0", {
-      field: "nextTimelock",
-      value: nextTimelock
-    });
-  }
-  return {
-    nextSequence: 1 << 30 | nextTimelock,
-    needRefresh: nextTimelock <= 100
-  };
-}
-function getEphemeralAnchorOutput() {
-  return {
-    script: new Uint8Array([81, 2, 78, 115]),
-    // Pay-to-anchor (P2A) ephemeral anchor output
-    amount: 0n
-  };
-}
-
-// src/utils/unilateral-exit.ts
-var import_utils9 = require("@noble/curves/abstract/utils");
-var import_legacy = require("@noble/hashes/legacy");
-var import_sha24 = require("@noble/hashes/sha2");
-var btc3 = __toESM(require("@scure/btc-signer"), 1);
-function isEphemeralAnchorOutput(script, amount) {
-  return Boolean(
-    amount === 0n && script && // Pattern 1: Bare OP_TRUE (single byte 0x51)
-    (script.length === 1 && script[0] === 81 || // Pattern 2: Push OP_TRUE (two bytes 0x01 0x51) - MALFORMED but we detect it
-    script.length === 2 && script[0] === 1 && script[1] === 81 || // Pattern 3: Bitcoin v29 ephemeral anchor script (7 bytes: 015152014e0173)
-    script.length === 7 && script[0] === 1 && script[1] === 81 && script[2] === 82 && script[3] === 1 && script[4] === 78 && script[5] === 1 && script[6] === 115 || // Pattern 4: Bitcoin ephemeral anchor OP_1 + push 2 bytes (4 bytes: 51024e73)
-    script.length === 4 && script[0] === 81 && script[1] === 2 && script[2] === 78 && script[3] === 115)
-  );
-}
-async function constructUnilateralExitTxs(nodeHexStrings, sparkClient, network) {
-  const result = [];
-  const nodes = nodeHexStrings.map((hex) => TreeNode.decode((0, import_utils9.hexToBytes)(hex)));
-  const nodeMap = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    nodeMap.set(node.id, node);
-  }
-  for (const node of nodes) {
-    const transactions = [];
-    const chain = [];
-    let currentNode = node;
-    while (currentNode) {
-      chain.unshift(currentNode);
-      if (currentNode.parentNodeId) {
-        let parentNode = nodeMap.get(currentNode.parentNodeId);
-        if (!parentNode && sparkClient) {
-          try {
-            const response = await sparkClient.query_nodes({
-              source: {
-                $case: "nodeIds",
-                nodeIds: {
-                  nodeIds: [currentNode.parentNodeId]
-                }
-              },
-              includeParents: true,
-              network: network || 0
-              // Default to mainnet if not provided
-            });
-            parentNode = response.nodes[currentNode.parentNodeId];
-            if (parentNode) {
-              nodeMap.set(currentNode.parentNodeId, parentNode);
-            }
-          } catch (error) {
-            console.warn(
-              `Failed to query parent node ${currentNode.parentNodeId}: ${error}`
-            );
-            break;
-          }
-        }
-        if (parentNode) {
-          currentNode = parentNode;
-        } else {
-          if (!sparkClient) {
-            console.warn(
-              `Parent node ${currentNode.parentNodeId} not found. Provide a sparkClient to fetch missing parents.`
-            );
-          } else {
-            console.warn(
-              `Parent node ${currentNode.parentNodeId} not found in database. Chain may be incomplete.`
-            );
-          }
-          break;
-        }
-      } else {
-        break;
-      }
-    }
-    for (const chainNode of chain) {
-      const nodeTx = (0, import_utils9.bytesToHex)(chainNode.nodeTx);
-      transactions.push(nodeTx);
-      if (chainNode.id === node.id) {
-        const refundTx = (0, import_utils9.bytesToHex)(chainNode.refundTx);
-        transactions.push(refundTx);
-      }
-    }
-    result.push({
-      leafId: node.id,
-      transactions
-    });
-  }
-  return result;
-}
-async function constructUnilateralExitFeeBumpPackages(nodeHexStrings, utxos, feeRate, electrsUrl, sparkClient, network) {
-  const result = [];
-  const availableUtxos = [...utxos].sort((a, b) => {
-    if (a.value > b.value) return -1;
-    if (a.value < b.value) return 1;
-    return 0;
-  });
-  const nodes = [];
-  for (let i = 0; i < nodeHexStrings.length; i++) {
-    const hex = nodeHexStrings[i];
-    try {
-      if (!hex || hex.length === 0) {
-        throw new Error(`Node hex string at index ${i} is empty`);
-      }
-      if (hex.startsWith("03000000") || hex.startsWith("02000000") || hex.startsWith("01000000")) {
-        throw new Error(
-          `Node hex string at index ${i} appears to be a raw transaction hex, not a TreeNode protobuf. Use 'leafidtohex' command to convert node IDs to proper hex strings.`
-        );
-      }
-      const nodeBytes = (0, import_utils9.hexToBytes)(hex);
-      const node = TreeNode.decode(nodeBytes);
-      if (!node.id) {
-        throw new Error(
-          `Decoded TreeNode at index ${i} is missing required 'id' field`
-        );
-      }
-      if (!node.nodeTx || node.nodeTx.length === 0) {
-        throw new Error(
-          `Decoded TreeNode at index ${i} is missing required 'nodeTx' field`
-        );
-      }
-      nodes.push(node);
-    } catch (decodeError) {
-      throw new Error(
-        `Failed to decode TreeNode hex string at index ${i}: ${decodeError}. Make sure you're providing TreeNode protobuf hex strings, not raw transaction hex. Use 'leafidtohex' command to get proper hex strings.`
-      );
-    }
-  }
-  const nodeMap = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    nodeMap.set(node.id, node);
-  }
-  const broadcastTxs = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    const txPackages = [];
-    let previousFeeBumpTx;
-    const chain = [];
-    let currentNode = node;
-    while (currentNode) {
-      chain.unshift(currentNode);
-      if (currentNode.parentNodeId) {
-        let parentNode = nodeMap.get(currentNode.parentNodeId);
-        if (!parentNode && sparkClient) {
-          try {
-            const response = await sparkClient.query_nodes({
-              source: {
-                $case: "nodeIds",
-                nodeIds: {
-                  nodeIds: [currentNode.parentNodeId]
-                }
-              },
-              includeParents: true,
-              network: network || 0
-              // Default to mainnet if not provided
-            });
-            parentNode = response.nodes[currentNode.parentNodeId];
-            if (parentNode) {
-              nodeMap.set(currentNode.parentNodeId, parentNode);
-            }
-          } catch (error) {
-            console.warn(
-              `Failed to query parent node ${currentNode.parentNodeId}: ${error}`
-            );
-            break;
-          }
-        }
-        if (parentNode) {
-          currentNode = parentNode;
-        } else {
-          if (!sparkClient) {
-            console.warn(
-              `Parent node ${currentNode.parentNodeId} not found. Provide a sparkClient to fetch missing parents.`
-            );
-          } else {
-            console.warn(
-              `Parent node ${currentNode.parentNodeId} not found in database. Chain may be incomplete.`
-            );
-          }
-          break;
-        }
-      } else {
-        break;
-      }
-    }
-    for (const chainNode of chain) {
-      let nodeTxHex = (0, import_utils9.bytesToHex)(chainNode.nodeTx);
-      try {
-        const txObj = getTxFromRawTxHex(nodeTxHex);
-        const txid = getTxId(txObj);
-        if (broadcastTxs.get(txid)) {
-          continue;
-        }
-        broadcastTxs.set(txid, true);
-        const isBroadcast = await isTxBroadcast(txid, electrsUrl, network);
-        if (isBroadcast) {
-          continue;
-        } else {
-        }
-        let anchorOutputScriptHex;
-        for (let i = txObj.outputsLength - 1; i >= 0; i--) {
-          const output = txObj.getOutput(i);
-          if (output?.amount === 0n && output.script) {
-            anchorOutputScriptHex = (0, import_utils9.bytesToHex)(output.script);
-            break;
-          }
-        }
-      } catch (parseError) {
-        console.error(
-          `\u274C Error parsing nodeTx for anchor check (node ${chainNode.id}): ${parseError}`
-        );
-        console.log(
-          `    This may indicate a corrupted transaction in the TreeNode.`
-        );
-        console.log(`    Transaction hex: ${nodeTxHex}`);
-        console.log(
-          `    Attempting to continue with original hex, but fee bump may fail.`
-        );
-      }
-      const {
-        feeBumpPsbt: nodeFeeBumpPsbt,
-        usedUtxos,
-        correctedParentTx
-      } = constructFeeBumpTx(nodeTxHex, availableUtxos, feeRate, void 0);
-      const feeBumpTx = btc3.Transaction.fromPSBT((0, import_utils9.hexToBytes)(nodeFeeBumpPsbt));
-      var feeBumpOut = feeBumpTx.outputsLength === 1 ? feeBumpTx.getOutput(0) : null;
-      var feeBumpOutPubKey = null;
-      for (const usedUtxo of usedUtxos) {
-        if (feeBumpOut && (0, import_utils9.bytesToHex)(feeBumpOut.script) == usedUtxo.script) {
-          feeBumpOutPubKey = usedUtxo.publicKey;
-        }
-        const index = availableUtxos.findIndex(
-          (u) => u.txid === usedUtxo.txid && u.vout === usedUtxo.vout
-        );
-        if (index !== -1) {
-          availableUtxos.splice(index, 1);
-        }
-      }
-      if (feeBumpOut)
-        availableUtxos.unshift({
-          txid: getTxId(feeBumpTx),
-          vout: 0,
-          value: feeBumpOut.amount,
-          script: (0, import_utils9.bytesToHex)(feeBumpOut.script),
-          publicKey: feeBumpOutPubKey
-        });
-      const finalNodeTx = correctedParentTx || nodeTxHex;
-      txPackages.push({ tx: finalNodeTx, feeBumpPsbt: nodeFeeBumpPsbt });
-      if (chainNode.id === node.id) {
-        let refundTxHex = (0, import_utils9.bytesToHex)(chainNode.refundTx);
-        try {
-          const txObj = getTxFromRawTxHex(refundTxHex);
-          let anchorOutputScriptHex;
-          for (let i = txObj.outputsLength - 1; i >= 0; i--) {
-            const output = txObj.getOutput(i);
-            if (output?.amount === 0n && output.script) {
-              anchorOutputScriptHex = (0, import_utils9.bytesToHex)(output.script);
-              break;
-            }
-          }
-        } catch (parseError) {
-          console.error(
-            `\u274C Error parsing refundTx for anchor check (node ${chainNode.id}): ${parseError}`
-          );
-          console.log(
-            `    This may indicate a corrupted refund transaction in the TreeNode.`
-          );
-          console.log(`    Refund transaction hex: ${refundTxHex}`);
-          console.log(
-            `    Attempting to continue with original refund hex, but this transaction may be invalid.`
-          );
-        }
-        const refundFeeBump = constructFeeBumpTx(
-          refundTxHex,
-          availableUtxos,
-          feeRate,
-          void 0
-        );
-        txPackages.push({
-          tx: refundTxHex,
-          feeBumpPsbt: refundFeeBump.feeBumpPsbt
-        });
-      }
-    }
-    result.push({
-      leafId: node.id,
-      txPackages
-    });
-  }
-  return result;
-}
-function hash160(data) {
-  const sha256Hash = (0, import_sha24.sha256)(data);
-  return (0, import_legacy.ripemd160)(sha256Hash);
-}
-function constructFeeBumpTx(txHex, utxos, feeRate, previousFeeBumpTx) {
-  if (!txHex || txHex.length === 0) {
-    throw new Error("Transaction hex string is empty or undefined");
-  }
-  if (utxos.length === 0) {
-    throw new Error("No UTXOs available for fee bump");
-  }
-  let correctedTxHex = txHex;
-  let parentTx;
-  try {
-    parentTx = getTxFromRawTxHex(correctedTxHex);
-    if (!parentTx) {
-      throw new Error("getTxFromRawTxHex returned null/undefined");
-    }
-  } catch (parseError) {
-    throw new Error(
-      `Failed to parse parent transaction hex: ${parseError}. Transaction hex: ${correctedTxHex}`
-    );
-  }
-  try {
-    const outputsLength = parentTx.outputsLength;
-    const inputsLength = parentTx.inputsLength;
-    if (typeof outputsLength !== "number" || outputsLength < 0) {
-      throw new Error(
-        "Invalid transaction: outputsLength is not a valid number"
-      );
-    }
-    if (typeof inputsLength !== "number" || inputsLength < 0) {
-      throw new Error(
-        "Invalid transaction: inputsLength is not a valid number"
-      );
-    }
-  } catch (validationError) {
-    throw new Error(
-      `Transaction validation failed: ${validationError}. This may indicate a corrupted or malformed transaction.`
-    );
-  }
-  const parentTxIdFromLib = parentTx.id;
-  let ephemeralAnchorIndex = -1;
-  for (let i = 0; i < parentTx.outputsLength; i++) {
-    const output = parentTx.getOutput(i);
-    const isEphemeralAnchor = isEphemeralAnchorOutput(
-      output?.script,
-      output?.amount
-    );
-    if (isEphemeralAnchor) {
-      ephemeralAnchorIndex = i;
-      break;
-    }
-  }
-  if (ephemeralAnchorIndex === -1) {
-    throw new Error(
-      "No ephemeral anchor output found in parent transaction. Expected a 0-value output with OP_TRUE script (0x51), malformed OP_TRUE (0x0151), Bitcoin v29 ephemeral anchor script (015152014e0173), or Bitcoin OP_1 + push 2 bytes script (51024e73)."
-    );
-  }
-  const ephemeralAnchorOutput = parentTx.getOutput(ephemeralAnchorIndex);
-  if (!ephemeralAnchorOutput)
-    throw new Error("No ephemeral anchor output found");
-  if (!ephemeralAnchorOutput.script)
-    throw new Error("No script found in ephemeral anchor output");
-  if (utxos.length === 0) {
-    throw new Error("No UTXOs available for fee bump");
-  }
-  const builder = new btc3.Transaction({
-    version: 3,
-    allowUnknown: true,
-    allowLegacyWitnessUtxo: true
-  });
-  let totalValue = 0n;
-  const processedUtxos = [];
-  for (let i = 0; i < utxos.length; i++) {
-    const fundingUtxo = utxos[i];
-    if (!fundingUtxo) {
-      throw new Error(`UTXO at index ${i} is undefined`);
-    }
-    const pubKeyHash = hash160((0, import_utils9.hexToBytes)(fundingUtxo.publicKey));
-    const scriptToUse = new Uint8Array([0, 20, ...pubKeyHash]);
-    const providedScript = (0, import_utils9.hexToBytes)(fundingUtxo.script);
-    if ((0, import_utils9.bytesToHex)(scriptToUse) !== (0, import_utils9.bytesToHex)(providedScript)) {
-      throw new Error(
-        `\u274C  Derived script doesn't match provided script for UTXO ${i + 1}.`
-      );
-    }
-    builder.addInput({
-      txid: fundingUtxo.txid,
-      index: fundingUtxo.vout,
-      sequence: 4294967295,
-      witnessUtxo: {
-        script: scriptToUse,
-        // Always P2WPKH
-        amount: fundingUtxo.value
-      }
-    });
-    totalValue += fundingUtxo.value;
-    processedUtxos.push({
-      utxo: fundingUtxo,
-      p2wpkhScript: scriptToUse
-    });
-  }
-  builder.addInput({
-    txid: parentTxIdFromLib,
-    index: ephemeralAnchorIndex,
-    sequence: 4294967295,
-    witnessUtxo: {
-      script: ephemeralAnchorOutput.script,
-      // Use the original script directly (not P2WSH wrapped)
-      amount: 0n
-    }
-  });
-  const fee = 1500n;
-  const remainingValue = totalValue - fee;
-  if (remainingValue <= 0n) {
-    throw new Error(
-      `Insufficient funds for fee bump. Required fee: ${fee} sats, Available: ${totalValue} sats`
-    );
-  }
-  if (processedUtxos.length === 0) {
-    throw new Error("No processed UTXOs available for change output");
-  }
-  const firstProcessedUtxo = processedUtxos[0];
-  if (!firstProcessedUtxo) {
-    throw new Error("First processed UTXO is undefined");
-  }
-  builder.addOutput({
-    script: firstProcessedUtxo.p2wpkhScript,
-    amount: remainingValue
-  });
-  for (let i = 0; i < processedUtxos.length; i++) {
-    const processed = processedUtxos[i];
-    if (!processed) {
-      throw new Error(`Processed UTXO at index ${i} is undefined`);
-    }
-    try {
-      builder.updateInput(i, {
-        witnessScript: processed.p2wpkhScript
-      });
-      builder.signIdx;
-    } catch (error) {
-      throw new Error(`Failed to handle funding UTXO input ${i + 1}: ${error}`);
-    }
-  }
-  let psbtHex;
-  try {
-    psbtHex = (0, import_utils9.bytesToHex)(builder.toPSBT());
-  } catch (error) {
-    throw new Error(`Failed to extract transaction: ${error}`);
-  }
-  return {
-    feeBumpPsbt: psbtHex,
-    usedUtxos: utxos,
-    correctedParentTx: correctedTxHex !== txHex ? correctedTxHex : void 0
-  };
-}
-
-// src/address/address.ts
-var import_secp256k16 = require("@noble/curves/secp256k1");
-var import_utils10 = require("@noble/hashes/utils");
-var import_base2 = require("@scure/base");
-var import_uuidv7 = require("uuidv7");
-var import_utils11 = require("@noble/curves/abstract/utils");
-var AddressNetwork = {
-  MAINNET: "sp",
-  TESTNET: "spt",
-  REGTEST: "sprt",
-  SIGNET: "sps",
-  LOCAL: "spl"
-};
-function encodeSparkAddress(payload) {
-  try {
-    isValidPublicKey(payload.identityPublicKey);
-    let paymentIntentFields;
-    if (payload.paymentIntentFields) {
-      paymentIntentFields = payload.paymentIntentFields;
-    }
-    const sparkAddressProto = SparkAddress.create({
-      identityPublicKey: (0, import_utils10.hexToBytes)(payload.identityPublicKey),
-      paymentIntentFields
-    });
-    const serializedPayload = SparkAddress.encode(sparkAddressProto).finish();
-    const words = import_base2.bech32m.toWords(serializedPayload);
-    return import_base2.bech32m.encode(
-      AddressNetwork[payload.network],
-      words,
-      500
-    );
-  } catch (error) {
-    throw new ValidationError(
-      "Failed to encode Spark address",
-      {
-        field: "publicKey",
-        value: payload.identityPublicKey
-      },
-      error
-    );
-  }
-}
-function isValidPublicKey(publicKey) {
-  try {
-    const point = import_secp256k16.secp256k1.ProjectivePoint.fromHex(publicKey);
-    point.assertValidity();
-  } catch (error) {
-    throw new ValidationError(
-      "Invalid public key",
-      {
-        field: "publicKey",
-        value: publicKey
-      },
-      error
-    );
-  }
-}
-
-// src/utils/xchain-address.ts
-var btc4 = __toESM(require("@scure/btc-signer"), 1);
-var networkByType = {
-  MAINNET: btc4.NETWORK,
-  TESTNET: btc4.TEST_NETWORK,
-  REGTEST: {
-    ...btc4.TEST_NETWORK,
-    bech32: "bcrt"
-  }
-};
-function getSparkAddressFromTaproot(taprootAddress) {
-  for (const networkType of ["MAINNET", "TESTNET", "REGTEST"]) {
-    try {
-      const result = btc4.Address(networkByType[networkType]).decode(taprootAddress);
-      if (result.type === "tr") {
-        const outputPublicKey = result.pubkey;
-        return encodeSparkAddress({
-          identityPublicKey: import_buffer.Buffer.concat([
-            import_buffer.Buffer.from([2]),
-            outputPublicKey
-          ]).toString("hex"),
-          network: networkType
-        });
-      }
-    } catch (_) {
-    }
-  }
-  throw new ValidationError("Invalid taproot address");
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DEFAULT_FEE_SATS,
-  LRC_WALLET_NETWORK,
-  LRC_WALLET_NETWORK_TYPE,
-  Network,
-  NetworkToProto,
-  addPrivateKeys,
-  addPublicKeys,
-  applyAdaptorToSignature,
-  applyAdditiveTweakToPublicKey,
-  bigIntToPrivateKey,
-  calculateAvailableTokenAmount,
-  checkIfSelectedOutputsAreAvailable,
-  checkIfValidSequence,
-  collectResponses,
-  computeTaprootKeyNoScript,
-  computerLagrangeCoefficients,
-  constructFeeBumpTx,
-  constructUnilateralExitFeeBumpPackages,
-  constructUnilateralExitTxs,
-  createRefundTx,
-  createSigningCommitment,
-  createSigningNonce,
-  decodeBytesToSigningCommitment,
-  decodeBytesToSigningNonce,
-  encodeSigningCommitmentToBytes,
-  encodeSigningNonceToBytes,
-  evaluatePolynomial,
-  fieldDiv,
-  filterTokenBalanceForTokenPublicKey,
-  generateAdaptorFromSignature,
-  generatePolynomialForSecretSharing,
-  generateSignatureFromExistingAdaptor,
-  getCurrentTimelock,
-  getEphemeralAnchorOutput,
-  getLatestDepositTxId,
-  getNetwork,
-  getNetworkFromAddress,
-  getNetworkFromString,
-  getNextTransactionSequence,
-  getP2TRAddressFromPkScript,
-  getP2TRAddressFromPublicKey,
-  getP2TRScriptFromPublicKey,
-  getP2WPKHAddressFromPublicKey,
-  getRandomBigInt,
-  getRandomSigningNonce,
-  getSigHashFromTx,
-  getSigningCommitmentFromNonce,
-  getSparkAddressFromTaproot,
-  getTransactionSequence,
-  getTransferPackageSigningPayload,
-  getTxFromRawTxBytes,
-  getTxFromRawTxHex,
-  getTxId,
-  getTxIdNoReverse,
-  isEphemeralAnchorOutput,
-  isTxBroadcast,
-  lastKeyWithTarget,
-  maybeApplyFee,
-  modInverse,
-  proofOfPossessionMessageHashForDepositAddress,
-  recoverSecret,
-  splitSecret,
-  splitSecretWithProofs,
-  subtractPrivateKeys,
-  subtractPublicKeys,
-  sumOfPrivateKeys,
-  validateOutboundAdaptorSignature,
-  validateShare
-});