otx-btc-wallet-connectors 0.1.0

package/dist/chunk-LVZMONQL.mjs

@@ -0,0 +1,699 @@
+import { BtcService, getAddressType, getInputVBytes, getOutputVBytes, getDustThreshold } from './chunk-AW2JZIHR.mjs';
+import { BaseConnector } from './chunk-5Z5Q2Y75.mjs';
+
+// src/ledger/LedgerConnector.ts
+var LEDGER_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjAwIiBoZWlnaHQ9IjIwMCIgdmlld0JveD0iMCAwIDIwMCAyMDAiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxnIGNsaXAtcGF0aD0idXJsKCNjbGlwMF83MDM1XzUxMTApIj4KPHJlY3Qgd2lkdGg9IjIwMCIgaGVpZ2h0PSIyMDAiIHJ4PSIzMiIgZmlsbD0id2hpdGUiLz4KPHBhdGggZD0iTTE0Mi4yMzkgMzcuNUg4NS4wOTY0VjExNC41ODJIMTYyLjIzOVY1Ny40MzkzQzE2Mi4yMzggNTQuODE2IDE2MS43MiA1Mi4yMTg2IDE2MC43MTQgNDkuNzk1OUMxNTkuNzA4IDQ3LjM3MzIgMTU4LjIzMyA0NS4xNzI4IDE1Ni4zNzYgNDMuMzIwN0MxNTQuNTE4IDQxLjQ2ODUgMTUyLjMxMyA0MC4wMDExIDE0OS44ODcgMzkuMDAyM0MxNDcuNDYyIDM4LjAwMzUgMTQ0Ljg2MyAzNy40OTMgMTQyLjIzOSAzNy41WiIgZmlsbD0iYmxhY2siLz4KPHBhdGggZD0iTTY3LjI5MjkgMzcuNUg1Ny40NDY0QzUyLjE1NjMgMzcuNSA0Ny4wODI5IDM5LjYwMTUgNDMuMzQyMiA0My4zNDIyQzM5LjYwMTUgNDcuMDgyOSAzNy41IDUyLjE1NjMgMzcuNSA1Ny40NDY0TDM3LjUgNjcuMjkyOUg2Ny4yOTI5VjM3LjVaIiBmaWxsPSJibGFjayIvPgo8cGF0aCBkPSJNMzcuNSA4NS4xMDM2SDY3LjI5MjlWMTE0Ljg5NkgzNy41Vjg1LjEwMzZaIiBmaWxsPSJibGFjayIvPgo8cGF0aCBkPSJNMTMyLjcwNyAxNjIuMjQ2SDE0Mi41NTNDMTQ1LjE3NyAxNjIuMjQ2IDE0Ny43NzYgMTYxLjcyOSAxNTAuMTk5IDE2MC43MjNDMTUyLjYyMyAxNTkuNzE3IDE1NC44MjQgMTU4LjI0MyAxNTYuNjc3IDE1Ni4zODVDMTU4LjUzIDE1NC41MjcgMTU5Ljk5OCAxNTIuMzIyIDE2MC45OTcgMTQ5Ljg5NkMxNjEuOTk2IDE0Ny40NyAxNjIuNTA3IDE0NC44NyAxNjIuNSAxNDIuMjQ2VjEzMi43MDdIMTMyLjcwN1YxNjIuMjQ2WiIgZmlsbD0iYmxhY2siLz4KPHBhdGggZD0iTTg1LjEwMzUgMTMyLjcwN0gxMTQuODk2VjE2Mi41SDg1LjEwMzVWMTMyLjcwN1oiIGZpbGw9ImJsYWNrIi8+CjxwYXRoIGQ9Ik0zNy41IDEzMi43MDdWMTQyLjU1NEMzNy41IDE0NS4xNzMgMzguMDE1OSAxNDcuNzY3IDM5LjAxODMgMTUwLjE4N0M0MC4wMjA3IDE1Mi42MDcgNDEuNDkgMTU0LjgwNiA0My4zNDIyIDE1Ni42NThDNDUuMTk0NCAxNTguNTEgNDcuMzkzMiAxNTkuOTc5IDQ5LjgxMzMgMTYwLjk4MkM1Mi4yMzMzIDE2MS45ODQgNTQuODI3IDE2Mi41IDU3LjQ0NjQgMTYyLjVINjcuMjkyOVYxMzIuNzA3SDM3LjVaIiBmaWxsPSJibGFjayIvPgo8L2c+CjxkZWZzPgo8Y2xpcFBhdGggaWQ9ImNsaXAwXzcwMzVfNTExMCI+CjxyZWN0IHdpZHRoPSIyMDAiIGhlaWdodD0iMjAwIiBmaWxsPSJ3aGl0ZSIvPgo8L2NsaXBQYXRoPgo8L2RlZnM+Cjwvc3ZnPgo=";
+var ADDRESS_TYPE_TO_PATH = {
+  "legacy": 44,
+  "nested-segwit": 49,
+  "segwit": 84,
+  "taproot": 86
+};
+var ADDRESS_TYPE_TO_FORMAT = {
+  "legacy": "legacy",
+  "nested-segwit": "p2sh",
+  "segwit": "bech32",
+  "taproot": "bech32m"
+};
+var _LedgerConnector = class _LedgerConnector extends BaseConnector {
+  constructor(options = {}) {
+    super();
+    this.id = "ledger";
+    this.name = "Ledger";
+    this.icon = LEDGER_ICON;
+    this._transport = null;
+    this._btcApp = null;
+    this._account = null;
+    this._network = "mainnet";
+    this._derivationPath = "";
+    this._options = {
+      addressType: options.addressType ?? "segwit",
+      accountIndex: options.accountIndex ?? 0,
+      addressIndex: options.addressIndex ?? 0
+    };
+  }
+  /**
+   * Override checkReady - Ledger is always "ready" since it doesn't require browser extension
+   * The actual device connection happens when connect() is called
+   */
+  checkReady() {
+    this.ready = true;
+  }
+  /**
+   * Get the provider - for Ledger this is the Bitcoin app instance
+   */
+  getProvider() {
+    return this._btcApp;
+  }
+  /**
+   * Get current address type
+   */
+  getAddressType() {
+    return this._options.addressType;
+  }
+  /**
+   * Set address type options before connecting
+   * Call this before connect() to change the address derivation path
+   */
+  setOptions(options) {
+    this._options = {
+      addressType: options.addressType ?? this._options.addressType,
+      accountIndex: options.accountIndex ?? this._options.accountIndex,
+      addressIndex: options.addressIndex ?? this._options.addressIndex
+    };
+  }
+  /**
+   * Get available address types for UI selection
+   */
+  static getAvailableAddressTypes() {
+    return [
+      { type: "legacy", label: "Legacy (P2PKH)", description: "Starts with '1' or 'm/n'" },
+      { type: "nested-segwit", label: "Nested SegWit (P2SH-P2WPKH)", description: "Starts with '3' or '2'" },
+      { type: "segwit", label: "Native SegWit (P2WPKH)", description: "Starts with 'bc1q' or 'tb1q'" },
+      { type: "taproot", label: "Taproot (P2TR)", description: "Starts with 'bc1p' or 'tb1p'" }
+    ];
+  }
+  /**
+   * Check if WebUSB is supported in the current browser
+   */
+  async isSupported() {
+    if (typeof window === "undefined")
+      return false;
+    try {
+      const TransportWebUSB = (await import('@ledgerhq/hw-transport-webusb')).default;
+      return await TransportWebUSB.isSupported();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Initialize transport with timeout
+   * Uses request() instead of create() to always show device selection popup
+   */
+  async initTransport() {
+    console.log("[LedgerConnector] initTransport() called");
+    await this.closeTransport();
+    console.log("[LedgerConnector] Importing TransportWebUSB...");
+    const TransportWebUSB = (await import('@ledgerhq/hw-transport-webusb')).default;
+    console.log("[LedgerConnector] TransportWebUSB imported");
+    console.log("[LedgerConnector] Requesting device selection...");
+    const transportPromise = TransportWebUSB.request();
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error("Connection timeout. Please make sure your Ledger is connected and unlocked."));
+      }, _LedgerConnector.CONNECTION_TIMEOUT);
+    });
+    const transport = await Promise.race([transportPromise, timeoutPromise]);
+    console.log("[LedgerConnector] Transport created successfully");
+    return transport;
+  }
+  /**
+   * Get BTC app instance, initializing if needed
+   */
+  async getBtcAppInstance() {
+    console.log("[LedgerConnector] getBtcAppInstance() called");
+    if (this._btcApp) {
+      console.log("[LedgerConnector] Returning existing BTC app instance");
+      return this._btcApp;
+    }
+    const transport = await this.initTransport();
+    this._transport = transport;
+    console.log("[LedgerConnector] Checking if Bitcoin app is open...");
+    try {
+      await transport.send(176, 1, 0, 0);
+      console.log("[LedgerConnector] Bitcoin app is open");
+    } catch (error) {
+      console.error("[LedgerConnector] Bitcoin app check failed:", error);
+      await this.closeTransport();
+      throw new Error("Please open the Bitcoin app on your Ledger device");
+    }
+    console.log("[LedgerConnector] Importing AppBtc...");
+    const AppBtc = (await import('@ledgerhq/hw-app-btc')).default;
+    console.log("[LedgerConnector] AppBtc imported");
+    const currency = this._network === "mainnet" ? "bitcoin" : "bitcoin_testnet";
+    this._btcApp = new AppBtc({ transport, currency });
+    console.log("[LedgerConnector] BTC app instance created");
+    return this._btcApp;
+  }
+  /**
+   * Connect to Ledger device
+   * IMPORTANT: This must be called within a user gesture (click event)
+   */
+  async connect(network = "mainnet") {
+    console.log("[LedgerConnector] connect() called with network:", network);
+    try {
+      console.log("[LedgerConnector] Checking WebUSB support...");
+      const supported = await this.isSupported();
+      console.log("[LedgerConnector] WebUSB supported:", supported);
+      if (!supported) {
+        throw new Error("WebUSB is not supported in this browser. Please use Chrome or a Chromium-based browser.");
+      }
+      this._network = network;
+      console.log("[LedgerConnector] Initializing BTC app...");
+      const btcApp = await this.getBtcAppInstance();
+      console.log("[LedgerConnector] BTC app initialized");
+      const coinType = network === "mainnet" ? 0 : 1;
+      const purpose = ADDRESS_TYPE_TO_PATH[this._options.addressType];
+      this._derivationPath = `${purpose}'/${coinType}'/${this._options.accountIndex}'/0/${this._options.addressIndex}`;
+      console.log("[LedgerConnector] Derivation path:", this._derivationPath);
+      const format = ADDRESS_TYPE_TO_FORMAT[this._options.addressType];
+      console.log("[LedgerConnector] Getting wallet public key...");
+      const result = await btcApp.getWalletPublicKey(this._derivationPath, {
+        verify: false,
+        format
+      });
+      console.log("[LedgerConnector] Got wallet public key:", result.bitcoinAddress);
+      this._account = {
+        address: result.bitcoinAddress,
+        publicKey: result.publicKey,
+        type: this.mapLedgerAddressType(this._options.addressType)
+      };
+      this.setupDisconnectListener();
+      console.log("[LedgerConnector] Connection successful!");
+      return this._account;
+    } catch (error) {
+      console.error("[LedgerConnector] Connection error:", error);
+      await this.closeTransport();
+      this.handleLedgerError(error);
+    }
+  }
+  /**
+   * Get address with verification on device
+   */
+  async getAddressWithVerification() {
+    if (!this._btcApp) {
+      throw new Error("Not connected to Ledger device");
+    }
+    try {
+      const format = ADDRESS_TYPE_TO_FORMAT[this._options.addressType];
+      const result = await this._btcApp.getWalletPublicKey(this._derivationPath, {
+        verify: true,
+        // Show address on device for verification
+        format
+      });
+      return {
+        address: result.bitcoinAddress,
+        publicKey: result.publicKey,
+        type: this.mapLedgerAddressType(this._options.addressType)
+      };
+    } catch (error) {
+      this.handleLedgerError(error);
+    }
+  }
+  setupDisconnectListener() {
+    if (!this._transport)
+      return;
+    this._transport.on("disconnect", () => {
+      this._transport = null;
+      this._btcApp = null;
+      this._account = null;
+      this.emitAccountsChanged([]);
+    });
+  }
+  async closeTransport() {
+    if (this._transport) {
+      try {
+        await this._transport.close();
+      } catch {
+      }
+      this._transport = null;
+      this._btcApp = null;
+    }
+  }
+  async disconnect() {
+    await this.closeTransport();
+    this._account = null;
+    this.cleanup();
+  }
+  async getAccounts() {
+    if (!this._account) {
+      return [];
+    }
+    return [this._account];
+  }
+  async signMessage(message) {
+    if (!this._btcApp) {
+      throw new Error("Not connected to Ledger device");
+    }
+    try {
+      const messageHex = Buffer.from(message, "utf8").toString("hex");
+      const result = await this._btcApp.signMessage(this._derivationPath, messageHex);
+      const v = result.v;
+      const r = result.r;
+      const s = result.s;
+      const vHex = v.toString(16).padStart(2, "0");
+      const signature = Buffer.from(vHex + r + s, "hex");
+      return signature.toString("base64");
+    } catch (error) {
+      this.handleLedgerError(error);
+    }
+  }
+  /**
+   * Sign a PSBT with Ledger
+   *
+   * Note: Ledger hardware wallets don't support direct PSBT signing through the standard API.
+   * Use the createTransaction method or sendTransaction instead.
+   */
+  async signPsbt(_psbtHex, _options) {
+    throw new Error("SignPsbt is not supported for Ledger Wallet. Use createTransaction or sendTransaction instead.");
+  }
+  /**
+   * Sign multiple PSBTs
+   */
+  async signPsbts(psbtHexs, options) {
+    const results = [];
+    for (const psbtHex of psbtHexs) {
+      const signed = await this.signPsbt(psbtHex, options);
+      results.push(signed);
+    }
+    return results;
+  }
+  /**
+   * Send a Bitcoin transaction
+   *
+   * @param to - Recipient address
+   * @param satoshis - Amount to send in satoshis
+   * @param options - Send options (feeRate, etc.)
+   * @returns Transaction ID after broadcast
+   *
+   * @example
+   * ```typescript
+   * const txid = await ledger.sendTransaction('bc1q...', 50000);
+   * // With custom fee rate
+   * const txid = await ledger.sendTransaction('bc1q...', 50000, { feeRate: 10 });
+   * ```
+   */
+  async sendTransaction(to, satoshis, options) {
+    if (!this._btcApp || !this._account) {
+      throw new Error("Not connected to Ledger device");
+    }
+    const btcService = new BtcService(this._network);
+    const utxos = await btcService.getUtxosWithTxHex(this._account.address);
+    if (utxos.length === 0) {
+      throw new Error("No UTXOs available for spending");
+    }
+    let feeRate = options?.feeRate;
+    if (!feeRate) {
+      const feeRates = await btcService.getFeeRates();
+      feeRate = feeRates.hour;
+    }
+    const fromAddressType = getAddressType(this._account.address);
+    const toAddressType = getAddressType(to);
+    const inputVBytes = getInputVBytes(fromAddressType);
+    const outputVBytes = getOutputVBytes(toAddressType);
+    const changeOutputVBytes = getOutputVBytes(fromAddressType);
+    const baseVBytes = 10.5;
+    const sortedUtxos = [...utxos].sort((a, b) => b.value - a.value);
+    const selectedUtxos = [];
+    let totalInputValue = 0;
+    for (const utxo of sortedUtxos) {
+      selectedUtxos.push(utxo);
+      totalInputValue += utxo.value;
+      const estimatedVBytes2 = baseVBytes + selectedUtxos.length * inputVBytes + outputVBytes + changeOutputVBytes;
+      const estimatedFee2 = Math.ceil(estimatedVBytes2 * feeRate);
+      if (totalInputValue >= satoshis + estimatedFee2) {
+        break;
+      }
+    }
+    let estimatedVBytes = baseVBytes + selectedUtxos.length * inputVBytes + outputVBytes + changeOutputVBytes;
+    let estimatedFee = Math.ceil(estimatedVBytes * feeRate);
+    if (totalInputValue < satoshis + estimatedFee) {
+      throw new Error(
+        `Insufficient funds. Available: ${totalInputValue} sats, Required: ${satoshis + estimatedFee} sats (including fee)`
+      );
+    }
+    let changeAmount = totalInputValue - satoshis - estimatedFee;
+    const outputs = [{ address: to, satoshis }];
+    const dustThreshold = getDustThreshold(fromAddressType);
+    if (changeAmount > dustThreshold) {
+      outputs.push({ address: this._account.address, satoshis: changeAmount });
+    } else {
+      estimatedVBytes = baseVBytes + selectedUtxos.length * inputVBytes + outputVBytes;
+      estimatedFee = Math.ceil(estimatedVBytes * feeRate);
+      changeAmount = 0;
+      if (totalInputValue < satoshis + estimatedFee) {
+        throw new Error(
+          `Insufficient funds after fee adjustment. Available: ${totalInputValue} sats, Required: ${satoshis + estimatedFee} sats`
+        );
+      }
+    }
+    const inputs = selectedUtxos.map((utxo) => ({
+      txHex: utxo.txHex,
+      outputIndex: utxo.vout,
+      derivationPath: this._derivationPath
+    }));
+    const signedTxHex = await this.createTransaction(inputs, outputs);
+    const txid = await btcService.broadcastTransaction(signedTxHex);
+    return txid;
+  }
+  /**
+   * Create and sign a Bitcoin transaction using Ledger
+   *
+   * This method requires you to provide UTXOs (unspent transaction outputs) which
+   * must be fetched from a blockchain API (e.g., Blockstream, Mempool.space, etc.)
+   *
+   * @param inputs - Array of UTXO inputs to spend
+   * @param outputs - Array of outputs (recipients)
+   * @param changePath - Optional BIP32 path for change output
+   * @returns Signed transaction hex ready for broadcast
+   *
+   * @example
+   * ```typescript
+   * const signedTx = await ledger.createTransaction(
+   *   [{
+   *     txHex: '0100000001...', // Raw tx hex that created the UTXO
+   *     outputIndex: 0,
+   *     derivationPath: "84'/0'/0'/0/0",
+   *   }],
+   *   [{
+   *     address: 'bc1q...',
+   *     satoshis: 50000,
+   *   }],
+   *   "84'/0'/0'/1/0" // Change address path
+   * );
+   * ```
+   */
+  async createTransaction(inputs, outputs, changePath) {
+    if (!this._btcApp) {
+      throw new Error("Not connected to Ledger device");
+    }
+    if (inputs.length === 0) {
+      throw new Error("At least one input is required");
+    }
+    if (outputs.length === 0) {
+      throw new Error("At least one output is required");
+    }
+    try {
+      const isSegwit = this._options.addressType !== "legacy";
+      const additionals = this.getAdditionals();
+      const parsedInputs = [];
+      const associatedKeysets = [];
+      for (const input of inputs) {
+        const tx = this._btcApp.splitTransaction(input.txHex, isSegwit, false, additionals);
+        parsedInputs.push([
+          tx,
+          input.outputIndex,
+          input.redeemScript ?? null,
+          input.sequence ?? 4294967295
+        ]);
+        associatedKeysets.push(input.derivationPath);
+      }
+      const outputScriptHex = this.buildOutputScript(outputs);
+      const txArgs = {
+        inputs: parsedInputs,
+        associatedKeysets,
+        outputScriptHex,
+        segwit: isSegwit,
+        additionals,
+        useTrustedInputForSegwit: isSegwit
+      };
+      if (changePath) {
+        txArgs.changePath = changePath;
+      }
+      const signedTx = await this._btcApp.createPaymentTransaction(txArgs);
+      return signedTx;
+    } catch (error) {
+      this.handleLedgerError(error);
+    }
+  }
+  /**
+   * Build output script hex from outputs array
+   * Format: varint(output_count) + [amount(8 bytes LE) + varint(script_len) + script]...
+   */
+  buildOutputScript(outputs) {
+    let script = "";
+    script += this.encodeVarint(outputs.length);
+    for (const output of outputs) {
+      const amountHex = this.uint64ToLittleEndian(output.satoshis);
+      script += amountHex;
+      const scriptPubKey = this.addressToScriptPubKey(output.address);
+      script += this.encodeVarint(scriptPubKey.length / 2);
+      script += scriptPubKey;
+    }
+    return script;
+  }
+  /**
+   * Convert address to scriptPubKey hex
+   */
+  addressToScriptPubKey(address) {
+    console.log("[LedgerConnector] addressToScriptPubKey called with:", address);
+    if (address.startsWith("bc1q") || address.startsWith("tb1q")) {
+      const decoded = this.decodeBech32(address);
+      console.log("[LedgerConnector] P2WPKH decoded length:", decoded.length, "hex:", decoded);
+      if (decoded.length !== 40) {
+        throw new Error(`Invalid P2WPKH address: expected 40 hex chars, got ${decoded.length}`);
+      }
+      return "0014" + decoded;
+    } else if (address.startsWith("bc1p") || address.startsWith("tb1p")) {
+      const decoded = this.decodeBech32(address);
+      console.log("[LedgerConnector] P2TR decoded length:", decoded.length, "hex:", decoded);
+      if (decoded.length !== 64) {
+        throw new Error(`Invalid P2TR address: expected 64 hex chars, got ${decoded.length}`);
+      }
+      return "5120" + decoded;
+    } else if (address.startsWith("3") || address.startsWith("2")) {
+      const decoded = this.decodeBase58Check(address);
+      return "a914" + decoded + "87";
+    } else if (address.startsWith("1") || address.startsWith("m") || address.startsWith("n")) {
+      const decoded = this.decodeBase58Check(address);
+      return "76a914" + decoded + "88ac";
+    } else {
+      throw new Error(`Unsupported address format: ${address}`);
+    }
+  }
+  /**
+   * Decode bech32/bech32m address to hex
+   */
+  decodeBech32(address) {
+    const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+    const pos = address.lastIndexOf("1");
+    if (pos < 1)
+      throw new Error("Invalid bech32 address");
+    const data = address.slice(pos + 1);
+    const values = [];
+    for (const char of data) {
+      const idx = CHARSET.indexOf(char.toLowerCase());
+      if (idx === -1)
+        throw new Error("Invalid bech32 character");
+      values.push(idx);
+    }
+    const dataValues = values.slice(0, -6);
+    const witnessData = dataValues.slice(1);
+    let acc = 0;
+    let bits = 0;
+    const result = [];
+    for (const value of witnessData) {
+      acc = acc << 5 | value;
+      bits += 5;
+      while (bits >= 8) {
+        bits -= 8;
+        result.push(acc >> bits & 255);
+      }
+    }
+    return Buffer.from(result).toString("hex");
+  }
+  /**
+   * Decode base58check address to hex (without version byte)
+   */
+  decodeBase58Check(address) {
+    const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let num = BigInt(0);
+    for (const char of address) {
+      const idx = ALPHABET.indexOf(char);
+      if (idx === -1)
+        throw new Error("Invalid base58 character");
+      num = num * BigInt(58) + BigInt(idx);
+    }
+    let hex = num.toString(16);
+    if (hex.length % 2 !== 0)
+      hex = "0" + hex;
+    let leadingZeros = 0;
+    for (const char of address) {
+      if (char === "1")
+        leadingZeros++;
+      else
+        break;
+    }
+    hex = "00".repeat(leadingZeros) + hex;
+    return hex.slice(2, -8);
+  }
+  /**
+   * Encode number as varint hex
+   */
+  encodeVarint(n) {
+    if (n < 253) {
+      return n.toString(16).padStart(2, "0");
+    } else if (n <= 65535) {
+      return "fd" + this.uint16ToLittleEndian(n);
+    } else if (n <= 4294967295) {
+      return "fe" + this.uint32ToLittleEndian(n);
+    } else {
+      return "ff" + this.uint64ToLittleEndian(n);
+    }
+  }
+  /**
+   * Convert uint16 to little-endian hex
+   */
+  uint16ToLittleEndian(n) {
+    const buf = Buffer.alloc(2);
+    buf.writeUInt16LE(n);
+    return buf.toString("hex");
+  }
+  /**
+   * Convert uint32 to little-endian hex
+   */
+  uint32ToLittleEndian(n) {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32LE(n);
+    return buf.toString("hex");
+  }
+  /**
+   * Convert uint64 to little-endian hex
+   */
+  uint64ToLittleEndian(n) {
+    const buf = Buffer.alloc(8);
+    buf.writeBigUInt64LE(BigInt(n));
+    return buf.toString("hex");
+  }
+  /**
+   * Get additionals array based on address type
+   */
+  getAdditionals() {
+    switch (this._options.addressType) {
+      case "segwit":
+        return ["bech32"];
+      case "taproot":
+        return ["bech32m"];
+      case "nested-segwit":
+        return [];
+      case "legacy":
+      default:
+        return [];
+    }
+  }
+  async getNetwork() {
+    return this._network;
+  }
+  /**
+   * Get extended public key (xpub/ypub/zpub) for account
+   */
+  async getExtendedPublicKey() {
+    if (!this._btcApp) {
+      throw new Error("Not connected to Ledger device");
+    }
+    try {
+      const coinType = this._network === "mainnet" ? 0 : 1;
+      const purpose = ADDRESS_TYPE_TO_PATH[this._options.addressType];
+      const accountPath = `${purpose}'/${coinType}'/${this._options.accountIndex}'`;
+      const xpubVersion = this.getXpubVersion();
+      const xpub = await this._btcApp.getWalletXpub({
+        path: accountPath,
+        xpubVersion
+      });
+      return xpub;
+    } catch (error) {
+      this.handleLedgerError(error);
+    }
+  }
+  /**
+   * Get multiple addresses for the account
+   */
+  async getAddresses(startIndex, count) {
+    if (!this._btcApp) {
+      throw new Error("Not connected to Ledger device");
+    }
+    const accounts = [];
+    const coinType = this._network === "mainnet" ? 0 : 1;
+    const purpose = ADDRESS_TYPE_TO_PATH[this._options.addressType];
+    const format = ADDRESS_TYPE_TO_FORMAT[this._options.addressType];
+    for (let i = startIndex; i < startIndex + count; i++) {
+      const path = `${purpose}'/${coinType}'/${this._options.accountIndex}'/0/${i}`;
+      const result = await this._btcApp.getWalletPublicKey(path, {
+        verify: false,
+        format
+      });
+      accounts.push({
+        address: result.bitcoinAddress,
+        publicKey: result.publicKey,
+        type: this.mapLedgerAddressType(this._options.addressType)
+      });
+    }
+    return accounts;
+  }
+  /**
+   * Get current derivation path
+   */
+  getDerivationPath() {
+    return this._derivationPath;
+  }
+  /**
+   * Check if device is connected
+   */
+  isConnected() {
+    return this._transport !== null && this._btcApp !== null;
+  }
+  /**
+   * Get the Ledger Bitcoin app instance for advanced operations
+   * This allows users to call createPaymentTransaction directly
+   */
+  getBtcApp() {
+    return this._btcApp;
+  }
+  mapLedgerAddressType(addressType) {
+    switch (addressType) {
+      case "legacy":
+        return "legacy";
+      case "nested-segwit":
+        return "nested-segwit";
+      case "segwit":
+        return "segwit";
+      case "taproot":
+        return "taproot";
+      default:
+        return "segwit";
+    }
+  }
+  getXpubVersion() {
+    const isMainnet = this._network === "mainnet";
+    switch (this._options.addressType) {
+      case "legacy":
+        return isMainnet ? 76067358 : 70617039;
+      case "nested-segwit":
+        return isMainnet ? 77429938 : 71979618;
+      case "segwit":
+        return isMainnet ? 78792518 : 73342198;
+      case "taproot":
+        return isMainnet ? 76067358 : 70617039;
+      default:
+        return isMainnet ? 78792518 : 73342198;
+    }
+  }
+  handleLedgerError(error) {
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      if (message.includes("locked") || message.includes("0x6982")) {
+        throw new Error("Ledger device is locked. Please unlock it and try again.");
+      }
+      if (message.includes("denied") || message.includes("rejected") || message.includes("0x6985")) {
+        throw new Error("User rejected the request on Ledger device.");
+      }
+      if (message.includes("app") && message.includes("open")) {
+        throw new Error("Please open the Bitcoin app on your Ledger device.");
+      }
+      if (message.includes("transportopenusercancelled")) {
+        throw new Error("Connection cancelled. Please try again.");
+      }
+      if (message.includes("no device selected")) {
+        throw new Error("No Ledger device selected. Please connect your device and try again.");
+      }
+    }
+    this.handleError(error);
+  }
+};
+// Connection timeout in milliseconds
+_LedgerConnector.CONNECTION_TIMEOUT = 3e4;
+var LedgerConnector = _LedgerConnector;
+
+export { LedgerConnector };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk-LVZMONQL.mjs.map