otx-btc-wallet-connectors 0.1.0

package/dist/chunk-FISNQZZ7.js

@@ -0,0 +1,802 @@
+'use strict';
+
+var bitcoin = require('bitcoinjs-lib');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var bitcoin__namespace = /*#__PURE__*/_interopNamespace(bitcoin);
+
+// src/utils/mempool.ts
+var DEFAULT_MEMPOOL_ENDPOINTS = {
+  mainnet: "https://mempool.space/api",
+  testnet: "https://mempool.space/testnet/api",
+  testnet4: "https://mempool.space/testnet4/api",
+  signet: "https://mempool.space/signet/api"
+};
+async function fetchWithTimeout(url, options, timeout = 1e4) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+var MempoolService = class {
+  constructor(network = "mainnet", customEndpoints) {
+    this.name = "mempool";
+    this._network = network;
+    this._customEndpoints = customEndpoints ?? {};
+  }
+  get network() {
+    return this._network;
+  }
+  get baseUrl() {
+    return this._customEndpoints[this._network] ?? DEFAULT_MEMPOOL_ENDPOINTS[this._network];
+  }
+  setNetwork(network) {
+    this._network = network;
+  }
+  /**
+   * Set custom endpoints for this service
+   */
+  setCustomEndpoints(endpoints) {
+    this._customEndpoints = { ...this._customEndpoints, ...endpoints };
+  }
+  /**
+   * Get current endpoints configuration
+   */
+  getEndpoints() {
+    return {
+      mainnet: this._customEndpoints.mainnet ?? DEFAULT_MEMPOOL_ENDPOINTS.mainnet,
+      testnet: this._customEndpoints.testnet ?? DEFAULT_MEMPOOL_ENDPOINTS.testnet,
+      testnet4: this._customEndpoints.testnet4 ?? DEFAULT_MEMPOOL_ENDPOINTS.testnet4,
+      signet: this._customEndpoints.signet ?? DEFAULT_MEMPOOL_ENDPOINTS.signet
+    };
+  }
+  // ============ UTXO Methods ============
+  async getUtxos(address2) {
+    const response = await fetchWithTimeout(`${this.baseUrl}/address/${address2}/utxo`);
+    if (!response.ok) {
+      throw new Error(`Mempool API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getUtxosWithTxHex(address2) {
+    const utxos = await this.getUtxos(address2);
+    const utxosWithTx = await Promise.all(
+      utxos.map(async (utxo) => {
+        const txHex = await this.getTxHex(utxo.txid);
+        return { ...utxo, txHex };
+      })
+    );
+    return utxosWithTx;
+  }
+  // ============ Transaction Methods ============
+  async getTxHex(txid) {
+    const response = await fetchWithTimeout(`${this.baseUrl}/tx/${txid}/hex`);
+    if (!response.ok) {
+      throw new Error(`Mempool API error: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+  }
+  async getTransaction(txid) {
+    const response = await fetchWithTimeout(`${this.baseUrl}/tx/${txid}`);
+    if (!response.ok) {
+      throw new Error(`Mempool API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getFullTransaction(txid) {
+    const response = await fetchWithTimeout(`${this.baseUrl}/tx/${txid}`);
+    if (!response.ok) {
+      throw new Error(`Mempool API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async broadcastTransaction(txHex) {
+    const response = await fetchWithTimeout(
+      `${this.baseUrl}/tx`,
+      {
+        method: "POST",
+        body: txHex,
+        headers: { "Content-Type": "text/plain" }
+      },
+      3e4
+    );
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Mempool broadcast error: ${error}`);
+    }
+    return response.text();
+  }
+  // ============ Address Methods ============
+  async getAddressInfo(address2) {
+    const response = await fetchWithTimeout(`${this.baseUrl}/address/${address2}`);
+    if (!response.ok) {
+      throw new Error(`Mempool API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getBalance(address2) {
+    const info = await this.getAddressInfo(address2);
+    const confirmedBalance = info.chain_stats.funded_txo_sum - info.chain_stats.spent_txo_sum;
+    const unconfirmedBalance = info.mempool_stats.funded_txo_sum - info.mempool_stats.spent_txo_sum;
+    return confirmedBalance + unconfirmedBalance;
+  }
+  async getConfirmedBalance(address2) {
+    const info = await this.getAddressInfo(address2);
+    return info.chain_stats.funded_txo_sum - info.chain_stats.spent_txo_sum;
+  }
+  // ============ Fee Methods ============
+  async getFeeRates() {
+    const response = await fetchWithTimeout(`${this.baseUrl}/v1/fees/recommended`);
+    if (!response.ok) {
+      throw new Error(`Mempool API error: ${response.status} ${response.statusText}`);
+    }
+    const fees = await response.json();
+    return {
+      fastest: fees.fastestFee,
+      halfHour: fees.halfHourFee,
+      hour: fees.hourFee,
+      economy: fees.economyFee,
+      minimum: fees.minimumFee
+    };
+  }
+};
+
+// src/utils/blockstream.ts
+var DEFAULT_BLOCKSTREAM_ENDPOINTS = {
+  mainnet: "https://blockstream.info/api",
+  testnet: "https://blockstream.info/testnet/api",
+  testnet4: "https://mempool.space/testnet4/api",
+  // Fallback to mempool
+  signet: "https://mempool.space/signet/api"
+  // Fallback to mempool
+};
+async function fetchWithTimeout2(url, options, timeout = 1e4) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+var BlockstreamService = class {
+  constructor(network = "mainnet", customEndpoints) {
+    this.name = "blockstream";
+    this._network = network;
+    this._customEndpoints = customEndpoints ?? {};
+  }
+  get network() {
+    return this._network;
+  }
+  get baseUrl() {
+    return this._customEndpoints[this._network] ?? DEFAULT_BLOCKSTREAM_ENDPOINTS[this._network];
+  }
+  setNetwork(network) {
+    this._network = network;
+  }
+  /**
+   * Set custom endpoints for this service
+   */
+  setCustomEndpoints(endpoints) {
+    this._customEndpoints = { ...this._customEndpoints, ...endpoints };
+  }
+  /**
+   * Get current endpoints configuration
+   */
+  getEndpoints() {
+    return {
+      mainnet: this._customEndpoints.mainnet ?? DEFAULT_BLOCKSTREAM_ENDPOINTS.mainnet,
+      testnet: this._customEndpoints.testnet ?? DEFAULT_BLOCKSTREAM_ENDPOINTS.testnet,
+      testnet4: this._customEndpoints.testnet4 ?? DEFAULT_BLOCKSTREAM_ENDPOINTS.testnet4,
+      signet: this._customEndpoints.signet ?? DEFAULT_BLOCKSTREAM_ENDPOINTS.signet
+    };
+  }
+  // ============ UTXO Methods ============
+  async getUtxos(address2) {
+    const response = await fetchWithTimeout2(`${this.baseUrl}/address/${address2}/utxo`);
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getUtxosWithTxHex(address2) {
+    const utxos = await this.getUtxos(address2);
+    const utxosWithTx = await Promise.all(
+      utxos.map(async (utxo) => {
+        const txHex = await this.getTxHex(utxo.txid);
+        return { ...utxo, txHex };
+      })
+    );
+    return utxosWithTx;
+  }
+  // ============ Transaction Methods ============
+  async getTxHex(txid) {
+    const response = await fetchWithTimeout2(`${this.baseUrl}/tx/${txid}/hex`);
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+    return response.text();
+  }
+  async getTransaction(txid) {
+    const response = await fetchWithTimeout2(`${this.baseUrl}/tx/${txid}`);
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getFullTransaction(txid) {
+    const response = await fetchWithTimeout2(`${this.baseUrl}/tx/${txid}`);
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async broadcastTransaction(txHex) {
+    const response = await fetchWithTimeout2(
+      `${this.baseUrl}/tx`,
+      {
+        method: "POST",
+        body: txHex,
+        headers: { "Content-Type": "text/plain" }
+      },
+      3e4
+    );
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Blockstream broadcast error: ${error}`);
+    }
+    return response.text();
+  }
+  // ============ Address Methods ============
+  async getAddressInfo(address2) {
+    const response = await fetchWithTimeout2(`${this.baseUrl}/address/${address2}`);
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async getBalance(address2) {
+    const info = await this.getAddressInfo(address2);
+    const confirmedBalance = info.chain_stats.funded_txo_sum - info.chain_stats.spent_txo_sum;
+    const unconfirmedBalance = info.mempool_stats.funded_txo_sum - info.mempool_stats.spent_txo_sum;
+    return confirmedBalance + unconfirmedBalance;
+  }
+  async getConfirmedBalance(address2) {
+    const info = await this.getAddressInfo(address2);
+    return info.chain_stats.funded_txo_sum - info.chain_stats.spent_txo_sum;
+  }
+  // ============ Fee Methods ============
+  async getFeeRates() {
+    const response = await fetchWithTimeout2(`${this.baseUrl}/fee-estimates`);
+    if (!response.ok) {
+      throw new Error(`Blockstream API error: ${response.status} ${response.statusText}`);
+    }
+    const fees = await response.json();
+    return {
+      fastest: Math.ceil(fees["1"] || fees["2"] || 10),
+      halfHour: Math.ceil(fees["3"] || fees["4"] || 8),
+      hour: Math.ceil(fees["6"] || fees["12"] || 5),
+      economy: Math.ceil(fees["144"] || fees["504"] || 2),
+      minimum: Math.ceil(fees["1008"] || 1)
+    };
+  }
+};
+
+// src/utils/btc-service.ts
+var globalConfig = {};
+function configureBtcService(config) {
+  globalConfig = config;
+  defaultService = null;
+}
+function getBtcServiceConfig() {
+  return { ...globalConfig };
+}
+function race(promises) {
+  return Promise.race(promises);
+}
+var BtcService = class {
+  constructor(network = "mainnet", config) {
+    this.name = "btc-service";
+    this._network = network;
+    this._config = { ...globalConfig, ...config };
+    this._mempool = new MempoolService(network, this._config.mempool);
+    this._blockstream = new BlockstreamService(network, this._config.blockstream);
+  }
+  get network() {
+    return this._network;
+  }
+  /**
+   * Get the underlying Mempool service for direct access
+   */
+  get mempool() {
+    return this._mempool;
+  }
+  /**
+   * Get the underlying Blockstream service for direct access
+   */
+  get blockstream() {
+    return this._blockstream;
+  }
+  /**
+   * Get current configuration
+   */
+  get config() {
+    return { ...this._config };
+  }
+  setNetwork(network) {
+    this._network = network;
+    this._mempool.setNetwork(network);
+    this._blockstream.setNetwork(network);
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this._config = { ...this._config, ...config };
+    if (config.mempool) {
+      this._mempool.setCustomEndpoints(config.mempool);
+    }
+    if (config.blockstream) {
+      this._blockstream.setCustomEndpoints(config.blockstream);
+    }
+  }
+  /**
+   * Execute method based on preferred provider setting
+   */
+  async executeWithProvider(mempoolFn, blockstreamFn) {
+    const provider = this._config.preferredProvider ?? "race";
+    switch (provider) {
+      case "mempool":
+        return mempoolFn();
+      case "blockstream":
+        return blockstreamFn();
+      case "race":
+      default:
+        return race([mempoolFn(), blockstreamFn()]);
+    }
+  }
+  // ============ UTXO Methods ============
+  async getUtxos(address2) {
+    return this.executeWithProvider(
+      () => this._mempool.getUtxos(address2),
+      () => this._blockstream.getUtxos(address2)
+    );
+  }
+  async getUtxosWithTxHex(address2) {
+    return this.executeWithProvider(
+      () => this._mempool.getUtxosWithTxHex(address2),
+      () => this._blockstream.getUtxosWithTxHex(address2)
+    );
+  }
+  // ============ Transaction Methods ============
+  async getTxHex(txid) {
+    return this.executeWithProvider(
+      () => this._mempool.getTxHex(txid),
+      () => this._blockstream.getTxHex(txid)
+    );
+  }
+  async getTransaction(txid) {
+    return this.executeWithProvider(
+      () => this._mempool.getTransaction(txid),
+      () => this._blockstream.getTransaction(txid)
+    );
+  }
+  async getFullTransaction(txid) {
+    return this.executeWithProvider(
+      () => this._mempool.getFullTransaction(txid),
+      () => this._blockstream.getFullTransaction(txid)
+    );
+  }
+  async broadcastTransaction(txHex) {
+    return this.executeWithProvider(
+      () => this._mempool.broadcastTransaction(txHex),
+      () => this._blockstream.broadcastTransaction(txHex)
+    );
+  }
+  // ============ Address Methods ============
+  async getAddressInfo(address2) {
+    return this.executeWithProvider(
+      () => this._mempool.getAddressInfo(address2),
+      () => this._blockstream.getAddressInfo(address2)
+    );
+  }
+  async getBalance(address2) {
+    return this.executeWithProvider(
+      () => this._mempool.getBalance(address2),
+      () => this._blockstream.getBalance(address2)
+    );
+  }
+  async getConfirmedBalance(address2) {
+    return this.executeWithProvider(
+      () => this._mempool.getConfirmedBalance(address2),
+      () => this._blockstream.getConfirmedBalance(address2)
+    );
+  }
+  // ============ Fee Methods ============
+  async getFeeRates() {
+    return this.executeWithProvider(
+      () => this._mempool.getFeeRates(),
+      () => this._blockstream.getFeeRates()
+    );
+  }
+};
+var defaultService = null;
+function getDefaultService(network = "mainnet") {
+  if (!defaultService || defaultService.network !== network) {
+    defaultService = new BtcService(network);
+  }
+  return defaultService;
+}
+async function getUtxos(address2, network = "mainnet") {
+  return getDefaultService(network).getUtxos(address2);
+}
+async function getUtxosWithTxHex(address2, network = "mainnet") {
+  return getDefaultService(network).getUtxosWithTxHex(address2);
+}
+async function getTxHex(txid, network = "mainnet") {
+  return getDefaultService(network).getTxHex(txid);
+}
+async function getTransaction(txid, network = "mainnet") {
+  return getDefaultService(network).getTransaction(txid);
+}
+async function getFullTransaction(txid, network = "mainnet") {
+  return getDefaultService(network).getFullTransaction(txid);
+}
+async function broadcastTransaction(txHex, network = "mainnet") {
+  return getDefaultService(network).broadcastTransaction(txHex);
+}
+async function getAddressInfo(address2, network = "mainnet") {
+  return getDefaultService(network).getAddressInfo(address2);
+}
+async function getBalance(address2, network = "mainnet") {
+  return getDefaultService(network).getBalance(address2);
+}
+async function getConfirmedBalance(address2, network = "mainnet") {
+  return getDefaultService(network).getConfirmedBalance(address2);
+}
+async function getFeeRates(network = "mainnet") {
+  return getDefaultService(network).getFeeRates();
+}
+function hexToBytes(hex) {
+  const cleanHex = hex.replace(/^0x/, "");
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(cleanHex.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function toXOnly(pubKey) {
+  return pubKey.subarray(1, 33);
+}
+function getAddressType(address2) {
+  if (address2.startsWith("bc1q") || address2.startsWith("tb1q")) {
+    return "segwit";
+  }
+  if (address2.startsWith("bc1p") || address2.startsWith("tb1p")) {
+    return "taproot";
+  }
+  if (address2.startsWith("3") || address2.startsWith("2")) {
+    return "nested-segwit";
+  }
+  return "legacy";
+}
+function getBitcoinJsNetwork(network) {
+  switch (network) {
+    case "mainnet":
+      return bitcoin__namespace.networks.bitcoin;
+    case "testnet":
+    case "testnet4":
+    case "signet":
+      return bitcoin__namespace.networks.testnet;
+    default:
+      return bitcoin__namespace.networks.bitcoin;
+  }
+}
+function getInputVBytes(addressType) {
+  switch (addressType) {
+    case "taproot":
+      return 58;
+    case "segwit":
+      return 68;
+    case "nested-segwit":
+      return 91;
+    default:
+      return 148;
+  }
+}
+function getOutputVBytes(addressType) {
+  switch (addressType) {
+    case "taproot":
+      return 43;
+    case "segwit":
+      return 31;
+    case "nested-segwit":
+      return 32;
+    default:
+      return 34;
+  }
+}
+function getDustThreshold(addressType) {
+  return addressType === "legacy" ? 546 : 294;
+}
+function selectUtxos(utxos, fromAddressType, toAddressType, amount, feeRate) {
+  const inputVBytes = getInputVBytes(fromAddressType);
+  const outputVBytes = getOutputVBytes(toAddressType);
+  const baseVBytes = 10.5;
+  const sortedUtxos = [...utxos].sort((a, b) => b.value - a.value);
+  const selectedUtxos = [];
+  let totalValue = 0;
+  for (const utxo of sortedUtxos) {
+    selectedUtxos.push(utxo);
+    totalValue += utxo.value;
+    const estimatedVBytes2 = baseVBytes + selectedUtxos.length * inputVBytes + 2 * outputVBytes;
+    const estimatedFee2 = Math.ceil(estimatedVBytes2 * feeRate);
+    if (totalValue >= amount + estimatedFee2) {
+      return { selectedUtxos, totalValue, estimatedFee: estimatedFee2 };
+    }
+  }
+  const estimatedVBytes = baseVBytes + selectedUtxos.length * inputVBytes + 2 * outputVBytes;
+  const estimatedFee = Math.ceil(estimatedVBytes * feeRate);
+  return { selectedUtxos, totalValue, estimatedFee };
+}
+async function generatePsbtForSend(toAddress, amount, fromAddress, publicKey, network, options) {
+  const btcService = new BtcService(network);
+  const btcNetwork = getBitcoinJsNetwork(network);
+  const allUtxos = await btcService.getUtxos(fromAddress);
+  const confirmedUtxos = allUtxos.filter(
+    (utxo) => utxo.status?.confirmed !== false
+  );
+  if (confirmedUtxos.length === 0) {
+    throw new Error("No confirmed UTXOs available for spending");
+  }
+  let feeRate = options?.feeRate;
+  if (!feeRate) {
+    const feeRates = await btcService.getFeeRates();
+    feeRate = feeRates.hour;
+  }
+  if (options?.feeRateMultiplier) {
+    feeRate = Math.ceil(feeRate * options.feeRateMultiplier);
+  }
+  const fromAddressType = getAddressType(fromAddress);
+  const toAddressType = getAddressType(toAddress);
+  const { selectedUtxos, totalValue, estimatedFee } = selectUtxos(
+    confirmedUtxos,
+    fromAddressType,
+    toAddressType,
+    amount,
+    feeRate
+  );
+  if (totalValue < amount + estimatedFee) {
+    throw new Error(
+      `Insufficient funds. Available: ${totalValue} sats, Required: ${amount + estimatedFee} sats (including fee)`
+    );
+  }
+  const dustThreshold = getDustThreshold(fromAddressType);
+  let changeAmount = totalValue - amount - estimatedFee;
+  if (changeAmount > 0 && changeAmount <= dustThreshold) {
+    changeAmount = 0;
+  }
+  const psbt = new bitcoin__namespace.Psbt({ network: btcNetwork });
+  const publicKeyBytes = hexToBytes(publicKey);
+  const inputsToSign = [];
+  for (let i = 0; i < selectedUtxos.length; i++) {
+    const utxo = selectedUtxos[i];
+    const script = bitcoin__namespace.address.toOutputScript(fromAddress, btcNetwork);
+    if (fromAddressType === "taproot") {
+      psbt.addInput({
+        hash: utxo.txid,
+        index: utxo.vout,
+        witnessUtxo: {
+          script,
+          value: BigInt(utxo.value)
+        },
+        tapInternalKey: toXOnly(publicKeyBytes)
+      });
+    } else if (fromAddressType === "segwit") {
+      psbt.addInput({
+        hash: utxo.txid,
+        index: utxo.vout,
+        witnessUtxo: {
+          script,
+          value: BigInt(utxo.value)
+        }
+      });
+    } else if (fromAddressType === "nested-segwit") {
+      const p2wpkh = bitcoin__namespace.payments.p2wpkh({
+        pubkey: publicKeyBytes,
+        network: btcNetwork
+      });
+      if (!p2wpkh.output) {
+        throw new Error("Failed to generate P2WPKH redeem script");
+      }
+      psbt.addInput({
+        hash: utxo.txid,
+        index: utxo.vout,
+        witnessUtxo: {
+          script,
+          value: BigInt(utxo.value)
+        },
+        redeemScript: p2wpkh.output
+      });
+    } else {
+      psbt.addInput({
+        hash: utxo.txid,
+        index: utxo.vout,
+        witnessUtxo: {
+          script,
+          value: BigInt(utxo.value)
+        }
+      });
+    }
+    inputsToSign.push({ address: fromAddress, index: i });
+  }
+  psbt.addOutput({
+    address: toAddress,
+    value: BigInt(amount)
+  });
+  if (changeAmount > 0) {
+    psbt.addOutput({
+      address: fromAddress,
+      value: BigInt(Math.floor(changeAmount))
+    });
+  }
+  return {
+    psbt,
+    psbtHex: psbt.toHex(),
+    psbtBase64: psbt.toBase64(),
+    btcNetwork,
+    selectedUtxos,
+    totalInputValue: totalValue,
+    estimatedFee,
+    changeAmount,
+    inputsToSign
+  };
+}
+function finalizeAllInputs(signedPsbt, inputCount) {
+  for (let i = 0; i < inputCount; i++) {
+    try {
+      signedPsbt.finalizeInput(i);
+    } catch (finalizeError) {
+      console.warn(
+        `Failed to finalize input ${i}, attempting alternative finalization:`,
+        finalizeError
+      );
+      try {
+        signedPsbt.finalizeInput(i, () => ({
+          finalScriptSig: void 0,
+          finalScriptWitness: void 0
+        }));
+      } catch {
+        console.warn(`Could not finalize input ${i}`);
+      }
+    }
+  }
+}
+async function finalizeAndBroadcast(signedPsbtHex, network, inputCount) {
+  const btcNetwork = getBitcoinJsNetwork(network);
+  const btcService = new BtcService(network);
+  const signedPsbt = bitcoin__namespace.Psbt.fromHex(signedPsbtHex, { network: btcNetwork });
+  finalizeAllInputs(signedPsbt, inputCount);
+  const tx = signedPsbt.extractTransaction();
+  const txHex = tx.toHex();
+  return await btcService.broadcastTransaction(txHex);
+}
+function deriveAddressFromPublicKey(publicKeyHex, addressType, network) {
+  const btcNetwork = getBitcoinJsNetwork(network);
+  const publicKeyBytes = hexToBytes(publicKeyHex);
+  switch (addressType) {
+    case "legacy": {
+      const p2pkh = bitcoin__namespace.payments.p2pkh({
+        pubkey: publicKeyBytes,
+        network: btcNetwork
+      });
+      if (!p2pkh.address) {
+        throw new Error("Failed to derive legacy address from public key");
+      }
+      return p2pkh.address;
+    }
+    case "nested-segwit": {
+      const p2wpkh = bitcoin__namespace.payments.p2wpkh({
+        pubkey: publicKeyBytes,
+        network: btcNetwork
+      });
+      const p2sh = bitcoin__namespace.payments.p2sh({
+        redeem: p2wpkh,
+        network: btcNetwork
+      });
+      if (!p2sh.address) {
+        throw new Error("Failed to derive nested-segwit address from public key");
+      }
+      return p2sh.address;
+    }
+    case "segwit": {
+      const p2wpkh = bitcoin__namespace.payments.p2wpkh({
+        pubkey: publicKeyBytes,
+        network: btcNetwork
+      });
+      if (!p2wpkh.address) {
+        throw new Error("Failed to derive segwit address from public key");
+      }
+      return p2wpkh.address;
+    }
+    case "taproot": {
+      const xOnlyPubKey = toXOnly(publicKeyBytes);
+      const p2tr = bitcoin__namespace.payments.p2tr({
+        internalPubkey: xOnlyPubKey,
+        network: btcNetwork
+      });
+      if (!p2tr.address) {
+        throw new Error("Failed to derive taproot address from public key");
+      }
+      return p2tr.address;
+    }
+    default:
+      throw new Error(`Unsupported address type: ${addressType}`);
+  }
+}
+
+exports.BlockstreamService = BlockstreamService;
+exports.BtcService = BtcService;
+exports.MempoolService = MempoolService;
+exports.broadcastTransaction = broadcastTransaction;
+exports.bytesToHex = bytesToHex;
+exports.configureBtcService = configureBtcService;
+exports.deriveAddressFromPublicKey = deriveAddressFromPublicKey;
+exports.finalizeAllInputs = finalizeAllInputs;
+exports.finalizeAndBroadcast = finalizeAndBroadcast;
+exports.generatePsbtForSend = generatePsbtForSend;
+exports.getAddressInfo = getAddressInfo;
+exports.getAddressType = getAddressType;
+exports.getBalance = getBalance;
+exports.getBitcoinJsNetwork = getBitcoinJsNetwork;
+exports.getBtcServiceConfig = getBtcServiceConfig;
+exports.getConfirmedBalance = getConfirmedBalance;
+exports.getDustThreshold = getDustThreshold;
+exports.getFeeRates = getFeeRates;
+exports.getFullTransaction = getFullTransaction;
+exports.getInputVBytes = getInputVBytes;
+exports.getOutputVBytes = getOutputVBytes;
+exports.getTransaction = getTransaction;
+exports.getTxHex = getTxHex;
+exports.getUtxos = getUtxos;
+exports.getUtxosWithTxHex = getUtxosWithTxHex;
+exports.hexToBytes = hexToBytes;
+exports.selectUtxos = selectUtxos;
+exports.toXOnly = toXOnly;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk-FISNQZZ7.js.map