@buildonspark/spark-sdk 0.1.45 → 0.1.47

package/dist/chunk-GWFQ7EBA.js

@@ -0,0 +1,3773 @@
+import {
+  SparkTokenServiceDefinition
+} from "./chunk-LHRD2WT6.js";
+import {
+  Empty,
+  SparkServiceDefinition
+} from "./chunk-BGGEVUJK.js";
+import {
+  Buffer
+} from "./chunk-MVRQ5US7.js";
+
+// src/utils/crypto.ts
+var cryptoImpl = globalThis.crypto ?? null;
+var getCrypto = () => {
+  if (!cryptoImpl) {
+    throw new Error(
+      "Crypto implementation is not set. Please set it using setCrypto()."
+    );
+  }
+  return cryptoImpl;
+};
+var setCrypto = (cryptoImplParam) => {
+  cryptoImpl = cryptoImplParam;
+};
+
+// src/errors/base.ts
+import { bytesToHex } from "@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${bytesToHex(arr)})`;
+}
+
+// src/errors/types.ts
+var NetworkError = class extends SparkSDKError {
+  constructor(message, context = {}, originalError) {
+    super(message, context, originalError);
+  }
+};
+var ValidationError = class extends SparkSDKError {
+  constructor(message, context = {}, originalError) {
+    super(message, context, originalError);
+  }
+};
+var InternalValidationError = class extends SparkSDKError {
+  constructor(message, context = {}, originalError) {
+    super(message, context, originalError);
+  }
+};
+var AuthenticationError = class extends SparkSDKError {
+  constructor(message, context = {}, originalError) {
+    super(message, context, originalError);
+  }
+};
+var RPCError = class extends SparkSDKError {
+  constructor(message, context = {}, originalError) {
+    super(message, context, originalError);
+  }
+};
+var ConfigurationError = class extends SparkSDKError {
+  constructor(message, context = {}, originalError) {
+    super(message, context, originalError);
+  }
+};
+var NotImplementedError = class extends SparkSDKError {
+  constructor(message, context, originalError) {
+    super(message, context, originalError);
+  }
+};
+
+// src/utils/adaptor-signature.ts
+import { mod } from "@noble/curves/abstract/modular";
+import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/abstract/utils";
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
+function generateSignatureFromExistingAdaptor(signature, adaptorPrivateKeyBytes) {
+  const { r, s } = parseSignature(signature);
+  const sBigInt = bytesToNumberBE(s);
+  const tBigInt = bytesToNumberBE(adaptorPrivateKeyBytes);
+  const newS = mod(sBigInt - tBigInt, secp256k1.CURVE.n);
+  const newSignature = new Uint8Array([...r, ...numberToBytesBE(newS, 32)]);
+  return newSignature;
+}
+function generateAdaptorFromSignature(signature) {
+  const adaptorPrivateKey = secp256k1.utils.randomPrivateKey();
+  const { r, s } = parseSignature(signature);
+  const sBigInt = bytesToNumberBE(s);
+  const tBigInt = bytesToNumberBE(adaptorPrivateKey);
+  const newS = mod(sBigInt - tBigInt, secp256k1.CURVE.n);
+  const newSignature = new Uint8Array([...r, ...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 = bytesToNumberBE(s);
+  const adaptorPrivateKey = bytesToNumberBE(adaptorPrivateKeyBytes);
+  const newS = mod(sBigInt + adaptorPrivateKey, secp256k1.CURVE.n);
+  const newSig = new Uint8Array([...r, ...numberToBytesBE(newS, 32)]);
+  if (schnorr.verify(newSig, hash, pubkey)) {
+    return newSig;
+  }
+  const altS = mod(sBigInt - adaptorPrivateKey, secp256k1.CURVE.n);
+  const altSig = new Uint8Array([...r, ...numberToBytesBE(altS, 32)]);
+  if (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 = schnorr.utils.lift_x(bytesToNumberBE(pubKeyBytes));
+  pubKey.assertValidity();
+  const { r, s } = parseSignature(signature);
+  const commitmenet = 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 = mod(bytesToNumberBE(commitmenet), secp256k1.CURVE.n);
+  const negE = mod(-e, secp256k1.CURVE.n);
+  const R = secp256k1.ProjectivePoint.BASE.multiplyAndAddUnsafe(
+    pubKey,
+    bytesToNumberBE(s),
+    negE
+  );
+  if (!R) {
+    throw new Error("R is undefined");
+  }
+  R.assertValidity();
+  const adaptorPoint = secp256k1.ProjectivePoint.fromHex(adaptorPubkey);
+  const newR = R.add(adaptorPoint);
+  if (!inbound && newR.equals(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 = 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 (bytesToNumberBE(r) >= secp256k1.CURVE.Fp.ORDER) {
+    throw new ValidationError("Invalid signature: r >= field prime", {
+      rValue: bytesToNumberBE(r),
+      fieldPrime: secp256k1.CURVE.Fp.ORDER
+    });
+  }
+  if (bytesToNumberBE(s) >= secp256k1.CURVE.n) {
+    throw new ValidationError("Invalid signature: s >= group order", {
+      sValue: bytesToNumberBE(s),
+      groupOrder: secp256k1.CURVE.n
+    });
+  }
+  return { r, s };
+}
+
+// src/utils/network.ts
+import { NetworkType as Lrc20NetworkType } from "@buildonspark/lrc20-sdk";
+import * as btc from "@scure/btc-signer";
+import * as bitcoin from "bitcoinjs-lib";
+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 protoToNetwork = (protoNetwork) => {
+  switch (protoNetwork) {
+    case 1 /* MAINNET */:
+      return 0 /* MAINNET */;
+    case 3 /* TESTNET */:
+      return 1 /* TESTNET */;
+    case 4 /* SIGNET */:
+      return 2 /* SIGNET */;
+    case 2 /* REGTEST */:
+      return 3 /* REGTEST */;
+    default:
+      return void 0;
+  }
+};
+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 */]: Lrc20NetworkType.MAINNET,
+  [1 /* TESTNET */]: Lrc20NetworkType.TESTNET,
+  [2 /* SIGNET */]: Lrc20NetworkType.TESTNET,
+  [3 /* REGTEST */]: Lrc20NetworkType.REGTEST,
+  [4 /* LOCAL */]: Lrc20NetworkType.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
+import {
+  bytesToHex as bytesToHex2,
+  bytesToNumberBE as bytesToNumberBE2,
+  hexToBytes
+} from "@noble/curves/abstract/utils";
+import { schnorr as schnorr2, secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
+import { sha256 } from "@noble/hashes/sha2";
+import * as btc2 from "@scure/btc-signer";
+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 = schnorr2.utils.taggedHash("TapTweak", pubkey);
+  const tweak = bytesToNumberBE2(taggedHash);
+  const P = schnorr2.utils.lift_x(schnorr2.utils.bytesToNumberBE(pubkey));
+  const Q = P.add(secp256k12.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 = secp256k12.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 = secp256k12.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: bytesToHex2(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 = 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 bytesToHex2(sha256(sha256(tx.toBytes(true))).reverse());
+}
+function getTxIdNoReverse(tx) {
+  return bytesToHex2(sha256(sha256(tx.toBytes(true))));
+}
+
+// src/utils/keys.ts
+import { numberToBytesBE as numberToBytesBE2 } from "@noble/curves/abstract/utils";
+import { secp256k1 as secp256k13 } from "@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 = secp256k13.ProjectivePoint.fromHex(a);
+  const pubkeyB = secp256k13.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 = secp256k13.ProjectivePoint.fromHex(pubkey);
+  const privTweek = secp256k13.utils.normPrivateKeyToScalar(tweak);
+  const pubTweek = secp256k13.getPublicKey(privTweek, true);
+  const tweekPoint = secp256k13.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 = secp256k13.ProjectivePoint.fromHex(a);
+  const pubkeyB = secp256k13.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 = secp256k13.utils.normPrivateKeyToScalar(a);
+  const privB = secp256k13.utils.normPrivateKeyToScalar(b);
+  const sum = (privA + privB) % secp256k13.CURVE.n;
+  return numberToBytesBE2(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 = secp256k13.utils.normPrivateKeyToScalar(a);
+  const privB = secp256k13.utils.normPrivateKeyToScalar(b);
+  const sum = (secp256k13.CURVE.n - privB + privA) % secp256k13.CURVE.n;
+  return numberToBytesBE2(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 isHermeticTest = Boolean(
+  typeof process !== "undefined" && process?.env?.HERMETIC_TEST === "true"
+);
+
+// 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")
+  }
+};
+var WalletConfig = {
+  LOCAL: LOCAL_WALLET_CONFIG,
+  LOCAL_SCHNORR: LOCAL_WALLET_CONFIG_SCHNORR,
+  LOCAL_ECDSA: LOCAL_WALLET_CONFIG_ECDSA,
+  REGTEST: REGTEST_WALLET_CONFIG,
+  MAINNET: MAINNET_WALLET_CONFIG
+};
+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/utils/proof.ts
+import { sha256 as sha2562 } from "@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 sha2562(proofMsg);
+}
+
+// src/utils/secret-sharing.ts
+import { bytesToHex as bytesToHex3, equalBytes } from "@noble/curves/abstract/utils";
+import { secp256k1 as secp256k14 } from "@noble/curves/secp256k1";
+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 crypto = getCrypto();
+    const randBytes = crypto.getRandomValues(new Uint8Array(byteLength + 1));
+    const randValue = BigInt("0x" + bytesToHex3(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] = secp256k14.ProjectivePoint.fromPrivateKey(secret).toRawBytes(true);
+  for (let i = 1; i < degree; i++) {
+    const coefficient = getRandomBigInt(fieldModulus);
+    coefficients[i] = coefficient;
+    proofs[i] = secp256k14.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 = secp256k14.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 = secp256k14.ProjectivePoint.fromHex(pubkey).multiply(value);
+    resultPubkey = secp256k14.ProjectivePoint.fromHex(resultPubkey).add(scaledPoint).toRawBytes(true);
+  }
+  if (!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
+import { secp256k1 as secp256k15 } from "@noble/curves/secp256k1";
+function getRandomSigningNonce() {
+  const binding = secp256k15.utils.randomPrivateKey();
+  const hiding = secp256k15.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 = secp256k15.getPublicKey(nonce.binding, true);
+  const hidingPubKey = secp256k15.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/transaction.ts
+import { Transaction as Transaction2 } from "@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 Transaction2({
+    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/signer/signer.ts
+import {
+  bytesToHex as bytesToHex4,
+  bytesToNumberBE as bytesToNumberBE3,
+  equalBytes as equalBytes2,
+  hexToBytes as hexToBytes2
+} from "@noble/curves/abstract/utils";
+import { schnorr as schnorr3, secp256k1 as secp256k16 } from "@noble/curves/secp256k1";
+import { HDKey } from "@scure/bip32";
+import { generateMnemonic, mnemonicToSeed } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+import * as ecies from "eciesjs";
+
+// src/constants.ts
+import { isNode } from "@lightsparkdev/core";
+var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var isBun = globalThis.Bun !== void 0;
+var packageVersion = true ? "0.1.47" : "unknown";
+var baseEnvStr = "unknown";
+if (isBun) {
+  const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
+  baseEnvStr = `bun/${bunVersion}`;
+} else if (isNode) {
+  baseEnvStr = `node/${process.version}`;
+} else if (isReactNative) {
+  baseEnvStr = "react-native";
+} else {
+  const userAgent = typeof navigator !== "undefined" && navigator.userAgent || "unknown-user-agent";
+  baseEnvStr = `browser/${userAgent}`;
+}
+var clientEnv = `js-spark-sdk/${packageVersion} ${baseEnvStr}`;
+
+// src/signer/signer.ts
+import { privateAdd, privateNegate } from "@bitcoinerlab/secp256k1";
+import {
+  fromPrivateKey,
+  PARITY,
+  Receipt
+} from "@buildonspark/lrc20-sdk";
+import { sha256 as sha2563 } from "@noble/hashes/sha2";
+import { taprootTweakPrivKey } from "@scure/btc-signer/utils";
+var sparkFrostModule = void 0;
+var getSparkFrostModule = async () => {
+  if (isReactNative) {
+    return void 0;
+  }
+  if (!sparkFrostModule) {
+    sparkFrostModule = await import("./spark_bindings/wasm/index.js");
+  }
+  return sparkFrostModule;
+};
+var HARDENED_OFFSET = 2147483648;
+var DefaultSparkKeysGenerator = class {
+  async deriveKeysFromSeed(seed, accountNumber) {
+    const hdkey = HDKey.fromMasterSeed(seed);
+    if (!hdkey.privateKey || !hdkey.publicKey) {
+      throw new ValidationError("Failed to derive keys from seed", {
+        field: "hdkey",
+        value: seed
+      });
+    }
+    const identityKey = hdkey.derive(`m/8797555'/${accountNumber}'/0'`);
+    const signingKey = hdkey.derive(`m/8797555'/${accountNumber}'/1'`);
+    const depositKey = hdkey.derive(`m/8797555'/${accountNumber}'/2'`);
+    const staticDepositKey = hdkey.derive(`m/8797555'/${accountNumber}'/3'`);
+    if (!identityKey.privateKey || !depositKey.privateKey || !signingKey.privateKey || !identityKey.publicKey || !depositKey.publicKey || !signingKey.publicKey || !staticDepositKey.privateKey || !staticDepositKey.publicKey) {
+      throw new ValidationError(
+        "Failed to derive all required keys from seed",
+        {
+          field: "derivedKeys"
+        }
+      );
+    }
+    return {
+      masterPublicKey: hdkey.publicKey,
+      identityKey: {
+        privateKey: identityKey.privateKey,
+        publicKey: identityKey.publicKey
+      },
+      signingHDKey: {
+        hdKey: signingKey,
+        privateKey: signingKey.privateKey,
+        publicKey: signingKey.publicKey
+      },
+      depositKey: {
+        privateKey: depositKey.privateKey,
+        publicKey: depositKey.publicKey
+      },
+      staticDepositHDKey: {
+        hdKey: staticDepositKey,
+        privateKey: staticDepositKey.privateKey,
+        publicKey: staticDepositKey.publicKey
+      }
+    };
+  }
+};
+var TaprootOutputKeysGenerator = class {
+  constructor(useAddressIndex = false) {
+    this.useAddressIndex = useAddressIndex;
+  }
+  async deriveKeysFromSeed(seed, accountNumber) {
+    const hdkey = HDKey.fromMasterSeed(seed);
+    if (!hdkey.privateKey || !hdkey.publicKey) {
+      throw new ValidationError("Failed to derive keys from seed", {
+        field: "hdkey",
+        value: seed
+      });
+    }
+    const derivationPath = this.useAddressIndex ? `m/86'/0'/0'/0/${accountNumber}` : `m/86'/0'/${accountNumber}'/0/0`;
+    const taprootInternalKey = hdkey.derive(derivationPath);
+    let tweakedPrivateKey = taprootTweakPrivKey(taprootInternalKey.privateKey);
+    let tweakedPublicKey = secp256k16.getPublicKey(tweakedPrivateKey);
+    if (tweakedPublicKey[0] === 3) {
+      tweakedPrivateKey = privateNegate(tweakedPrivateKey);
+      tweakedPublicKey = secp256k16.getPublicKey(tweakedPrivateKey);
+    }
+    const identityKey = {
+      publicKey: tweakedPublicKey,
+      privateKey: tweakedPrivateKey
+    };
+    const signingKey = hdkey.derive(`${derivationPath}/1'`);
+    const depositKey = hdkey.derive(`${derivationPath}/2'`);
+    const staticDepositKey = hdkey.derive(`${derivationPath}/3'`);
+    if (!signingKey.privateKey || !signingKey.publicKey || !depositKey.privateKey || !depositKey.publicKey || !staticDepositKey.privateKey || !staticDepositKey.publicKey) {
+      throw new ValidationError(
+        "Failed to derive all required keys from seed",
+        {
+          field: "derivedKeys"
+        }
+      );
+    }
+    return {
+      masterPublicKey: hdkey.publicKey,
+      identityKey: {
+        privateKey: identityKey.privateKey,
+        publicKey: identityKey.publicKey
+      },
+      signingHDKey: {
+        hdKey: signingKey,
+        privateKey: signingKey.privateKey,
+        publicKey: signingKey.publicKey
+      },
+      depositKey: {
+        privateKey: depositKey.privateKey,
+        publicKey: depositKey.publicKey
+      },
+      staticDepositHDKey: {
+        hdKey: staticDepositKey,
+        privateKey: staticDepositKey.privateKey,
+        publicKey: staticDepositKey.publicKey
+      }
+    };
+  }
+};
+var DefaultSparkSigner = class {
+  masterPublicKey = null;
+  identityKey = null;
+  signingKey = null;
+  depositKey = null;
+  staticDepositKey = null;
+  staticDepositKeyMap = /* @__PURE__ */ new Map();
+  // <hex, hex>
+  publicKeyToPrivateKeyMap = /* @__PURE__ */ new Map();
+  commitmentToNonceMap = /* @__PURE__ */ new Map();
+  keysGenerator;
+  constructor({
+    sparkKeysGenerator
+  } = {}) {
+    this.keysGenerator = sparkKeysGenerator ?? new DefaultSparkKeysGenerator();
+  }
+  deriveSigningKey(hash) {
+    if (!this.signingKey) {
+      throw new ValidationError("Private key not initialized", {
+        field: "signingKey"
+      });
+    }
+    const view = new DataView(hash.buffer);
+    const amount = view.getUint32(0, false) % HARDENED_OFFSET + HARDENED_OFFSET;
+    const newPrivateKey = this.signingKey?.deriveChild(amount).privateKey;
+    if (!newPrivateKey) {
+      throw new ValidationError("Failed to recover signing key", {
+        field: "privateKey"
+      });
+    }
+    return newPrivateKey;
+  }
+  async restoreSigningKeysFromLeafs(leafs) {
+    if (!this.signingKey) {
+      throw new ValidationError("Signing key is not set", {
+        field: "signingKey"
+      });
+    }
+    for (const leaf of leafs) {
+      const hash = sha2563(leaf.id);
+      const privateKey = this.deriveSigningKey(hash);
+      const publicKey = secp256k16.getPublicKey(privateKey);
+      this.publicKeyToPrivateKeyMap.set(
+        bytesToHex4(publicKey),
+        bytesToHex4(privateKey)
+      );
+    }
+  }
+  async getSchnorrPublicKey(publicKey) {
+    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex4(publicKey));
+    if (!privateKey) {
+      throw new ValidationError("Private key is not set", {
+        field: "privateKey"
+      });
+    }
+    return schnorr3.getPublicKey(hexToBytes2(privateKey));
+  }
+  async signSchnorr(message, publicKey) {
+    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex4(publicKey));
+    if (!privateKey) {
+      throw new ValidationError("Private key is not set", {
+        field: "privateKey"
+      });
+    }
+    return schnorr3.sign(message, hexToBytes2(privateKey));
+  }
+  async signSchnorrWithIdentityKey(message) {
+    if (!this.identityKey?.privateKey) {
+      throw new ValidationError("Private key not set", {
+        field: "identityKey"
+      });
+    }
+    const signature = schnorr3.sign(message, this.identityKey.privateKey);
+    return signature;
+  }
+  async getIdentityPublicKey() {
+    if (!this.identityKey?.publicKey) {
+      throw new ValidationError("Private key is not set", {
+        field: "identityKey"
+      });
+    }
+    return this.identityKey.publicKey;
+  }
+  async getDepositSigningKey() {
+    if (!this.depositKey?.publicKey) {
+      throw new ValidationError("Deposit key is not set", {
+        field: "depositKey"
+      });
+    }
+    return this.depositKey.publicKey;
+  }
+  async generateStaticDepositKey(idx) {
+    if (!this.staticDepositKey?.privateKey) {
+      throw new ValidationError("Static deposit key is not set", {
+        field: "staticDepositKey"
+      });
+    }
+    if (this.staticDepositKeyMap.has(idx)) {
+      const staticDepositKey2 = this.staticDepositKeyMap.get(idx);
+      return staticDepositKey2?.publicKey;
+    }
+    const staticDepositKey = this.staticDepositKey.deriveChild(
+      HARDENED_OFFSET + idx
+    );
+    this.staticDepositKeyMap.set(idx, staticDepositKey);
+    this.publicKeyToPrivateKeyMap.set(
+      bytesToHex4(staticDepositKey.publicKey),
+      bytesToHex4(staticDepositKey.privateKey)
+    );
+    return staticDepositKey.publicKey;
+  }
+  async getStaticDepositSigningKey(idx) {
+    if (!this.staticDepositKey) {
+      throw new ValidationError("Static deposit key is not set", {
+        field: "staticDepositKey"
+      });
+    }
+    if (!this.staticDepositKeyMap.has(idx)) {
+      await this.generateStaticDepositKey(idx);
+    }
+    const staticDepositKey = this.staticDepositKeyMap.get(idx);
+    if (!staticDepositKey?.publicKey) {
+      throw new ValidationError("Static deposit key is not set", {
+        field: "staticDepositKey"
+      });
+    }
+    return staticDepositKey.publicKey;
+  }
+  async getStaticDepositSecretKey(idx) {
+    if (!this.staticDepositKey) {
+      throw new ValidationError("Static deposit key is not set", {
+        field: "staticDepositKey"
+      });
+    }
+    if (!this.staticDepositKeyMap.has(idx)) {
+      await this.generateStaticDepositKey(idx);
+    }
+    const staticDepositKey = this.staticDepositKeyMap.get(idx);
+    if (!staticDepositKey?.privateKey) {
+      throw new ValidationError("Static deposit key is not set", {
+        field: "staticDepositKey"
+      });
+    }
+    return staticDepositKey.privateKey;
+  }
+  async generateMnemonic() {
+    return generateMnemonic(wordlist);
+  }
+  async mnemonicToSeed(mnemonic) {
+    return await mnemonicToSeed(mnemonic);
+  }
+  async getTrackedPublicKeys() {
+    return Array.from(this.publicKeyToPrivateKeyMap.keys()).map(hexToBytes2);
+  }
+  async generatePublicKey(hash) {
+    if (!this.signingKey) {
+      throw new ValidationError("Private key is not set", {
+        field: "signingKey"
+      });
+    }
+    let newPrivateKey = null;
+    if (hash) {
+      newPrivateKey = this.deriveSigningKey(hash);
+    } else {
+      newPrivateKey = secp256k16.utils.randomPrivateKey();
+    }
+    if (!newPrivateKey) {
+      throw new ValidationError("Failed to generate new private key", {
+        field: "privateKey"
+      });
+    }
+    const publicKey = secp256k16.getPublicKey(newPrivateKey);
+    const pubKeyHex = bytesToHex4(publicKey);
+    const privKeyHex = bytesToHex4(newPrivateKey);
+    this.publicKeyToPrivateKeyMap.set(pubKeyHex, privKeyHex);
+    return publicKey;
+  }
+  async removePublicKey(publicKey) {
+    this.publicKeyToPrivateKeyMap.delete(bytesToHex4(publicKey));
+  }
+  async subtractPrivateKeysGivenPublicKeys(first, second) {
+    const firstPubKeyHex = bytesToHex4(first);
+    const secondPubKeyHex = bytesToHex4(second);
+    const firstPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(firstPubKeyHex);
+    const secondPrivateKeyHex = this.publicKeyToPrivateKeyMap.get(secondPubKeyHex);
+    if (!firstPrivateKeyHex || !secondPrivateKeyHex) {
+      throw new Error("Private key is not set");
+    }
+    const firstPrivateKey = hexToBytes2(firstPrivateKeyHex);
+    const secondPrivateKey = hexToBytes2(secondPrivateKeyHex);
+    const resultPrivKey = subtractPrivateKeys(
+      firstPrivateKey,
+      secondPrivateKey
+    );
+    const resultPubKey = secp256k16.getPublicKey(resultPrivKey);
+    const resultPrivKeyHex = bytesToHex4(resultPrivKey);
+    const resultPubKeyHex = bytesToHex4(resultPubKey);
+    this.publicKeyToPrivateKeyMap.set(resultPubKeyHex, resultPrivKeyHex);
+    return resultPubKey;
+  }
+  async splitSecretWithProofs({
+    secret,
+    curveOrder,
+    threshold,
+    numShares,
+    isSecretPubkey = false
+  }) {
+    if (isSecretPubkey) {
+      const pubKeyHex = bytesToHex4(secret);
+      const privateKey = this.publicKeyToPrivateKeyMap.get(pubKeyHex);
+      if (!privateKey) {
+        throw new Error("Private key is not set");
+      }
+      secret = hexToBytes2(privateKey);
+    }
+    const secretAsInt = bytesToNumberBE3(secret);
+    return splitSecretWithProofs(secretAsInt, curveOrder, threshold, numShares);
+  }
+  async signFrost({
+    message,
+    privateAsPubKey,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey
+  }) {
+    const SparkFrost = await getSparkFrostModule();
+    if (!SparkFrost) {
+      throw new ValidationError("SparkFrost module not found", {
+        field: "SparkFrost"
+      });
+    }
+    const privateAsPubKeyHex = bytesToHex4(privateAsPubKey);
+    const signingPrivateKey = this.publicKeyToPrivateKeyMap.get(privateAsPubKeyHex);
+    if (!signingPrivateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey"
+      });
+    }
+    const nonce = this.commitmentToNonceMap.get(selfCommitment);
+    if (!nonce) {
+      throw new ValidationError("Nonce not found for commitment", {
+        field: "nonce"
+      });
+    }
+    const keyPackage = {
+      secretKey: hexToBytes2(signingPrivateKey),
+      publicKey,
+      verifyingKey
+    };
+    return SparkFrost.signFrost({
+      message,
+      keyPackage,
+      nonce,
+      selfCommitment,
+      statechainCommitments,
+      adaptorPubKey
+    });
+  }
+  async aggregateFrost({
+    message,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey,
+    selfSignature,
+    statechainSignatures,
+    statechainPublicKeys
+  }) {
+    const SparkFrost = await getSparkFrostModule();
+    if (!SparkFrost) {
+      throw new ValidationError("SparkFrost module not found", {
+        field: "SparkFrost"
+      });
+    }
+    return SparkFrost.aggregateFrost({
+      message,
+      statechainSignatures,
+      statechainPublicKeys,
+      verifyingKey,
+      statechainCommitments,
+      selfCommitment,
+      selfPublicKey: publicKey,
+      selfSignature,
+      adaptorPubKey
+    });
+  }
+  async createSparkWalletFromSeed(seed, accountNumber) {
+    if (typeof seed === "string") {
+      seed = hexToBytes2(seed);
+    }
+    const {
+      masterPublicKey,
+      identityKey,
+      signingHDKey: signingKey,
+      depositKey,
+      staticDepositHDKey: staticDepositKey
+    } = await this.keysGenerator.deriveKeysFromSeed(seed, accountNumber ?? 0);
+    this.masterPublicKey = masterPublicKey;
+    this.identityKey = identityKey;
+    this.depositKey = depositKey;
+    this.signingKey = signingKey.hdKey;
+    this.staticDepositKey = staticDepositKey.hdKey;
+    this.publicKeyToPrivateKeyMap.set(
+      bytesToHex4(identityKey.publicKey),
+      bytesToHex4(identityKey.privateKey)
+    );
+    this.publicKeyToPrivateKeyMap.set(
+      bytesToHex4(depositKey.publicKey),
+      bytesToHex4(depositKey.privateKey)
+    );
+    this.publicKeyToPrivateKeyMap.set(
+      bytesToHex4(staticDepositKey.publicKey),
+      bytesToHex4(staticDepositKey.privateKey)
+    );
+    return bytesToHex4(identityKey.publicKey);
+  }
+  async signMessageWithPublicKey(message, publicKey, compact) {
+    const privateKey = this.publicKeyToPrivateKeyMap.get(bytesToHex4(publicKey));
+    if (!privateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey",
+        value: bytesToHex4(publicKey)
+      });
+    }
+    const signature = secp256k16.sign(message, hexToBytes2(privateKey));
+    if (compact) {
+      return signature.toCompactRawBytes();
+    }
+    return signature.toDERRawBytes();
+  }
+  async signMessageWithIdentityKey(message, compact) {
+    if (!this.identityKey?.privateKey) {
+      throw new ConfigurationError("Identity key not initialized", {
+        configKey: "identityKey"
+      });
+    }
+    const signature = secp256k16.sign(message, this.identityKey.privateKey);
+    if (compact) {
+      return signature.toCompactRawBytes();
+    }
+    return signature.toDERRawBytes();
+  }
+  async encryptLeafPrivateKeyEcies(receiverPublicKey, publicKey) {
+    const publicKeyHex = bytesToHex4(publicKey);
+    const privateKey = this.publicKeyToPrivateKeyMap.get(publicKeyHex);
+    if (!privateKey) {
+      throw new Error("Private key is not set");
+    }
+    return ecies.encrypt(receiverPublicKey, hexToBytes2(privateKey));
+  }
+  async decryptEcies(ciphertext) {
+    if (!this.identityKey?.privateKey) {
+      throw new ConfigurationError("Identity key not initialized", {
+        configKey: "identityKey"
+      });
+    }
+    const receiverEciesPrivKey = ecies.PrivateKey.fromHex(
+      bytesToHex4(this.identityKey.privateKey)
+    );
+    const privateKey = ecies.decrypt(receiverEciesPrivKey.toHex(), ciphertext);
+    const publicKey = secp256k16.getPublicKey(privateKey);
+    const publicKeyHex = bytesToHex4(publicKey);
+    const privateKeyHex = bytesToHex4(privateKey);
+    this.publicKeyToPrivateKeyMap.set(publicKeyHex, privateKeyHex);
+    return publicKey;
+  }
+  async getRandomSigningCommitment() {
+    const nonce = getRandomSigningNonce();
+    const commitment = getSigningCommitmentFromNonce(nonce);
+    this.commitmentToNonceMap.set(commitment, nonce);
+    return commitment;
+  }
+  async hashRandomPrivateKey() {
+    return sha2563(secp256k16.utils.randomPrivateKey());
+  }
+  async generateAdaptorFromSignature(signature) {
+    const adaptor = generateAdaptorFromSignature(signature);
+    const adaptorPublicKey = secp256k16.getPublicKey(adaptor.adaptorPrivateKey);
+    this.publicKeyToPrivateKeyMap.set(
+      bytesToHex4(adaptorPublicKey),
+      bytesToHex4(adaptor.adaptorPrivateKey)
+    );
+    return {
+      adaptorSignature: signature,
+      adaptorPublicKey
+    };
+  }
+  async getMasterPublicKey() {
+    if (!this.masterPublicKey) {
+      throw new Error("Private key is not set");
+    }
+    return this.masterPublicKey;
+  }
+  async validateMessageWithIdentityKey(message, signature) {
+    if (!this.identityKey?.publicKey) {
+      throw new ConfigurationError("Identity key not initialized", {
+        configKey: "identityKey"
+      });
+    }
+    return secp256k16.verify(signature, message, this.identityKey.publicKey);
+  }
+  async signPsbt(psbt, input, sighashTypes, receipt) {
+    if (!this.identityKey?.privateKey) {
+      throw new ConfigurationError("Identity key not initialized", {
+        configKey: "identityKey"
+      });
+    }
+    if (receipt) {
+      const receiptPrivateKey = this.getReceiptPrivateKey(receipt);
+      const tweakedKeyPair = fromPrivateKey(Buffer.from(receiptPrivateKey));
+      psbt.signInput(input, tweakedKeyPair, sighashTypes);
+      return psbt;
+    }
+    const keypair = fromPrivateKey(Buffer.from(this.identityKey.privateKey));
+    psbt.signInput(input, keypair, sighashTypes);
+    return psbt;
+  }
+  getReceiptPrivateKey(receipt) {
+    const pxh = Receipt.receiptHash(receipt);
+    let innerKey = this.identityKey.publicKey;
+    let privateKey = this.identityKey.privateKey;
+    if (innerKey[0] === 3) {
+      innerKey = Buffer.concat([PARITY, innerKey.slice(1)]);
+      privateKey = Buffer.from(privateNegate(privateKey));
+    }
+    const pxhPubkey = sha2563(Buffer.concat([pxh, innerKey]));
+    const receiptProof = privateAdd(privateKey, pxhPubkey);
+    return Buffer.from(receiptProof);
+  }
+  signTransactionIndex(tx, index, publicKey) {
+    let privateKey;
+    if (equalBytes2(publicKey, this.identityKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.identityKey?.privateKey;
+    } else if (equalBytes2(publicKey, this.depositKey?.publicKey ?? new Uint8Array())) {
+      privateKey = this.depositKey?.privateKey;
+    } else {
+      privateKey = hexToBytes2(
+        this.publicKeyToPrivateKeyMap.get(bytesToHex4(publicKey)) ?? ""
+      );
+    }
+    if (!privateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey",
+        value: bytesToHex4(publicKey)
+      });
+    }
+    tx.signIdx(privateKey, index);
+  }
+};
+var TaprootSparkSigner = class extends DefaultSparkSigner {
+  constructor(useAddressIndex = false) {
+    super({
+      sparkKeysGenerator: new TaprootOutputKeysGenerator(useAddressIndex)
+    });
+  }
+};
+
+// src/services/config.ts
+var WalletConfigService = class {
+  config;
+  signer;
+  lrc20ApiConfig;
+  sspClientOptions;
+  constructor(options, signer) {
+    const network = options?.network ?? "REGTEST";
+    this.config = {
+      ...this.getDefaultConfig(Network2[network]),
+      ...options
+    };
+    this.signer = signer ?? new DefaultSparkSigner();
+    this.lrc20ApiConfig = this.config.lrc20ApiConfig;
+    this.sspClientOptions = this.config.sspClientOptions;
+  }
+  getDefaultConfig(network) {
+    switch (network) {
+      case 0 /* MAINNET */:
+        return WalletConfig.MAINNET;
+      case 3 /* REGTEST */:
+        return WalletConfig.REGTEST;
+      default:
+        return WalletConfig.LOCAL;
+    }
+  }
+  getCoordinatorAddress() {
+    const coordinator = this.config.signingOperators[this.config.coodinatorIdentifier];
+    if (!coordinator) {
+      throw new ConfigurationError(
+        "Coordinator not found in signing operators",
+        {
+          configKey: "signingOperators"
+        }
+      );
+    }
+    return coordinator.address;
+  }
+  getLrc20Address() {
+    return this.config.lrc20Address;
+  }
+  getSigningOperators() {
+    return this.config.signingOperators;
+  }
+  getThreshold() {
+    return this.config.threshold;
+  }
+  getCoordinatorIdentifier() {
+    return this.config.coodinatorIdentifier;
+  }
+  getExpectedWithdrawBondSats() {
+    return this.config.expectedWithdrawBondSats;
+  }
+  getExpectedWithdrawRelativeBlockLocktime() {
+    return this.config.expectedWithdrawRelativeBlockLocktime;
+  }
+  getSspNetwork() {
+    if (this.config.network === "MAINNET") {
+      return "MAINNET" /* MAINNET */;
+    } else if (this.config.network === "REGTEST") {
+      return "REGTEST" /* REGTEST */;
+    } else if (this.config.network === "TESTNET") {
+      return "TESTNET" /* TESTNET */;
+    } else if (this.config.network === "SIGNET") {
+      return "SIGNET" /* SIGNET */;
+    }
+    return "FUTURE_VALUE" /* FUTURE_VALUE */;
+  }
+  getNetwork() {
+    return Network2[this.config.network];
+  }
+  getNetworkType() {
+    return this.config.network;
+  }
+  getNetworkProto() {
+    return NetworkToProto[Network2[this.config.network]];
+  }
+  getTokenSignatures() {
+    return this.config.tokenSignatures;
+  }
+  getTokenTransactionVersion() {
+    return this.config.tokenTransactionVersion;
+  }
+  getTokenValidityDurationSeconds() {
+    return this.config.tokenValidityDurationSeconds;
+  }
+  getElectrsUrl() {
+    return this.config.electrsUrl;
+  }
+  getSspIdentityPublicKey() {
+    return this.config.sspClientOptions.identityPublicKey;
+  }
+};
+
+// src/services/connection.ts
+import { isError, isNode as isNode2 } from "@lightsparkdev/core";
+import { sha256 as sha2564 } from "@noble/hashes/sha2";
+import { retryMiddleware } from "nice-grpc-client-middleware-retry";
+import { Metadata } from "nice-grpc-common";
+
+// src/proto/mock.ts
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+function interruptTransferRequest_InterruptTransferActionFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "NONE":
+      return 0 /* NONE */;
+    case 1:
+    case "INTERRUPT":
+      return 1 /* INTERRUPT */;
+    case 2:
+    case "RESUME":
+      return 2 /* RESUME */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function interruptTransferRequest_InterruptTransferActionToJSON(object) {
+  switch (object) {
+    case 0 /* NONE */:
+      return "NONE";
+    case 1 /* INTERRUPT */:
+      return "INTERRUPT";
+    case 2 /* RESUME */:
+      return "RESUME";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+function createBaseCleanUpPreimageShareRequest() {
+  return { paymentHash: new Uint8Array(0) };
+}
+var CleanUpPreimageShareRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.paymentHash.length !== 0) {
+      writer.uint32(10).bytes(message.paymentHash);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseCleanUpPreimageShareRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.paymentHash = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { paymentHash: isSet(object.paymentHash) ? bytesFromBase64(object.paymentHash) : new Uint8Array(0) };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.paymentHash.length !== 0) {
+      obj.paymentHash = base64FromBytes(message.paymentHash);
+    }
+    return obj;
+  },
+  create(base) {
+    return CleanUpPreimageShareRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseCleanUpPreimageShareRequest();
+    message.paymentHash = object.paymentHash ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseInterruptTransferRequest() {
+  return { action: 0 };
+}
+var InterruptTransferRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.action !== 0) {
+      writer.uint32(8).int32(message.action);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseInterruptTransferRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.action = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      action: isSet(object.action) ? interruptTransferRequest_InterruptTransferActionFromJSON(object.action) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.action !== 0) {
+      obj.action = interruptTransferRequest_InterruptTransferActionToJSON(message.action);
+    }
+    return obj;
+  },
+  create(base) {
+    return InterruptTransferRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseInterruptTransferRequest();
+    message.action = object.action ?? 0;
+    return message;
+  }
+};
+function createBaseUpdateNodesStatusRequest() {
+  return { nodeIds: [], status: "" };
+}
+var UpdateNodesStatusRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    for (const v of message.nodeIds) {
+      writer.uint32(10).string(v);
+    }
+    if (message.status !== "") {
+      writer.uint32(18).string(message.status);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseUpdateNodesStatusRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.nodeIds.push(reader.string());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.status = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      nodeIds: globalThis.Array.isArray(object?.nodeIds) ? object.nodeIds.map((e) => globalThis.String(e)) : [],
+      status: isSet(object.status) ? globalThis.String(object.status) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.nodeIds?.length) {
+      obj.nodeIds = message.nodeIds;
+    }
+    if (message.status !== "") {
+      obj.status = message.status;
+    }
+    return obj;
+  },
+  create(base) {
+    return UpdateNodesStatusRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseUpdateNodesStatusRequest();
+    message.nodeIds = object.nodeIds?.map((e) => e) || [];
+    message.status = object.status ?? "";
+    return message;
+  }
+};
+var MockServiceDefinition = {
+  name: "MockService",
+  fullName: "mock.MockService",
+  methods: {
+    clean_up_preimage_share: {
+      name: "clean_up_preimage_share",
+      requestType: CleanUpPreimageShareRequest,
+      requestStream: false,
+      responseType: Empty,
+      responseStream: false,
+      options: {}
+    },
+    interrupt_transfer: {
+      name: "interrupt_transfer",
+      requestType: InterruptTransferRequest,
+      requestStream: false,
+      responseType: Empty,
+      responseStream: false,
+      options: {}
+    },
+    update_nodes_status: {
+      name: "update_nodes_status",
+      requestType: UpdateNodesStatusRequest,
+      requestStream: false,
+      responseType: Empty,
+      responseStream: false,
+      options: {}
+    }
+  }
+};
+function bytesFromBase64(b64) {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+function base64FromBytes(arr) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/proto/spark_authn.ts
+import { BinaryReader as BinaryReader2, BinaryWriter as BinaryWriter2 } from "@bufbuild/protobuf/wire";
+function createBaseChallenge() {
+  return { version: 0, timestamp: 0, nonce: new Uint8Array(0), publicKey: new Uint8Array(0) };
+}
+var Challenge = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.version !== 0) {
+      writer.uint32(8).int32(message.version);
+    }
+    if (message.timestamp !== 0) {
+      writer.uint32(16).int64(message.timestamp);
+    }
+    if (message.nonce.length !== 0) {
+      writer.uint32(26).bytes(message.nonce);
+    }
+    if (message.publicKey.length !== 0) {
+      writer.uint32(34).bytes(message.publicKey);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseChallenge();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.version = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.timestamp = longToNumber(reader.int64());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.nonce = reader.bytes();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.publicKey = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      version: isSet2(object.version) ? globalThis.Number(object.version) : 0,
+      timestamp: isSet2(object.timestamp) ? globalThis.Number(object.timestamp) : 0,
+      nonce: isSet2(object.nonce) ? bytesFromBase642(object.nonce) : new Uint8Array(0),
+      publicKey: isSet2(object.publicKey) ? bytesFromBase642(object.publicKey) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.version !== 0) {
+      obj.version = Math.round(message.version);
+    }
+    if (message.timestamp !== 0) {
+      obj.timestamp = Math.round(message.timestamp);
+    }
+    if (message.nonce.length !== 0) {
+      obj.nonce = base64FromBytes2(message.nonce);
+    }
+    if (message.publicKey.length !== 0) {
+      obj.publicKey = base64FromBytes2(message.publicKey);
+    }
+    return obj;
+  },
+  create(base) {
+    return Challenge.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseChallenge();
+    message.version = object.version ?? 0;
+    message.timestamp = object.timestamp ?? 0;
+    message.nonce = object.nonce ?? new Uint8Array(0);
+    message.publicKey = object.publicKey ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseProtectedChallenge() {
+  return { version: 0, challenge: void 0, serverHmac: new Uint8Array(0) };
+}
+var ProtectedChallenge = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.version !== 0) {
+      writer.uint32(8).int32(message.version);
+    }
+    if (message.challenge !== void 0) {
+      Challenge.encode(message.challenge, writer.uint32(18).fork()).join();
+    }
+    if (message.serverHmac.length !== 0) {
+      writer.uint32(26).bytes(message.serverHmac);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseProtectedChallenge();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.version = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.challenge = Challenge.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.serverHmac = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      version: isSet2(object.version) ? globalThis.Number(object.version) : 0,
+      challenge: isSet2(object.challenge) ? Challenge.fromJSON(object.challenge) : void 0,
+      serverHmac: isSet2(object.serverHmac) ? bytesFromBase642(object.serverHmac) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.version !== 0) {
+      obj.version = Math.round(message.version);
+    }
+    if (message.challenge !== void 0) {
+      obj.challenge = Challenge.toJSON(message.challenge);
+    }
+    if (message.serverHmac.length !== 0) {
+      obj.serverHmac = base64FromBytes2(message.serverHmac);
+    }
+    return obj;
+  },
+  create(base) {
+    return ProtectedChallenge.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseProtectedChallenge();
+    message.version = object.version ?? 0;
+    message.challenge = object.challenge !== void 0 && object.challenge !== null ? Challenge.fromPartial(object.challenge) : void 0;
+    message.serverHmac = object.serverHmac ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseGetChallengeRequest() {
+  return { publicKey: new Uint8Array(0) };
+}
+var GetChallengeRequest = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.publicKey.length !== 0) {
+      writer.uint32(10).bytes(message.publicKey);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseGetChallengeRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.publicKey = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { publicKey: isSet2(object.publicKey) ? bytesFromBase642(object.publicKey) : new Uint8Array(0) };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.publicKey.length !== 0) {
+      obj.publicKey = base64FromBytes2(message.publicKey);
+    }
+    return obj;
+  },
+  create(base) {
+    return GetChallengeRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseGetChallengeRequest();
+    message.publicKey = object.publicKey ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseGetChallengeResponse() {
+  return { protectedChallenge: void 0 };
+}
+var GetChallengeResponse = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.protectedChallenge !== void 0) {
+      ProtectedChallenge.encode(message.protectedChallenge, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseGetChallengeResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.protectedChallenge = ProtectedChallenge.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      protectedChallenge: isSet2(object.protectedChallenge) ? ProtectedChallenge.fromJSON(object.protectedChallenge) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.protectedChallenge !== void 0) {
+      obj.protectedChallenge = ProtectedChallenge.toJSON(message.protectedChallenge);
+    }
+    return obj;
+  },
+  create(base) {
+    return GetChallengeResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseGetChallengeResponse();
+    message.protectedChallenge = object.protectedChallenge !== void 0 && object.protectedChallenge !== null ? ProtectedChallenge.fromPartial(object.protectedChallenge) : void 0;
+    return message;
+  }
+};
+function createBaseVerifyChallengeRequest() {
+  return { protectedChallenge: void 0, signature: new Uint8Array(0), publicKey: new Uint8Array(0) };
+}
+var VerifyChallengeRequest = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.protectedChallenge !== void 0) {
+      ProtectedChallenge.encode(message.protectedChallenge, writer.uint32(10).fork()).join();
+    }
+    if (message.signature.length !== 0) {
+      writer.uint32(18).bytes(message.signature);
+    }
+    if (message.publicKey.length !== 0) {
+      writer.uint32(26).bytes(message.publicKey);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseVerifyChallengeRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.protectedChallenge = ProtectedChallenge.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.signature = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.publicKey = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      protectedChallenge: isSet2(object.protectedChallenge) ? ProtectedChallenge.fromJSON(object.protectedChallenge) : void 0,
+      signature: isSet2(object.signature) ? bytesFromBase642(object.signature) : new Uint8Array(0),
+      publicKey: isSet2(object.publicKey) ? bytesFromBase642(object.publicKey) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.protectedChallenge !== void 0) {
+      obj.protectedChallenge = ProtectedChallenge.toJSON(message.protectedChallenge);
+    }
+    if (message.signature.length !== 0) {
+      obj.signature = base64FromBytes2(message.signature);
+    }
+    if (message.publicKey.length !== 0) {
+      obj.publicKey = base64FromBytes2(message.publicKey);
+    }
+    return obj;
+  },
+  create(base) {
+    return VerifyChallengeRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseVerifyChallengeRequest();
+    message.protectedChallenge = object.protectedChallenge !== void 0 && object.protectedChallenge !== null ? ProtectedChallenge.fromPartial(object.protectedChallenge) : void 0;
+    message.signature = object.signature ?? new Uint8Array(0);
+    message.publicKey = object.publicKey ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseVerifyChallengeResponse() {
+  return { sessionToken: "", expirationTimestamp: 0 };
+}
+var VerifyChallengeResponse = {
+  encode(message, writer = new BinaryWriter2()) {
+    if (message.sessionToken !== "") {
+      writer.uint32(10).string(message.sessionToken);
+    }
+    if (message.expirationTimestamp !== 0) {
+      writer.uint32(16).int64(message.expirationTimestamp);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader2 ? input : new BinaryReader2(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseVerifyChallengeResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.sessionToken = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.expirationTimestamp = longToNumber(reader.int64());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      sessionToken: isSet2(object.sessionToken) ? globalThis.String(object.sessionToken) : "",
+      expirationTimestamp: isSet2(object.expirationTimestamp) ? globalThis.Number(object.expirationTimestamp) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.sessionToken !== "") {
+      obj.sessionToken = message.sessionToken;
+    }
+    if (message.expirationTimestamp !== 0) {
+      obj.expirationTimestamp = Math.round(message.expirationTimestamp);
+    }
+    return obj;
+  },
+  create(base) {
+    return VerifyChallengeResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseVerifyChallengeResponse();
+    message.sessionToken = object.sessionToken ?? "";
+    message.expirationTimestamp = object.expirationTimestamp ?? 0;
+    return message;
+  }
+};
+var SparkAuthnServiceDefinition = {
+  name: "SparkAuthnService",
+  fullName: "spark_authn.SparkAuthnService",
+  methods: {
+    /** Request a new authentication challenge for a public key */
+    get_challenge: {
+      name: "get_challenge",
+      requestType: GetChallengeRequest,
+      requestStream: false,
+      responseType: GetChallengeResponse,
+      responseStream: false,
+      options: {}
+    },
+    /** Verify a signed challenge and return a session token */
+    verify_challenge: {
+      name: "verify_challenge",
+      requestType: VerifyChallengeRequest,
+      requestStream: false,
+      responseType: VerifyChallengeResponse,
+      responseStream: false,
+      options: {}
+    }
+  }
+};
+function bytesFromBase642(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 base64FromBytes2(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 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 isSet2(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/services/connection.ts
+var ConnectionManager = class {
+  config;
+  clients = /* @__PURE__ */ new Map();
+  tokenClients = /* @__PURE__ */ new Map();
+  // We are going to .unref() the underlying channels for stream clients
+  // to prevent the stream from keeping the process alive
+  // Using a different map to avoid unforeseen problems with unary calls
+  streamClients = /* @__PURE__ */ new Map();
+  // Tracks in-flight authenticate() promises so concurrent callers share one
+  authPromises = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  // When initializing wallet, go ahead and instantiate all clients
+  async createClients() {
+    await Promise.all(
+      Object.values(this.config.getSigningOperators()).map((operator) => {
+        this.createSparkClient(operator.address);
+      })
+    );
+  }
+  async closeConnections() {
+    await Promise.all(
+      Array.from(this.clients.values()).map(
+        (client) => client.client.close?.()
+      )
+    );
+    this.clients.clear();
+  }
+  async createMockClient(address2) {
+    const channel = await this.createChannelWithTLS(address2);
+    const isNodeChannel = "close" in channel;
+    if (isNode2 && isNodeChannel && !isBun) {
+      const grpcModule = await import("nice-grpc");
+      const { createClient } = "default" in grpcModule ? grpcModule.default : grpcModule;
+      const client = createClient(MockServiceDefinition, channel);
+      return { ...client, close: () => channel.close() };
+    } else if (!isNodeChannel) {
+      const grpcModule = await import("nice-grpc-web");
+      const { createClient } = "default" in grpcModule ? grpcModule.default : grpcModule;
+      const client = createClient(MockServiceDefinition, channel);
+      return { ...client, close: () => {
+      } };
+    } else {
+      throw new Error("Channel does not have close in NodeJS environment");
+    }
+  }
+  async createChannelWithTLS(address2, certPath) {
+    try {
+      if (isNode2 && !isBun) {
+        const grpcModule = await import("nice-grpc");
+        const { ChannelCredentials, createChannel } = "default" in grpcModule ? grpcModule.default : grpcModule;
+        if (certPath) {
+          try {
+            const fs = await import("fs");
+            const cert = fs.readFileSync(certPath);
+            return createChannel(address2, ChannelCredentials.createSsl(cert));
+          } catch (error) {
+            console.error("Error reading certificate:", error);
+            return createChannel(
+              address2,
+              ChannelCredentials.createSsl(null, null, null, {
+                rejectUnauthorized: false
+              })
+            );
+          }
+        } else {
+          return createChannel(
+            address2,
+            ChannelCredentials.createSsl(null, null, null, {
+              rejectUnauthorized: false
+            })
+          );
+        }
+      } else {
+        const grpcModule = await import("nice-grpc-web");
+        const { createChannel, FetchTransport } = "default" in grpcModule ? grpcModule.default : grpcModule;
+        const { XHRTransport } = await import("./xhr-transport-RH6LDRXS.js");
+        return createChannel(
+          address2,
+          isReactNative ? XHRTransport() : FetchTransport()
+        );
+      }
+    } catch (error) {
+      console.error("Channel creation error:", error);
+      throw new NetworkError(
+        "Failed to create channel",
+        {
+          url: address2,
+          operation: "createChannel",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
+  }
+  async createSparkStreamClient(address2, certPath) {
+    if (this.streamClients.has(address2)) {
+      return this.streamClients.get(address2).client;
+    }
+    const authToken = await this.authenticate(address2);
+    const channel = await this.createChannelWithTLS(address2, certPath);
+    const middleware = this.createMiddleware(address2, authToken);
+    const client = await this.createGrpcClient(
+      SparkServiceDefinition,
+      channel,
+      true,
+      middleware
+    );
+    this.streamClients.set(address2, { client, authToken, channel });
+    return client;
+  }
+  async createSparkClient(address2, certPath) {
+    if (this.clients.has(address2)) {
+      return this.clients.get(address2).client;
+    }
+    const authToken = await this.authenticate(address2);
+    const channel = await this.createChannelWithTLS(address2, certPath);
+    const middleware = this.createMiddleware(address2, authToken);
+    const client = await this.createGrpcClient(
+      SparkServiceDefinition,
+      channel,
+      true,
+      middleware
+    );
+    this.clients.set(address2, { client, authToken });
+    return client;
+  }
+  async createSparkTokenClient(address2, certPath) {
+    if (this.tokenClients.has(address2)) {
+      return this.tokenClients.get(address2).client;
+    }
+    const authToken = await this.authenticate(address2);
+    const channel = await this.createChannelWithTLS(address2, certPath);
+    const middleware = this.createMiddleware(address2, authToken);
+    const tokenClient = await this.createGrpcClient(
+      SparkTokenServiceDefinition,
+      channel,
+      true,
+      middleware
+    );
+    this.tokenClients.set(address2, { client: tokenClient, authToken });
+    return tokenClient;
+  }
+  async getStreamChannel(address2) {
+    return this.streamClients.get(address2)?.channel;
+  }
+  async authenticate(address2, certPath) {
+    const existing = this.authPromises.get(address2);
+    if (existing) {
+      return existing;
+    }
+    const authPromise = (async () => {
+      const MAX_ATTEMPTS = 3;
+      let lastError;
+      for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        let sparkAuthnClient;
+        try {
+          const identityPublicKey = await this.config.signer.getIdentityPublicKey();
+          sparkAuthnClient = await this.createSparkAuthnGrpcConnection(
+            address2,
+            certPath
+          );
+          const challengeResp = await sparkAuthnClient.get_challenge({
+            publicKey: identityPublicKey
+          });
+          if (!challengeResp.protectedChallenge?.challenge) {
+            throw new AuthenticationError("Invalid challenge response", {
+              endpoint: "get_challenge",
+              reason: "Missing challenge in response"
+            });
+          }
+          const challengeBytes = Challenge.encode(
+            challengeResp.protectedChallenge.challenge
+          ).finish();
+          const hash = sha2564(challengeBytes);
+          const derSignatureBytes = await this.config.signer.signMessageWithIdentityKey(hash);
+          const verifyResp = await sparkAuthnClient.verify_challenge({
+            protectedChallenge: challengeResp.protectedChallenge,
+            signature: derSignatureBytes,
+            publicKey: identityPublicKey
+          });
+          sparkAuthnClient.close?.();
+          return verifyResp.sessionToken;
+        } catch (error) {
+          if (isError(error)) {
+            sparkAuthnClient?.close?.();
+            if (error.message.includes("challenge expired")) {
+              console.warn(
+                `Authentication attempt ${attempt + 1} failed due to expired challenge, retrying...`
+              );
+              lastError = error;
+              continue;
+            }
+            throw new AuthenticationError(
+              "Authentication failed",
+              {
+                endpoint: "authenticate",
+                reason: error.message
+              },
+              error
+            );
+          } else {
+            lastError = new Error(
+              `Unknown error during authentication: ${String(error)}`
+            );
+          }
+        }
+      }
+      throw new AuthenticationError(
+        "Authentication failed after retrying expired challenges",
+        {
+          endpoint: "authenticate",
+          reason: lastError?.message ?? "Unknown error"
+        },
+        lastError
+      );
+    })();
+    this.authPromises.set(address2, authPromise);
+    try {
+      return await authPromise;
+    } finally {
+      this.authPromises.delete(address2);
+    }
+  }
+  async createSparkAuthnGrpcConnection(address2, certPath) {
+    const channel = await this.createChannelWithTLS(address2, certPath);
+    const authnMiddleware = this.createAuthnMiddleware();
+    return this.createGrpcClient(
+      SparkAuthnServiceDefinition,
+      channel,
+      false,
+      authnMiddleware
+    );
+  }
+  createAuthnMiddleware() {
+    if (isNode2) {
+      return async function* (call, options) {
+        const metadata = Metadata(options.metadata).set(
+          "X-Client-Env",
+          clientEnv
+        );
+        return yield* call.next(call.request, {
+          ...options,
+          metadata
+        });
+      }.bind(this);
+    } else {
+      return async function* (call, options) {
+        const metadata = Metadata(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("X-Client-Env", clientEnv).set("Content-Type", "application/grpc-web+proto");
+        return yield* call.next(call.request, {
+          ...options,
+          metadata
+        });
+      }.bind(this);
+    }
+  }
+  createMiddleware(address2, authToken) {
+    if (isNode2) {
+      return this.createNodeMiddleware(address2, authToken);
+    } else {
+      return this.createBrowserMiddleware(address2, authToken);
+    }
+  }
+  async *handleMiddlewareError(error, address2, call, metadata, options) {
+    if (isError(error)) {
+      if (error.message.includes("token has expired")) {
+        const newAuthToken = await this.authenticate(address2);
+        const clientData = this.clients.get(address2);
+        if (!clientData) {
+          throw new Error(`No client found for address: ${address2}`);
+        }
+        clientData.authToken = newAuthToken;
+        return yield* call.next(call.request, {
+          ...options,
+          metadata: metadata.set("Authorization", `Bearer ${newAuthToken}`)
+        });
+      }
+    }
+    throw error;
+  }
+  createNodeMiddleware(address2, initialAuthToken) {
+    return async function* (call, options) {
+      const metadata = Metadata(options.metadata).set(
+        "X-Client-Env",
+        clientEnv
+      );
+      try {
+        return yield* call.next(call.request, {
+          ...options,
+          metadata: metadata.set(
+            "Authorization",
+            `Bearer ${this.clients.get(address2)?.authToken || initialAuthToken}`
+          )
+        });
+      } catch (error) {
+        return yield* this.handleMiddlewareError(
+          error,
+          address2,
+          call,
+          metadata,
+          options
+        );
+      }
+    }.bind(this);
+  }
+  createBrowserMiddleware(address2, initialAuthToken) {
+    return async function* (call, options) {
+      const metadata = Metadata(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("X-Client-Env", clientEnv).set("Content-Type", "application/grpc-web+proto");
+      try {
+        return yield* call.next(call.request, {
+          ...options,
+          metadata: metadata.set(
+            "Authorization",
+            `Bearer ${this.clients.get(address2)?.authToken || initialAuthToken}`
+          )
+        });
+      } catch (error) {
+        return yield* this.handleMiddlewareError(
+          error,
+          address2,
+          call,
+          metadata,
+          options
+        );
+      }
+    }.bind(this);
+  }
+  async createGrpcClient(defintion, channel, withRetries, middleware) {
+    let clientFactory;
+    const retryOptions = {
+      retry: true,
+      retryMaxAttempts: 3
+    };
+    let options = {};
+    const isNodeChannel = "close" in channel;
+    if (isNode2 && isNodeChannel && !isBun) {
+      const grpcModule = await import("nice-grpc");
+      const { openTelemetryClientMiddleware } = await import("nice-grpc-opentelemetry");
+      const { createClientFactory } = "default" in grpcModule ? grpcModule.default : grpcModule;
+      clientFactory = createClientFactory();
+      if (withRetries) {
+        options = retryOptions;
+        clientFactory = clientFactory.use(openTelemetryClientMiddleware()).use(retryMiddleware);
+      }
+      if (middleware) {
+        clientFactory = clientFactory.use(middleware);
+      }
+      const client = clientFactory.create(defintion, channel, {
+        "*": options
+      });
+      return {
+        ...client,
+        close: channel.close.bind(channel)
+      };
+    } else if (!isNodeChannel) {
+      const grpcModule = await import("nice-grpc-web");
+      const { createClientFactory } = "default" in grpcModule ? grpcModule.default : grpcModule;
+      clientFactory = createClientFactory();
+      if (withRetries) {
+        options = retryOptions;
+        clientFactory = clientFactory.use(retryMiddleware);
+      }
+      if (middleware) {
+        clientFactory = clientFactory.use(middleware);
+      }
+      const client = clientFactory.create(defintion, channel, {
+        "*": options
+      });
+      return {
+        ...client,
+        close: void 0
+      };
+    } else {
+      throw new Error("Channel does not have close in NodeJS environment");
+    }
+  }
+};
+
+// src/services/deposit.ts
+import { schnorr as schnorr4, secp256k1 as secp256k17 } from "@noble/curves/secp256k1";
+import { sha256 as sha2565 } from "@noble/hashes/sha2";
+import { hexToBytes as hexToBytes3 } from "@noble/hashes/utils";
+import * as btc3 from "@scure/btc-signer";
+import { p2tr as p2tr2, Transaction as Transaction3 } from "@scure/btc-signer";
+import { equalBytes as equalBytes3 } from "@scure/btc-signer/utils";
+var INITIAL_TIME_LOCK = 2e3;
+var DepositService = class {
+  config;
+  connectionManager;
+  constructor(config, connectionManager) {
+    this.config = config;
+    this.connectionManager = connectionManager;
+  }
+  async validateDepositAddress({
+    address: address2,
+    userPubkey
+  }) {
+    if (!address2.depositAddressProof || !address2.depositAddressProof.proofOfPossessionSignature || !address2.depositAddressProof.addressSignatures) {
+      throw new ValidationError(
+        "Proof of possession signature or address signatures is null",
+        {
+          field: "depositAddressProof",
+          value: address2.depositAddressProof
+        }
+      );
+    }
+    const operatorPubkey = subtractPublicKeys(address2.verifyingKey, userPubkey);
+    const msg = proofOfPossessionMessageHashForDepositAddress(
+      await this.config.signer.getIdentityPublicKey(),
+      operatorPubkey,
+      address2.address
+    );
+    const taprootKey = p2tr2(
+      operatorPubkey.slice(1, 33),
+      void 0,
+      getNetwork(this.config.getNetwork())
+    ).tweakedPubkey;
+    const isVerified = schnorr4.verify(
+      address2.depositAddressProof.proofOfPossessionSignature,
+      msg,
+      taprootKey
+    );
+    if (!isVerified) {
+      throw new ValidationError(
+        "Proof of possession signature verification failed",
+        {
+          field: "proofOfPossessionSignature",
+          value: address2.depositAddressProof.proofOfPossessionSignature
+        }
+      );
+    }
+    const addrHash = sha2565(address2.address);
+    for (const operator of Object.values(this.config.getSigningOperators())) {
+      if (operator.identifier === this.config.getCoordinatorIdentifier()) {
+        continue;
+      }
+      const operatorPubkey2 = hexToBytes3(operator.identityPublicKey);
+      const operatorSig = address2.depositAddressProof.addressSignatures[operator.identifier];
+      if (!operatorSig) {
+        throw new ValidationError("Operator signature not found", {
+          field: "addressSignatures",
+          value: operator.identifier
+        });
+      }
+      const sig = secp256k17.Signature.fromDER(operatorSig);
+      const isVerified2 = secp256k17.verify(sig, addrHash, operatorPubkey2);
+      if (!isVerified2) {
+        throw new ValidationError("Operator signature verification failed", {
+          field: "operatorSignature",
+          value: operatorSig
+        });
+      }
+    }
+  }
+  async generateDepositAddress({
+    signingPubkey,
+    leafId,
+    isStatic = false
+  }) {
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let depositResp;
+    try {
+      depositResp = await sparkClient.generate_deposit_address({
+        signingPublicKey: signingPubkey,
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        network: this.config.getNetworkProto(),
+        leafId,
+        isStatic
+      });
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to generate deposit address",
+        {
+          operation: "generate_deposit_address",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
+    if (!depositResp.depositAddress) {
+      throw new ValidationError(
+        "No deposit address response from coordinator",
+        {
+          field: "depositAddress",
+          value: depositResp
+        }
+      );
+    }
+    await this.validateDepositAddress({
+      address: depositResp.depositAddress,
+      userPubkey: signingPubkey
+    });
+    return depositResp;
+  }
+  async createTreeRoot({
+    signingPubKey,
+    verifyingKey,
+    depositTx,
+    vout
+  }) {
+    const rootTx = new Transaction3({ version: 3 });
+    const output = depositTx.getOutput(vout);
+    if (!output) {
+      throw new ValidationError("Invalid deposit transaction output", {
+        field: "vout",
+        value: vout,
+        expected: "Valid output index"
+      });
+    }
+    const script = output.script;
+    const amount = output.amount;
+    if (!script || !amount) {
+      throw new ValidationError("No script or amount found in deposit tx", {
+        field: "output",
+        value: output,
+        expected: "Output with script and amount"
+      });
+    }
+    let outputAmount = amount;
+    rootTx.addInput({
+      txid: getTxId(depositTx),
+      index: vout
+    });
+    rootTx.addOutput({
+      script,
+      amount: outputAmount
+    });
+    rootTx.addOutput(getEphemeralAnchorOutput());
+    const rootNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const rootTxSighash = getSigHashFromTx(rootTx, 0, output);
+    const refundTx = new Transaction3({ version: 3 });
+    const sequence = 1 << 30 | INITIAL_TIME_LOCK;
+    refundTx.addInput({
+      txid: getTxId(rootTx),
+      index: 0,
+      sequence
+    });
+    const refundP2trAddress = getP2TRAddressFromPublicKey(
+      signingPubKey,
+      this.config.getNetwork()
+    );
+    const refundAddress = btc3.Address(getNetwork(this.config.getNetwork())).decode(refundP2trAddress);
+    const refundPkScript = btc3.OutScript.encode(refundAddress);
+    refundTx.addOutput({
+      script: refundPkScript,
+      amount: outputAmount
+    });
+    refundTx.addOutput(getEphemeralAnchorOutput());
+    const refundNonceCommitment = await this.config.signer.getRandomSigningCommitment();
+    const refundTxSighash = getSigHashFromTx(refundTx, 0, rootTx.getOutput(0));
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress()
+    );
+    let treeResp;
+    try {
+      treeResp = await sparkClient.start_deposit_tree_creation({
+        identityPublicKey: await this.config.signer.getIdentityPublicKey(),
+        onChainUtxo: {
+          vout,
+          rawTx: depositTx.toBytes(true),
+          network: this.config.getNetworkProto()
+        },
+        rootTxSigningJob: {
+          rawTx: rootTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: rootNonceCommitment
+        },
+        refundTxSigningJob: {
+          rawTx: refundTx.toBytes(),
+          signingPublicKey: signingPubKey,
+          signingNonceCommitment: refundNonceCommitment
+        }
+      });
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to start deposit tree creation",
+        {
+          operation: "start_deposit_tree_creation",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
+    if (!treeResp.rootNodeSignatureShares?.verifyingKey) {
+      throw new ValidationError("No verifying key found in tree response", {
+        field: "verifyingKey",
+        value: treeResp.rootNodeSignatureShares,
+        expected: "Non-null verifying key"
+      });
+    }
+    if (!treeResp.rootNodeSignatureShares.nodeTxSigningResult?.signingNonceCommitments) {
+      throw new ValidationError(
+        "No signing nonce commitments found in tree response",
+        {
+          field: "nodeTxSigningResult.signingNonceCommitments",
+          value: treeResp.rootNodeSignatureShares.nodeTxSigningResult,
+          expected: "Non-null signing nonce commitments"
+        }
+      );
+    }
+    if (!treeResp.rootNodeSignatureShares.refundTxSigningResult?.signingNonceCommitments) {
+      throw new ValidationError(
+        "No signing nonce commitments found in tree response",
+        {
+          field: "refundTxSigningResult.signingNonceCommitments"
+        }
+      );
+    }
+    if (!equalBytes3(treeResp.rootNodeSignatureShares.verifyingKey, verifyingKey)) {
+      throw new ValidationError("Verifying key mismatch", {
+        field: "verifyingKey",
+        value: treeResp.rootNodeSignatureShares.verifyingKey,
+        expected: verifyingKey
+      });
+    }
+    const rootSignature = await this.config.signer.signFrost({
+      message: rootTxSighash,
+      publicKey: signingPubKey,
+      privateAsPubKey: signingPubKey,
+      verifyingKey,
+      selfCommitment: rootNonceCommitment,
+      statechainCommitments: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const refundSignature = await this.config.signer.signFrost({
+      message: refundTxSighash,
+      publicKey: signingPubKey,
+      privateAsPubKey: signingPubKey,
+      verifyingKey,
+      selfCommitment: refundNonceCommitment,
+      statechainCommitments: treeResp.rootNodeSignatureShares.refundTxSigningResult.signingNonceCommitments,
+      adaptorPubKey: new Uint8Array()
+    });
+    const rootAggregate = await this.config.signer.aggregateFrost({
+      message: rootTxSighash,
+      statechainSignatures: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signatureShares,
+      statechainPublicKeys: treeResp.rootNodeSignatureShares.nodeTxSigningResult.publicKeys,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      statechainCommitments: treeResp.rootNodeSignatureShares.nodeTxSigningResult.signingNonceCommitments,
+      selfCommitment: rootNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: rootSignature,
+      adaptorPubKey: new Uint8Array()
+    });
+    const refundAggregate = await this.config.signer.aggregateFrost({
+      message: refundTxSighash,
+      statechainSignatures: treeResp.rootNodeSignatureShares.refundTxSigningResult.signatureShares,
+      statechainPublicKeys: treeResp.rootNodeSignatureShares.refundTxSigningResult.publicKeys,
+      verifyingKey: treeResp.rootNodeSignatureShares.verifyingKey,
+      statechainCommitments: treeResp.rootNodeSignatureShares.refundTxSigningResult.signingNonceCommitments,
+      selfCommitment: refundNonceCommitment,
+      publicKey: signingPubKey,
+      selfSignature: refundSignature,
+      adaptorPubKey: new Uint8Array()
+    });
+    let finalizeResp;
+    try {
+      finalizeResp = await sparkClient.finalize_node_signatures({
+        intent: 0 /* CREATION */,
+        nodeSignatures: [
+          {
+            nodeId: treeResp.rootNodeSignatureShares.nodeId,
+            nodeTxSignature: rootAggregate,
+            refundTxSignature: refundAggregate
+          }
+        ]
+      });
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to finalize node signatures",
+        {
+          operation: "finalize_node_signatures",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
+    return finalizeResp;
+  }
+};
+
+// src/tests/utils/test-faucet.ts
+import { bytesToHex as bytesToHex5, hexToBytes as hexToBytes4 } from "@noble/curves/abstract/utils";
+import { schnorr as schnorr5, secp256k1 as secp256k18 } from "@noble/curves/secp256k1";
+import * as btc4 from "@scure/btc-signer";
+import { Address as Address3, OutScript as OutScript3, SigHash as SigHash2, Transaction as Transaction4 } from "@scure/btc-signer";
+import { taprootTweakPrivKey as taprootTweakPrivKey2 } from "@scure/btc-signer/utils";
+var STATIC_FAUCET_KEY = hexToBytes4(
+  "deadbeef1337cafe4242424242424242deadbeef1337cafe4242424242424242"
+);
+var STATIC_MINING_KEY = hexToBytes4(
+  "1337cafe4242deadbeef4242424242421337cafe4242deadbeef424242424242"
+);
+var SATS_PER_BTC = 1e8;
+var COIN_AMOUNT = 10000000n;
+var FEE_AMOUNT = 1000n;
+var TARGET_NUM_COINS = 20;
+var BitcoinFaucet = class _BitcoinFaucet {
+  constructor(url = "http://127.0.0.1:8332", username = "testutil", password = "testutilpassword") {
+    this.url = url;
+    this.username = username;
+    this.password = password;
+    this.miningAddress = getP2TRAddressFromPublicKey(
+      secp256k18.getPublicKey(STATIC_MINING_KEY),
+      4 /* LOCAL */
+    );
+  }
+  coins = [];
+  static instance = null;
+  miningAddress;
+  lock = Promise.resolve();
+  static getInstance(url = "http://127.0.0.1:8332", username = "testutil", password = "testutilpassword") {
+    if (!_BitcoinFaucet.instance) {
+      _BitcoinFaucet.instance = new _BitcoinFaucet(url, username, password);
+    }
+    return _BitcoinFaucet.instance;
+  }
+  async withLock(operation) {
+    const current = this.lock;
+    let resolve;
+    this.lock = new Promise((r) => resolve = r);
+    await current;
+    try {
+      return await operation();
+    } finally {
+      resolve();
+    }
+  }
+  async fund() {
+    return this.withLock(async () => {
+      if (this.coins.length === 0) {
+        await this.refill();
+      }
+      const coin = this.coins[0];
+      if (!coin) {
+        throw new Error("Failed to get coin from faucet");
+      }
+      this.coins = this.coins.slice(1);
+      return coin;
+    });
+  }
+  async refill() {
+    const minerPubKey = secp256k18.getPublicKey(STATIC_MINING_KEY);
+    const address2 = getP2TRAddressFromPublicKey(minerPubKey, 4 /* LOCAL */);
+    const scanResult = await this.call("scantxoutset", [
+      "start",
+      [`addr(${address2})`]
+    ]);
+    let selectedUtxo;
+    let selectedUtxoAmountSats;
+    if (!scanResult.success || scanResult.unspents.length === 0) {
+      const blockHash = await this.generateToAddress(1, address2);
+      const block = await this.getBlock(blockHash[0]);
+      const fundingTx = Transaction4.fromRaw(hexToBytes4(block.tx[0].hex), {
+        allowUnknownOutputs: true
+      });
+      await this.generateToAddress(100, this.miningAddress);
+      selectedUtxo = {
+        txid: block.tx[0].txid,
+        vout: 0,
+        amount: fundingTx.getOutput(0).amount
+        // Already in sats
+      };
+      selectedUtxoAmountSats = BigInt(selectedUtxo.amount);
+    } else {
+      selectedUtxo = scanResult.unspents.find((utxo) => {
+        const isValueEnough = BigInt(Math.floor(utxo.amount * SATS_PER_BTC)) >= COIN_AMOUNT + FEE_AMOUNT;
+        const isMature = scanResult.height - utxo.height >= 100;
+        return isValueEnough && isMature;
+      });
+      if (!selectedUtxo) {
+        throw new Error("No UTXO large enough to create even one faucet coin");
+      }
+      selectedUtxoAmountSats = BigInt(
+        Math.floor(selectedUtxo.amount * SATS_PER_BTC)
+      );
+    }
+    const maxPossibleCoins = Number(
+      (selectedUtxoAmountSats - FEE_AMOUNT) / COIN_AMOUNT
+    );
+    const numCoinsToCreate = Math.min(maxPossibleCoins, TARGET_NUM_COINS);
+    if (numCoinsToCreate < 1) {
+      throw new Error(
+        `Selected UTXO (${selectedUtxoAmountSats} sats) is too small to create even one faucet coin of ${COIN_AMOUNT} sats`
+      );
+    }
+    const splitTx = new Transaction4();
+    splitTx.addInput({
+      txid: selectedUtxo.txid,
+      index: selectedUtxo.vout
+    });
+    const faucetPubKey = secp256k18.getPublicKey(STATIC_FAUCET_KEY);
+    const script = getP2TRScriptFromPublicKey(faucetPubKey, 4 /* LOCAL */);
+    for (let i = 0; i < numCoinsToCreate; i++) {
+      splitTx.addOutput({
+        script,
+        amount: COIN_AMOUNT
+      });
+    }
+    const remainingValue = selectedUtxoAmountSats - COIN_AMOUNT * BigInt(numCoinsToCreate) - FEE_AMOUNT;
+    const minerScript = getP2TRScriptFromPublicKey(minerPubKey, 4 /* LOCAL */);
+    if (remainingValue > 0n) {
+      splitTx.addOutput({
+        script: minerScript,
+        amount: remainingValue
+      });
+    }
+    const signedSplitTx = await this.signFaucetCoin(
+      splitTx,
+      {
+        amount: selectedUtxoAmountSats,
+        script: minerScript
+      },
+      STATIC_MINING_KEY
+    );
+    await this.broadcastTx(bytesToHex5(signedSplitTx.extract()));
+    const splitTxId = signedSplitTx.id;
+    for (let i = 0; i < numCoinsToCreate; i++) {
+      this.coins.push({
+        key: STATIC_FAUCET_KEY,
+        outpoint: {
+          txid: hexToBytes4(splitTxId),
+          index: i
+        },
+        txout: signedSplitTx.getOutput(i)
+      });
+    }
+  }
+  async sendFaucetCoinToP2WPKHAddress(pubKey) {
+    const sendToPubKeyTx = new Transaction4();
+    const p2wpkhAddress = btc4.p2wpkh(pubKey, getNetwork(4 /* LOCAL */)).address;
+    if (!p2wpkhAddress) {
+      throw new Error("Invalid P2WPKH address");
+    }
+    const coinToSend = await this.fund();
+    if (!coinToSend) {
+      throw new Error("No coins available");
+    }
+    sendToPubKeyTx.addInput(coinToSend.outpoint);
+    sendToPubKeyTx.addOutputAddress(
+      p2wpkhAddress,
+      COIN_AMOUNT - FEE_AMOUNT,
+      getNetwork(4 /* LOCAL */)
+    );
+    const signedTx = await this.signFaucetCoin(
+      sendToPubKeyTx,
+      coinToSend.txout,
+      coinToSend.key
+    );
+    await this.broadcastTx(bytesToHex5(signedTx.extract()));
+  }
+  async signFaucetCoin(unsignedTx, fundingTxOut, key) {
+    const pubKey = secp256k18.getPublicKey(key);
+    const internalKey = pubKey.slice(1);
+    const script = getP2TRScriptFromPublicKey(pubKey, 4 /* LOCAL */);
+    unsignedTx.updateInput(0, {
+      tapInternalKey: internalKey,
+      witnessUtxo: {
+        script,
+        amount: fundingTxOut.amount
+      }
+    });
+    const sighash = unsignedTx.preimageWitnessV1(
+      0,
+      new Array(unsignedTx.inputsLength).fill(script),
+      SigHash2.DEFAULT,
+      new Array(unsignedTx.inputsLength).fill(fundingTxOut.amount)
+    );
+    const merkleRoot = new Uint8Array();
+    const tweakedKey = taprootTweakPrivKey2(key, merkleRoot);
+    if (!tweakedKey)
+      throw new Error("Invalid private key for taproot tweaking");
+    const signature = schnorr5.sign(sighash, tweakedKey);
+    unsignedTx.updateInput(0, {
+      tapKeySig: signature
+    });
+    unsignedTx.finalize();
+    return unsignedTx;
+  }
+  // MineBlocks mines the specified number of blocks to a random address
+  // and returns the block hashes.
+  async mineBlocks(numBlocks) {
+    return await this.generateToAddress(numBlocks, this.miningAddress);
+  }
+  async call(method, params) {
+    try {
+      const response = await fetch(this.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Basic " + btoa(`${this.username}:${this.password}`)
+        },
+        body: JSON.stringify({
+          jsonrpc: "1.0",
+          id: "spark-js",
+          method,
+          params
+        })
+      });
+      const data = await response.json();
+      if (data.error) {
+        console.error(`RPC Error for method ${method}:`, data.error);
+        throw new RPCError(`Bitcoin RPC error: ${data.error.message}`, {
+          method,
+          params,
+          code: data.error.code
+        });
+      }
+      return data.result;
+    } catch (error) {
+      if (error instanceof RPCError) {
+        throw error;
+      }
+      throw new RPCError(
+        "Failed to call Bitcoin RPC",
+        {
+          method,
+          params
+        },
+        error
+      );
+    }
+  }
+  async generateToAddress(numBlocks, address2) {
+    return await this.call("generatetoaddress", [numBlocks, address2]);
+  }
+  async getBlock(blockHash) {
+    return await this.call("getblock", [blockHash, 2]);
+  }
+  async broadcastTx(txHex) {
+    let response = await this.call("sendrawtransaction", [txHex, 0]);
+    return response;
+  }
+  async getNewAddress() {
+    const key = secp256k18.utils.randomPrivateKey();
+    const pubKey = secp256k18.getPublicKey(key);
+    return getP2TRAddressFromPublicKey(pubKey, 4 /* LOCAL */);
+  }
+  async sendToAddress(address2, amount) {
+    const coin = await this.fund();
+    if (!coin) {
+      throw new Error("No coins available");
+    }
+    const tx = new Transaction4();
+    tx.addInput(coin.outpoint);
+    const availableAmount = COIN_AMOUNT - FEE_AMOUNT;
+    const destinationAddress = Address3(getNetwork(4 /* LOCAL */)).decode(
+      address2
+    );
+    const destinationScript = OutScript3.encode(destinationAddress);
+    tx.addOutput({
+      script: destinationScript,
+      amount
+    });
+    const changeAmount = availableAmount - amount;
+    if (changeAmount > 0) {
+      const changeKey = secp256k18.utils.randomPrivateKey();
+      const changePubKey = secp256k18.getPublicKey(changeKey);
+      const changeScript = getP2TRScriptFromPublicKey(
+        changePubKey,
+        4 /* LOCAL */
+      );
+      tx.addOutput({
+        script: changeScript,
+        amount: changeAmount
+      });
+    }
+    const signedTx = await this.signFaucetCoin(tx, coin.txout, coin.key);
+    const txHex = bytesToHex5(signedTx.extract());
+    await this.broadcastTx(txHex);
+    const randomKey = secp256k18.utils.randomPrivateKey();
+    const randomPubKey = secp256k18.getPublicKey(randomKey);
+    const randomAddress = getP2TRAddressFromPublicKey(
+      randomPubKey,
+      4 /* LOCAL */
+    );
+    await this.generateToAddress(1, randomAddress);
+    return signedTx;
+  }
+  async getRawTransaction(txid) {
+    return await this.call("getrawtransaction", [txid, 2]);
+  }
+};
+
+export {
+  getCrypto,
+  setCrypto,
+  SparkSDKError,
+  NetworkError,
+  ValidationError,
+  InternalValidationError,
+  AuthenticationError,
+  RPCError,
+  ConfigurationError,
+  NotImplementedError,
+  generateSignatureFromExistingAdaptor,
+  generateAdaptorFromSignature,
+  validateOutboundAdaptorSignature,
+  applyAdaptorToSignature,
+  Network2 as Network,
+  NetworkToProto,
+  protoToNetwork,
+  getNetwork,
+  LRC_WALLET_NETWORK,
+  LRC_WALLET_NETWORK_TYPE,
+  getNetworkFromAddress,
+  getNetworkFromString,
+  computeTaprootKeyNoScript,
+  getP2TRScriptFromPublicKey,
+  getP2TRAddressFromPublicKey,
+  getP2TRAddressFromPkScript,
+  getP2WPKHAddressFromPublicKey,
+  getTxFromRawTxHex,
+  getTxFromRawTxBytes,
+  getSigHashFromTx,
+  getTxId,
+  getTxIdNoReverse,
+  addPublicKeys,
+  applyAdditiveTweakToPublicKey,
+  subtractPublicKeys,
+  addPrivateKeys,
+  subtractPrivateKeys,
+  sumOfPrivateKeys,
+  lastKeyWithTarget,
+  ELECTRS_CREDENTIALS,
+  getElectrsUrl,
+  WalletConfig,
+  proofOfPossessionMessageHashForDepositAddress,
+  getRandomBigInt,
+  modInverse,
+  evaluatePolynomial,
+  fieldDiv,
+  computerLagrangeCoefficients,
+  generatePolynomialForSecretSharing,
+  splitSecret,
+  splitSecretWithProofs,
+  recoverSecret,
+  validateShare,
+  bigIntToPrivateKey,
+  getRandomSigningNonce,
+  createSigningNonce,
+  getSigningCommitmentFromNonce,
+  encodeSigningNonceToBytes,
+  decodeBytesToSigningNonce,
+  createSigningCommitment,
+  encodeSigningCommitmentToBytes,
+  decodeBytesToSigningCommitment,
+  DEFAULT_FEE_SATS,
+  maybeApplyFee,
+  createRefundTx,
+  getCurrentTimelock,
+  getTransactionSequence,
+  checkIfValidSequence,
+  getNextTransactionSequence,
+  getEphemeralAnchorOutput,
+  isReactNative,
+  TaprootOutputKeysGenerator,
+  DefaultSparkSigner,
+  TaprootSparkSigner,
+  WalletConfigService,
+  ConnectionManager,
+  DepositService,
+  BitcoinFaucet
+};