@bytezhang/ledger-adapter 0.0.1

package/dist/index.js

@@ -0,0 +1,1010 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AppManager: () => AppManager,
+  LedgerAdapter: () => LedgerAdapter,
+  LedgerDeviceManager: () => LedgerDeviceManager,
+  SignerBtc: () => SignerBtc,
+  SignerEth: () => SignerEth,
+  SignerManager: () => SignerManager,
+  clearRegistry: () => clearRegistry,
+  deviceActionToPromise: () => deviceActionToPromise,
+  getTransportProvider: () => getTransportProvider,
+  isDeviceLockedError: () => isDeviceLockedError,
+  listRegisteredTransports: () => listRegisteredTransports,
+  mapLedgerError: () => mapLedgerError,
+  registerTransport: () => registerTransport,
+  unregisterTransport: () => unregisterTransport
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/adapter/LedgerAdapter.ts
+var import_hardware_wallet_core2 = require("@bytezhang/hardware-wallet-core");
+
+// src/errors.ts
+var import_hardware_wallet_core = require("@bytezhang/hardware-wallet-core");
+var LOCKED_ERROR_CODES = /* @__PURE__ */ new Set(["5515", "21781", "6982", "27010", "5303", "21251"]);
+var USER_REJECTED_CODES = /* @__PURE__ */ new Set(["6985", "27013"]);
+var WRONG_APP_CODES = /* @__PURE__ */ new Set(["6e00", "28160", "6d00", "27904"]);
+function isDeviceLockedError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e.errorCode != null && LOCKED_ERROR_CODES.has(String(e.errorCode))) return true;
+  if (e.statusCode != null && LOCKED_ERROR_CODES.has(String(e.statusCode))) return true;
+  if (e._tag === "DeviceLockedError") return true;
+  if (typeof e.message === "string" && /locked/i.test(e.message)) return true;
+  if (e.originalError != null && isDeviceLockedError(e.originalError)) return true;
+  if (e.error != null && e._tag && isDeviceLockedError(e.error)) return true;
+  return false;
+}
+function hasStatusCode(err, codeSet) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e.errorCode != null && codeSet.has(String(e.errorCode))) return true;
+  if (e.statusCode != null && codeSet.has(String(e.statusCode))) return true;
+  if (e.originalError != null && hasStatusCode(e.originalError, codeSet)) return true;
+  if (e.error != null && e._tag && hasStatusCode(e.error, codeSet)) return true;
+  return false;
+}
+function isUserRejectedError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e._tag === "UserRefusedOnDevice") return true;
+  if (typeof e.message === "string" && /denied|rejected|refused/i.test(e.message)) return true;
+  if (hasStatusCode(err, USER_REJECTED_CODES)) return true;
+  return false;
+}
+function isWrongAppError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e._tag === "WrongAppOpenedError" || e._tag === "InvalidStatusWordError") {
+    if (hasStatusCode(err, WRONG_APP_CODES)) return true;
+  }
+  if (typeof e.message === "string" && /wrong app|open the .* app|CLA not supported/i.test(e.message)) return true;
+  if (hasStatusCode(err, WRONG_APP_CODES)) return true;
+  return false;
+}
+function isDeviceDisconnectedError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e._tag === "DeviceNotRecognizedError" || e._tag === "DeviceSessionNotFound") return true;
+  if (typeof e.message === "string" && /disconnected|not found|no device|unplugged|session.*not.*found/i.test(e.message)) return true;
+  return false;
+}
+function isTimeoutError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (typeof e.message === "string" && /timeout|timed?\s*out/i.test(e.message)) return true;
+  if (e._tag === "DeviceExchangeTimeoutError") return true;
+  return false;
+}
+function mapLedgerError(err) {
+  if (isDeviceLockedError(err)) {
+    return {
+      code: import_hardware_wallet_core.HardwareErrorCode.DeviceLocked,
+      message: "Device is locked. Please unlock your Ledger device and try again."
+    };
+  }
+  if (isUserRejectedError(err)) {
+    return {
+      code: import_hardware_wallet_core.HardwareErrorCode.UserRejected,
+      message: "User rejected the request on the device."
+    };
+  }
+  if (isWrongAppError(err)) {
+    return {
+      code: import_hardware_wallet_core.HardwareErrorCode.WrongApp,
+      message: "Wrong app is open on the Ledger device. Please open the correct app (e.g. Ethereum) and try again."
+    };
+  }
+  if (isDeviceDisconnectedError(err)) {
+    return {
+      code: import_hardware_wallet_core.HardwareErrorCode.DeviceDisconnected,
+      message: "Ledger device was disconnected. Please reconnect the device and try again."
+    };
+  }
+  if (isTimeoutError(err)) {
+    return {
+      code: import_hardware_wallet_core.HardwareErrorCode.OperationTimeout,
+      message: "Operation timed out. Please ensure the Ledger device is connected and responsive."
+    };
+  }
+  let message = "Unknown Ledger error";
+  if (err instanceof Error) {
+    message = err.message;
+  } else if (err && typeof err === "object") {
+    const e = err;
+    message = String(e.message ?? e._tag ?? e.type ?? JSON.stringify(err));
+  }
+  return { code: import_hardware_wallet_core.HardwareErrorCode.UnknownError, message };
+}
+
+// src/adapter/LedgerAdapter.ts
+function ensure0x(hex) {
+  return hex.startsWith("0x") ? hex : `0x${hex}`;
+}
+function stripHex(hex) {
+  return hex.startsWith("0x") ? hex.slice(2) : hex;
+}
+function padHex64(hex) {
+  return `0x${stripHex(hex).padStart(64, "0")}`;
+}
+var LedgerAdapter = class {
+  constructor(connector) {
+    this.vendor = "ledger";
+    this.emitter = new import_hardware_wallet_core2.TypedEventEmitter();
+    this._uiHandler = null;
+    // Device cache: tracks discovered devices from connector events
+    this._discoveredDevices = /* @__PURE__ */ new Map();
+    // Session tracking: maps connectId -> sessionId
+    this._sessions = /* @__PURE__ */ new Map();
+    // ---------------------------------------------------------------------------
+    // Event translation
+    // ---------------------------------------------------------------------------
+    this.deviceConnectHandler = (data) => {
+      const deviceInfo = this.connectorDeviceToDeviceInfo(data.device);
+      this._discoveredDevices.set(deviceInfo.connectId, deviceInfo);
+      this.emitter.emit(import_hardware_wallet_core2.DEVICE.CONNECT, {
+        type: import_hardware_wallet_core2.DEVICE.CONNECT,
+        payload: deviceInfo
+      });
+    };
+    this.deviceDisconnectHandler = (data) => {
+      this._discoveredDevices.delete(data.connectId);
+      this._sessions.delete(data.connectId);
+      this.emitter.emit(import_hardware_wallet_core2.DEVICE.DISCONNECT, {
+        type: import_hardware_wallet_core2.DEVICE.DISCONNECT,
+        payload: { connectId: data.connectId }
+      });
+    };
+    this.uiRequestHandler = (data) => {
+      this.handleUiEvent(data);
+    };
+    this.uiEventHandler = (data) => {
+      this.handleUiEvent(data);
+    };
+    this.connector = connector;
+    this.registerEventListeners();
+  }
+  // ---------------------------------------------------------------------------
+  // Transport
+  // ---------------------------------------------------------------------------
+  // Transport is decided at connector creation time. These methods
+  // satisfy the IHardwareWallet interface with sensible defaults.
+  get activeTransport() {
+    return "hid";
+  }
+  getAvailableTransports() {
+    return ["hid"];
+  }
+  async switchTransport(_type) {
+  }
+  // ---------------------------------------------------------------------------
+  // UI handler
+  // ---------------------------------------------------------------------------
+  setUiHandler(handler) {
+    this._uiHandler = handler;
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  async init(_config) {
+  }
+  async dispose() {
+    this.unregisterEventListeners();
+    this.connector.reset();
+    this._uiHandler = null;
+    this._discoveredDevices.clear();
+    this._sessions.clear();
+    this.emitter.removeAllListeners();
+  }
+  // ---------------------------------------------------------------------------
+  // Device management
+  // ---------------------------------------------------------------------------
+  async searchDevices() {
+    await this._ensureDevicePermission();
+    const devices = await this.connector.searchDevices();
+    for (const d of devices) {
+      if (d.connectId && !this._discoveredDevices.has(d.connectId)) {
+        this._discoveredDevices.set(d.connectId, this.connectorDeviceToDeviceInfo(d));
+      }
+    }
+    if (this._discoveredDevices.size === 0) {
+      await this._ensureDevicePermission();
+    }
+    return Array.from(this._discoveredDevices.values());
+  }
+  async connectDevice(connectId) {
+    await this._ensureDevicePermission(connectId);
+    try {
+      const session = await this.connector.connect(connectId);
+      this._sessions.set(connectId, session.sessionId);
+      if (session.deviceInfo) {
+        this._discoveredDevices.set(connectId, session.deviceInfo);
+      }
+      return (0, import_hardware_wallet_core2.success)(connectId);
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  async disconnectDevice(connectId) {
+    const sessionId = this._sessions.get(connectId);
+    if (sessionId) {
+      await this.connector.disconnect(sessionId);
+      this._sessions.delete(connectId);
+    }
+  }
+  async getDeviceInfo(connectId, deviceId) {
+    await this._ensureDevicePermission(connectId, deviceId);
+    const cached = this._discoveredDevices.get(connectId) ?? Array.from(this._discoveredDevices.values()).find(
+      (d) => d.deviceId === deviceId
+    );
+    if (cached) {
+      return (0, import_hardware_wallet_core2.success)(cached);
+    }
+    return (0, import_hardware_wallet_core2.failure)(
+      import_hardware_wallet_core2.HardwareErrorCode.DeviceNotFound,
+      "Device not found in cache. Call searchDevices() or wait for a device-connected event first."
+    );
+  }
+  getSupportedChains() {
+    return ["evm", "btc", "sol"];
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+  }
+  cancel(connectId) {
+    const sessionId = this._sessions.get(connectId) ?? connectId;
+    void this.connector.cancel(sessionId);
+  }
+  // ---------------------------------------------------------------------------
+  // EVM methods
+  // ---------------------------------------------------------------------------
+  async evmGetAddress(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    try {
+      const result = await this.connectorCall(connectId, "evmGetAddress", {
+        path: params.path,
+        showOnDevice: params.showOnDevice,
+        chainId: params.chainId
+      });
+      return (0, import_hardware_wallet_core2.success)({
+        address: result.address,
+        path: params.path
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  async evmGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.batchCall(
+      params,
+      (p) => this.evmGetAddress(connectId, deviceId, p),
+      onProgress
+    );
+  }
+  async evmGetPublicKey(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    try {
+      const result = await this.connectorCall(connectId, "evmGetAddress", {
+        path: params.path,
+        showOnDevice: params.showOnDevice
+      });
+      return (0, import_hardware_wallet_core2.success)({
+        publicKey: result.publicKey,
+        path: params.path
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  async evmSignTransaction(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    try {
+      const result = await this.connectorCall(connectId, "evmSignTransaction", {
+        path: params.path,
+        transaction: {
+          to: params.to,
+          value: params.value,
+          chainId: params.chainId,
+          nonce: params.nonce,
+          gasLimit: params.gasLimit,
+          gasPrice: params.gasPrice,
+          maxFeePerGas: params.maxFeePerGas,
+          maxPriorityFeePerGas: params.maxPriorityFeePerGas,
+          accessList: params.accessList,
+          data: params.data
+        }
+      });
+      return (0, import_hardware_wallet_core2.success)({
+        v: ensure0x(result.v),
+        r: padHex64(result.r),
+        s: padHex64(result.s)
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  async evmSignMessage(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    try {
+      const result = await this.connectorCall(connectId, "evmSignMessage", {
+        path: params.path,
+        message: params.message
+      });
+      return (0, import_hardware_wallet_core2.success)({
+        signature: ensure0x(result.signature)
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  async evmSignTypedData(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    if (params.mode === "hash") {
+      return (0, import_hardware_wallet_core2.failure)(
+        import_hardware_wallet_core2.HardwareErrorCode.MethodNotSupported,
+        'Ledger does not support hash-only EIP-712 signing. Use mode "full" with the complete typed data structure.'
+      );
+    }
+    try {
+      const result = await this.connectorCall(connectId, "evmSignTypedData", {
+        path: params.path,
+        data: params.data
+      });
+      return (0, import_hardware_wallet_core2.success)({
+        signature: ensure0x(result.signature)
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // BTC methods
+  // ---------------------------------------------------------------------------
+  async btcGetAddress(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    try {
+      const result = await this.connectorCall(connectId, "btcGetAddress", {
+        path: params.path,
+        coin: params.coin,
+        showOnDevice: params.showOnDevice,
+        scriptType: params.scriptType
+      });
+      return (0, import_hardware_wallet_core2.success)({
+        address: result.address,
+        path: params.path
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  async btcGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.batchCall(
+      params,
+      (p) => this.btcGetAddress(connectId, deviceId, p),
+      onProgress
+    );
+  }
+  async btcGetPublicKey(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    try {
+      const result = await this.connectorCall(connectId, "btcGetPublicKey", {
+        path: params.path,
+        coin: params.coin,
+        showOnDevice: params.showOnDevice
+      });
+      return (0, import_hardware_wallet_core2.success)({
+        xpub: result.xpub,
+        publicKey: result.publicKey ?? "",
+        fingerprint: result.fingerprint ?? 0,
+        chainCode: result.chainCode ?? "",
+        path: params.path,
+        depth: result.depth ?? 0
+      });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  async btcSignTransaction(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    if (!params.psbt) {
+      return (0, import_hardware_wallet_core2.failure)(
+        import_hardware_wallet_core2.HardwareErrorCode.InvalidParams,
+        "Ledger requires PSBT format for BTC transaction signing. Provide params.psbt."
+      );
+    }
+    return (0, import_hardware_wallet_core2.failure)(
+      import_hardware_wallet_core2.HardwareErrorCode.MethodNotSupported,
+      "BTC transaction signing via PSBT is not yet implemented for Ledger."
+    );
+  }
+  async btcSignMessage(_connectId, _deviceId, _params) {
+    return (0, import_hardware_wallet_core2.failure)(
+      import_hardware_wallet_core2.HardwareErrorCode.MethodNotSupported,
+      "BTC message signing is not yet supported on Ledger."
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Device fingerprint
+  // ---------------------------------------------------------------------------
+  async btcGetMasterFingerprint(connectId, _deviceId, params) {
+    await this._ensureDevicePermission(connectId, _deviceId);
+    try {
+      const result = await this.connectorCall(connectId, "btcGetMasterFingerprint", {
+        skipOpenApp: params?.skipOpenApp
+      });
+      return (0, import_hardware_wallet_core2.success)({ masterFingerprint: result.masterFingerprint });
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Solana methods (stubs -- not yet supported)
+  // ---------------------------------------------------------------------------
+  async solGetAddress(_connectId, _deviceId, _params) {
+    return (0, import_hardware_wallet_core2.failure)(import_hardware_wallet_core2.HardwareErrorCode.MethodNotSupported, "Solana not supported on Ledger yet");
+  }
+  async solGetAddresses(_connectId, _deviceId, _params, _onProgress) {
+    return (0, import_hardware_wallet_core2.failure)(import_hardware_wallet_core2.HardwareErrorCode.MethodNotSupported, "Solana not supported on Ledger yet");
+  }
+  async solGetPublicKey(_connectId, _deviceId, _params) {
+    return (0, import_hardware_wallet_core2.failure)(import_hardware_wallet_core2.HardwareErrorCode.MethodNotSupported, "Solana not supported on Ledger yet");
+  }
+  async solSignTransaction(_connectId, _deviceId, _params) {
+    return (0, import_hardware_wallet_core2.failure)(import_hardware_wallet_core2.HardwareErrorCode.MethodNotSupported, "Solana not supported on Ledger yet");
+  }
+  async solSignMessage(_connectId, _deviceId, _params) {
+    return (0, import_hardware_wallet_core2.failure)(import_hardware_wallet_core2.HardwareErrorCode.MethodNotSupported, "Solana signMessage is not supported on Ledger yet");
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Call the connector with session resolution.
+   * Looks up sessionId from connectId, falls back to connectId itself.
+   */
+  async connectorCall(connectId, method, params) {
+    const sessionId = this._sessions.get(connectId) ?? connectId;
+    return this.connector.call(sessionId, method, params);
+  }
+  /**
+   * Ensure device permission before proceeding.
+   * - No connectId (searchDevices): check environment-level permission
+   * - With connectId (business methods): check device-level permission
+   * If not granted, calls onDevicePermission so the consumer can request access.
+   */
+  async _ensureDevicePermission(connectId, deviceId) {
+    const transportType = "hid";
+    let granted = false;
+    let context;
+    if (this._uiHandler?.checkDevicePermission) {
+      try {
+        const result = await this._uiHandler.checkDevicePermission({ transportType, connectId, deviceId });
+        granted = result.granted;
+        context = result.context;
+      } catch {
+        granted = false;
+      }
+    }
+    if (!granted) {
+      try {
+        await this._uiHandler?.onDevicePermission?.({ transportType, context });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Convert a thrown error to a Response failure.
+   * Uses mapLedgerError to parse Ledger DMK error codes into HardwareErrorCode values.
+   */
+  errorToFailure(err) {
+    console.error("[LedgerAdapter] error:", err);
+    const mapped = mapLedgerError(err);
+    if (mapped.code === import_hardware_wallet_core2.HardwareErrorCode.DeviceLocked) {
+      this.emitter.emit(import_hardware_wallet_core2.UI_REQUEST.REQUEST_BUTTON, {
+        type: import_hardware_wallet_core2.UI_REQUEST.REQUEST_BUTTON,
+        payload: {
+          device: this.unknownDevice(),
+          code: "ButtonRequest_Other"
+        }
+      });
+    }
+    return (0, import_hardware_wallet_core2.failure)(mapped.code, mapped.message);
+  }
+  /**
+   * Generic batch call with progress reporting.
+   * If any single call fails, returns the failure immediately.
+   */
+  async batchCall(params, callFn, onProgress) {
+    const results = [];
+    for (let i = 0; i < params.length; i++) {
+      const result = await callFn(params[i]);
+      if (!result.success) {
+        return result;
+      }
+      results.push(result.payload);
+      onProgress?.({ index: i, total: params.length });
+    }
+    return (0, import_hardware_wallet_core2.success)(results);
+  }
+  registerEventListeners() {
+    this.connector.on("device-connect", this.deviceConnectHandler);
+    this.connector.on("device-disconnect", this.deviceDisconnectHandler);
+    this.connector.on("ui-request", this.uiRequestHandler);
+    this.connector.on("ui-event", this.uiEventHandler);
+  }
+  unregisterEventListeners() {
+    this.connector.off("device-connect", this.deviceConnectHandler);
+    this.connector.off("device-disconnect", this.deviceDisconnectHandler);
+    this.connector.off("ui-request", this.uiRequestHandler);
+    this.connector.off("ui-event", this.uiEventHandler);
+  }
+  handleUiEvent(event) {
+    if (!event.type) return;
+    const payload = event.payload;
+    const deviceInfo = payload ? this.extractDeviceInfoFromPayload(payload) : this.unknownDevice();
+    switch (event.type) {
+      case "ui-request_confirmation":
+        this.emitter.emit(import_hardware_wallet_core2.UI_REQUEST.REQUEST_BUTTON, {
+          type: import_hardware_wallet_core2.UI_REQUEST.REQUEST_BUTTON,
+          payload: { device: deviceInfo }
+        });
+        break;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Device info mapping
+  // ---------------------------------------------------------------------------
+  connectorDeviceToDeviceInfo(device) {
+    return {
+      vendor: "ledger",
+      model: device.model ?? "unknown",
+      firmwareVersion: "",
+      deviceId: device.deviceId,
+      connectId: device.connectId,
+      label: device.name,
+      connectionType: "usb"
+    };
+  }
+  extractDeviceInfoFromPayload(payload) {
+    return {
+      vendor: "ledger",
+      model: payload["model"] ?? "unknown",
+      firmwareVersion: "",
+      deviceId: payload["deviceId"] ?? payload["id"] ?? "",
+      connectId: payload["connectId"] ?? payload["path"] ?? "",
+      label: payload["label"],
+      connectionType: "usb"
+    };
+  }
+  unknownDevice() {
+    return {
+      vendor: "ledger",
+      model: "unknown",
+      firmwareVersion: "",
+      deviceId: "",
+      connectId: "",
+      connectionType: "usb"
+    };
+  }
+};
+
+// src/device/LedgerDeviceManager.ts
+var LedgerDeviceManager = class {
+  constructor(dmk) {
+    this._discovered = /* @__PURE__ */ new Map();
+    this._sessions = /* @__PURE__ */ new Map();
+    // deviceId → sessionId
+    this._sessionToDevice = /* @__PURE__ */ new Map();
+    // sessionId → deviceId
+    this._listenSub = null;
+    this._dmk = dmk;
+  }
+  /**
+   * One-shot enumeration: subscribe to listenToAvailableDevices,
+   * take the first emission, unsubscribe, return DeviceDescriptors.
+   */
+  enumerate() {
+    return new Promise((resolve) => {
+      const sub = this._dmk.listenToAvailableDevices().subscribe({
+        next: (devices) => {
+          this._discovered.clear();
+          for (const d of devices) {
+            this._discovered.set(d.id, d);
+          }
+          sub.unsubscribe();
+          resolve(devices.map((d) => ({ path: d.id, type: d.deviceModel.id })));
+        },
+        error: () => {
+          sub.unsubscribe();
+          resolve([]);
+        }
+      });
+    });
+  }
+  /**
+   * Continuous listening: tracks device connect/disconnect via diffing.
+   */
+  listen(onChange) {
+    this.stopListening();
+    let previousIds = /* @__PURE__ */ new Set();
+    this._listenSub = this._dmk.listenToAvailableDevices().subscribe({
+      next: (devices) => {
+        const currentIds = new Set(devices.map((d) => d.id));
+        for (const d of devices) {
+          this._discovered.set(d.id, d);
+          if (!previousIds.has(d.id)) {
+            onChange({ type: "device-connected", descriptor: { path: d.id, type: d.deviceModel.id } });
+          }
+        }
+        for (const id of previousIds) {
+          if (!currentIds.has(id)) {
+            this._discovered.delete(id);
+            onChange({ type: "device-disconnected", descriptor: { path: id } });
+          }
+        }
+        previousIds = currentIds;
+      }
+    });
+  }
+  stopListening() {
+    this._listenSub?.unsubscribe();
+    this._listenSub = null;
+  }
+  /**
+   * Trigger browser device selection (WebHID requestDevice).
+   * Starts discovery for a short period, then stops.
+   */
+  requestDevice(timeoutMs = 3e3) {
+    return new Promise((resolve) => {
+      const sub = this._dmk.startDiscovering().subscribe({
+        next: (d) => {
+          this._discovered.set(d.id, d);
+        },
+        error: () => {
+          sub.unsubscribe();
+          resolve();
+        }
+      });
+      setTimeout(() => {
+        sub.unsubscribe();
+        this._dmk.stopDiscovering();
+        resolve();
+      }, timeoutMs);
+    });
+  }
+  /** Connect to a previously discovered device. Returns sessionId. */
+  async connect(deviceId) {
+    const device = this._discovered.get(deviceId);
+    if (!device) {
+      throw new Error(`Device "${deviceId}" not found. Call enumerate() or listen() first.`);
+    }
+    const sessionId = await this._dmk.connect({ device });
+    this._sessions.set(deviceId, sessionId);
+    this._sessionToDevice.set(sessionId, deviceId);
+    return sessionId;
+  }
+  /** Disconnect a session. */
+  async disconnect(sessionId) {
+    await this._dmk.disconnect({ sessionId });
+    const deviceId = this._sessionToDevice.get(sessionId);
+    if (deviceId) this._sessions.delete(deviceId);
+    this._sessionToDevice.delete(sessionId);
+  }
+  getSessionId(deviceId) {
+    return this._sessions.get(deviceId);
+  }
+  getDeviceId(sessionId) {
+    return this._sessionToDevice.get(sessionId);
+  }
+  /** Get the underlying DMK instance (needed by SignerManager). */
+  getDmk() {
+    return this._dmk;
+  }
+  dispose() {
+    this.stopListening();
+    this._discovered.clear();
+    this._sessions.clear();
+    this._sessionToDevice.clear();
+    this._dmk.close?.();
+  }
+};
+
+// src/signer/deviceActionToPromise.ts
+function deviceActionToPromise(action, onInteraction) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let sub;
+    sub = action.observable.subscribe({
+      next: (state) => {
+        if (settled) return;
+        if (state.status === "completed") {
+          settled = true;
+          sub?.unsubscribe();
+          resolve(state.output);
+        } else if (state.status === "error") {
+          settled = true;
+          sub?.unsubscribe();
+          reject(state.error);
+        } else if (state.status === "pending" && onInteraction) {
+          const interaction = state.intermediateValue?.requiredUserInteraction;
+          if (interaction && interaction !== "none") {
+            onInteraction(interaction);
+          }
+        }
+      },
+      error: (err) => {
+        if (!settled) {
+          settled = true;
+          sub?.unsubscribe();
+          reject(err);
+        }
+      },
+      complete: () => {
+        if (!settled) {
+          settled = true;
+          reject(new Error("Device action completed without result"));
+        }
+      }
+    });
+  });
+}
+
+// src/signer/SignerEth.ts
+function hexToBytes(hex) {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(h.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(h.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+var SignerEth = class {
+  constructor(_sdk) {
+    this._sdk = _sdk;
+  }
+  async getAddress(derivationPath, options) {
+    const action = this._sdk.getAddress(derivationPath, {
+      checkOnDevice: options?.checkOnDevice ?? false
+    });
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+  async signTransaction(derivationPath, serializedTxHex) {
+    const action = this._sdk.signTransaction(derivationPath, hexToBytes(serializedTxHex));
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+  async signMessage(derivationPath, message) {
+    const action = this._sdk.signMessage(derivationPath, message);
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+  async signTypedData(derivationPath, data) {
+    const action = this._sdk.signTypedData(derivationPath, data);
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+};
+
+// src/signer/SignerManager.ts
+var SignerManager = class _SignerManager {
+  constructor(dmk, builderFn) {
+    this._cache = /* @__PURE__ */ new Map();
+    this._dmk = dmk;
+    this._builderFn = builderFn ?? _SignerManager._defaultBuilder();
+  }
+  async getOrCreate(sessionId) {
+    let signer = this._cache.get(sessionId);
+    if (signer) return signer;
+    const builder = await this._builderFn({ dmk: this._dmk, sessionId });
+    const sdkSigner = builder.build();
+    signer = new SignerEth(sdkSigner);
+    this._cache.set(sessionId, signer);
+    return signer;
+  }
+  invalidate(sessionId) {
+    this._cache.delete(sessionId);
+  }
+  clearAll() {
+    this._cache.clear();
+  }
+  static _defaultBuilder() {
+    let BuilderClass = null;
+    return async (args) => {
+      if (!BuilderClass) {
+        const mod = await import("@ledgerhq/device-signer-kit-ethereum");
+        BuilderClass = mod.SignerEthBuilder;
+      }
+      return new BuilderClass(args);
+    };
+  }
+};
+
+// src/signer/SignerBtc.ts
+var SignerBtc = class {
+  constructor(_sdk) {
+    this._sdk = _sdk;
+  }
+  async getWalletAddress(wallet, addressIndex, options) {
+    const action = this._sdk.getWalletAddress(wallet, addressIndex, {
+      checkOnDevice: options?.checkOnDevice ?? false,
+      change: options?.change ?? false
+    });
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+  async getExtendedPublicKey(derivationPath, options) {
+    const action = this._sdk.getExtendedPublicKey(derivationPath, {
+      checkOnDevice: options?.checkOnDevice ?? false
+    });
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+  async getMasterFingerprint(options) {
+    const action = this._sdk.getMasterFingerprint(options);
+    const result = await deviceActionToPromise(action, this.onInteraction);
+    return result.masterFingerprint;
+  }
+};
+
+// src/transport/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function normalizeType(type) {
+  return type.trim().toLowerCase();
+}
+function registerTransport(type, provider) {
+  const key = normalizeType(type);
+  if (!key) throw new Error("Transport type must be a non-empty string");
+  registry.set(key, provider);
+}
+function unregisterTransport(type) {
+  registry.delete(normalizeType(type));
+}
+function getTransportProvider(type) {
+  return registry.get(normalizeType(type)) ?? null;
+}
+function listRegisteredTransports() {
+  return Array.from(registry.keys());
+}
+function clearRegistry() {
+  registry.clear();
+}
+
+// src/app/AppManager.ts
+var APP_NAME_MAP = {
+  ETH: "Ethereum",
+  BTC: "Bitcoin",
+  SOL: "Solana",
+  TRX: "Tron",
+  XRP: "XRP",
+  ADA: "Cardano",
+  DOT: "Polkadot",
+  ATOM: "Cosmos"
+};
+var DASHBOARD_APP_NAME = "BOLOS";
+var AppManager = class {
+  constructor(dmk, options) {
+    this._dmk = dmk;
+    this._waitMs = options?.waitMs ?? 1e3;
+    this._maxRetries = options?.maxRetries ?? 10;
+  }
+  /**
+   * Return the Ledger app name for a given chain ticker,
+   * or undefined if the chain is not supported.
+   */
+  static getAppName(chain) {
+    return APP_NAME_MAP[chain];
+  }
+  /**
+   * Ensure the target app is open on the device identified by `sessionId`.
+   *
+   * Flow:
+   * 1. Check the currently running app.
+   * 2. If it is already the target, return immediately.
+   * 3. If a different app is running (not dashboard), close it first.
+   * 4. Open the target app.
+   * 5. Poll until the device confirms the target app is running.
+   */
+  async ensureAppOpen(sessionId, targetAppName) {
+    const currentApp = await this._getCurrentApp(sessionId);
+    if (currentApp === targetAppName) {
+      return;
+    }
+    if (!this._isDashboard(currentApp)) {
+      await this._closeCurrentApp(sessionId);
+      await this._waitForApp(sessionId, DASHBOARD_APP_NAME);
+    }
+    await this._openApp(sessionId, targetAppName);
+    await this._waitForApp(sessionId, targetAppName);
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  async _getCurrentApp(sessionId) {
+    const result = await this._dmk.sendCommand({
+      sessionId,
+      command: { type: "get-app-and-version" }
+    });
+    return result.name;
+  }
+  async _openApp(sessionId, appName) {
+    await this._dmk.sendCommand({
+      sessionId,
+      command: { type: "open-app", appName }
+    });
+  }
+  async _closeCurrentApp(sessionId) {
+    await this._dmk.sendCommand({
+      sessionId,
+      command: { type: "close-app" }
+    });
+  }
+  /**
+   * Poll the device until the expected app is reported as running,
+   * or throw after `_maxRetries` attempts.
+   */
+  async _waitForApp(sessionId, expectedAppName) {
+    for (let i = 0; i < this._maxRetries; i++) {
+      await this._wait();
+      const current = await this._getCurrentApp(sessionId);
+      if (current === expectedAppName) {
+        return;
+      }
+    }
+    throw new Error(
+      `Ledger: failed to open "${expectedAppName}" after ${this._maxRetries} retries`
+    );
+  }
+  _isDashboard(appName) {
+    return appName === DASHBOARD_APP_NAME;
+  }
+  _wait() {
+    return new Promise((resolve) => setTimeout(resolve, this._waitMs));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppManager,
+  LedgerAdapter,
+  LedgerDeviceManager,
+  SignerBtc,
+  SignerEth,
+  SignerManager,
+  clearRegistry,
+  deviceActionToPromise,
+  getTransportProvider,
+  isDeviceLockedError,
+  listRegisteredTransports,
+  mapLedgerError,
+  registerTransport,
+  unregisterTransport
+});
+//# sourceMappingURL=index.js.map