@onekeyfe/hwk-ledger-adapter 1.1.26-alpha.100

package/dist/index.js

@@ -0,0 +1,2338 @@
+"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,
+  DmkTransport: () => DmkTransport,
+  LedgerAdapter: () => LedgerAdapter,
+  LedgerConnectorBase: () => LedgerConnectorBase,
+  LedgerDeviceManager: () => LedgerDeviceManager,
+  SignerBtc: () => SignerBtc,
+  SignerEth: () => SignerEth,
+  SignerManager: () => SignerManager,
+  SignerSol: () => SignerSol,
+  deviceActionToPromise: () => deviceActionToPromise,
+  isDeviceLockedError: () => isDeviceLockedError,
+  mapLedgerError: () => mapLedgerError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/adapter/LedgerAdapter.ts
+var import_hwk_adapter_core2 = require("@onekeyfe/hwk-adapter-core");
+
+// src/errors.ts
+var import_hwk_adapter_core = require("@onekeyfe/hwk-adapter-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", "6a83", "27267"]);
+var APP_NOT_INSTALLED_CODES = /* @__PURE__ */ new Set(["6807", "26631"]);
+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|device exchange error/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 isAppNotInstalledError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e._tag === "OpenAppCommandError") return true;
+  if (typeof e.message === "string" && /unknown application/i.test(e.message)) return true;
+  if (hasStatusCode(err, APP_NOT_INSTALLED_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|timed out.*locked/i.test(
+    e.message
+  ))
+    return true;
+  return false;
+}
+var TIMEOUT_TAGS = /* @__PURE__ */ new Set([
+  "DeviceExchangeTimeoutError",
+  "SendApduTimeoutError",
+  "SendCommandTimeoutError"
+]);
+function isTimeoutError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (typeof e._tag === "string" && TIMEOUT_TAGS.has(e._tag)) return true;
+  if (e.code === import_hwk_adapter_core.HardwareErrorCode.OperationTimeout) return true;
+  return false;
+}
+function mapLedgerError(err) {
+  let originalMessage = "Unknown Ledger error";
+  if (err instanceof Error) {
+    originalMessage = err.message;
+  } else if (err && typeof err === "object") {
+    const e = err;
+    originalMessage = String(e.message ?? e._tag ?? e.type ?? JSON.stringify(err));
+  }
+  let code;
+  if (isDeviceLockedError(err)) {
+    code = import_hwk_adapter_core.HardwareErrorCode.DeviceLocked;
+  } else if (isUserRejectedError(err)) {
+    code = import_hwk_adapter_core.HardwareErrorCode.UserRejected;
+  } else if (isWrongAppError(err)) {
+    code = import_hwk_adapter_core.HardwareErrorCode.WrongApp;
+  } else if (isAppNotInstalledError(err)) {
+    code = import_hwk_adapter_core.HardwareErrorCode.AppNotOpen;
+  } else if (isDeviceDisconnectedError(err)) {
+    code = import_hwk_adapter_core.HardwareErrorCode.DeviceDisconnected;
+  } else if (isTimeoutError(err)) {
+    code = import_hwk_adapter_core.HardwareErrorCode.OperationTimeout;
+  } else {
+    code = import_hwk_adapter_core.HardwareErrorCode.UnknownError;
+  }
+  return { code, message: (0, import_hwk_adapter_core.enrichErrorMessage)(code, originalMessage) };
+}
+
+// src/adapter/LedgerAdapter.ts
+var _LedgerAdapter = class _LedgerAdapter {
+  constructor(connector) {
+    this.vendor = "ledger";
+    this.emitter = new import_hwk_adapter_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();
+    // Pending device-connect resolve — set by _waitForDeviceConnect, resolved by uiResponse
+    this._deviceConnectResolve = null;
+    // Mutex for ensureConnected — prevents concurrent calls from establishing duplicate connections
+    this._connectingPromise = null;
+    // ---------------------------------------------------------------------------
+    // Event translation
+    // ---------------------------------------------------------------------------
+    this.deviceConnectHandler = (data) => {
+      const deviceInfo = this.connectorDeviceToDeviceInfo(data.device);
+      this._discoveredDevices.set(deviceInfo.connectId, deviceInfo);
+      this._sessions.delete(deviceInfo.connectId);
+      this.emitter.emit(import_hwk_adapter_core2.DEVICE.CONNECT, {
+        type: import_hwk_adapter_core2.DEVICE.CONNECT,
+        payload: deviceInfo
+      });
+    };
+    this.deviceDisconnectHandler = (data) => {
+      this._discoveredDevices.delete(data.connectId);
+      this._sessions.delete(data.connectId);
+      this.emitter.emit(import_hwk_adapter_core2.DEVICE.DISCONNECT, {
+        type: import_hwk_adapter_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) {
+  }
+  /**
+   * Clear cached device/session state without tearing down the adapter.
+   * Call before retrying after errors or when the device state may be stale.
+   * The next operation will re-discover and re-connect automatically.
+   */
+  resetState() {
+    this._discoveredDevices.clear();
+    this._sessions.clear();
+    this._connectingPromise = null;
+  }
+  async dispose() {
+    this._deviceConnectResolve?.(true);
+    this._deviceConnectResolve = null;
+    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();
+    console.log("[DMK] adapter.searchDevices raw:", JSON.stringify(devices));
+    for (const d of devices) {
+      if (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_hwk_adapter_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_hwk_adapter_core2.success)(cached);
+    }
+    return (0, import_hwk_adapter_core2.failure)(
+      import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound,
+      "Device not found in cache. Call searchDevices() or wait for a device-connected event first."
+    );
+  }
+  getSupportedChains() {
+    return ["evm", "btc", "sol", "tron"];
+  }
+  // ---------------------------------------------------------------------------
+  // Chain call helper
+  // ---------------------------------------------------------------------------
+  async callChain(connectId, deviceId, chain, method, params, skipFingerprint = false) {
+    await this._ensureDevicePermission(connectId, deviceId);
+    if (!skipFingerprint && !await this._verifyDeviceFingerprint(connectId, deviceId, chain)) {
+      return (0, import_hwk_adapter_core2.failure)(import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch, "Wrong device connected");
+    }
+    try {
+      const result = await this.connectorCall(connectId, method, params);
+      return (0, import_hwk_adapter_core2.success)(result);
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  /**
+   * Batch version of callChain — checks permission and fingerprint once,
+   * then calls the connector for each param sequentially.
+   */
+  async callChainBatch(connectId, deviceId, chain, method, params, onProgress, skipFingerprint = false) {
+    await this._ensureDevicePermission(connectId, deviceId);
+    if (!skipFingerprint && !await this._verifyDeviceFingerprint(connectId, deviceId, chain)) {
+      return (0, import_hwk_adapter_core2.failure)(import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch, "Wrong device connected");
+    }
+    const results = [];
+    for (let i = 0; i < params.length; i++) {
+      try {
+        const result = await this.connectorCall(connectId, method, params[i]);
+        results.push(result);
+        onProgress?.({ index: i, total: params.length });
+      } catch (err) {
+        return this.errorToFailure(err);
+      }
+    }
+    return (0, import_hwk_adapter_core2.success)(results);
+  }
+  // ---------------------------------------------------------------------------
+  // EVM chain methods
+  // ---------------------------------------------------------------------------
+  evmGetAddress(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "evm", "evmGetAddress", params);
+  }
+  evmGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.callChainBatch(
+      connectId,
+      deviceId,
+      "evm",
+      "evmGetAddress",
+      params,
+      onProgress
+    );
+  }
+  evmGetPublicKey(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "evm", "evmGetAddress", params);
+  }
+  evmSignTransaction(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "evm", "evmSignTransaction", params);
+  }
+  evmSignMessage(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "evm", "evmSignMessage", params);
+  }
+  evmSignTypedData(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "evm", "evmSignTypedData", params);
+  }
+  // ---------------------------------------------------------------------------
+  // BTC chain methods
+  // ---------------------------------------------------------------------------
+  btcGetAddress(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "btc", "btcGetAddress", params);
+  }
+  btcGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.callChainBatch(
+      connectId,
+      deviceId,
+      "btc",
+      "btcGetAddress",
+      params,
+      onProgress
+    );
+  }
+  btcGetPublicKey(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "btc", "btcGetPublicKey", params);
+  }
+  btcSignTransaction(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "btc", "btcSignTransaction", params);
+  }
+  btcSignMessage(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "btc", "btcSignMessage", params);
+  }
+  btcGetMasterFingerprint(connectId, deviceId) {
+    return this.callChain(
+      connectId,
+      deviceId,
+      "btc",
+      "btcGetMasterFingerprint",
+      {}
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // SOL chain methods
+  // ---------------------------------------------------------------------------
+  solGetAddress(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "sol", "solGetAddress", params);
+  }
+  solGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.callChainBatch(
+      connectId,
+      deviceId,
+      "sol",
+      "solGetAddress",
+      params,
+      onProgress
+    );
+  }
+  solGetPublicKey(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "sol", "solGetAddress", params);
+  }
+  solSignTransaction(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "sol", "solSignTransaction", params);
+  }
+  solSignMessage(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "sol", "solSignMessage", params);
+  }
+  // ---------------------------------------------------------------------------
+  // TRON chain methods
+  // ---------------------------------------------------------------------------
+  tronGetAddress(connectId, deviceId, params) {
+    return this.callChain(connectId, deviceId, "tron", "tronGetAddress", params, true);
+  }
+  tronGetAddresses(connectId, deviceId, params, onProgress) {
+    return this.callChainBatch(
+      connectId,
+      deviceId,
+      "tron",
+      "tronGetAddress",
+      params,
+      onProgress,
+      true
+    );
+  }
+  tronSignTransaction(connectId, deviceId, params) {
+    return this.callChain(
+      connectId,
+      deviceId,
+      "tron",
+      "tronSignTransaction",
+      params,
+      true
+    );
+  }
+  tronSignMessage(connectId, deviceId, params) {
+    return this.callChain(
+      connectId,
+      deviceId,
+      "tron",
+      "tronSignMessage",
+      params,
+      true
+    );
+  }
+  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);
+  }
+  // ---------------------------------------------------------------------------
+  // Chain fingerprint
+  // ---------------------------------------------------------------------------
+  async getChainFingerprint(connectId, deviceId, chain) {
+    console.log(
+      "[LedgerAdapter] getChainFingerprint called, chain:",
+      chain,
+      "connectId:",
+      connectId || "(empty)",
+      "sessions:",
+      this._sessions.size
+    );
+    await this._ensureDevicePermission(connectId, deviceId);
+    console.log(
+      "[LedgerAdapter] getChainFingerprint permission ok, calling _deriveAddressForFingerprint"
+    );
+    try {
+      const address = await this._deriveAddressForFingerprint(connectId, chain);
+      console.log("[LedgerAdapter] getChainFingerprint address:", address?.substring(0, 20));
+      return (0, import_hwk_adapter_core2.success)((0, import_hwk_adapter_core2.deriveDeviceFingerprint)(address));
+    } catch (err) {
+      console.error(
+        "[LedgerAdapter] getChainFingerprint error in _deriveAddressForFingerprint:",
+        chain,
+        err
+      );
+      return this.errorToFailure(err);
+    }
+  }
+  /**
+   * Verify that the connected device matches the expected fingerprint.
+   *
+   * - If deviceId is empty, verification is skipped (returns true).
+   * - deviceId is used here as the stored fingerprint to compare against.
+   */
+  async _verifyDeviceFingerprint(connectId, deviceId, chain) {
+    if (!deviceId) return true;
+    try {
+      const address = await this._deriveAddressForFingerprint(connectId, chain);
+      const fingerprint = (0, import_hwk_adapter_core2.deriveDeviceFingerprint)(address);
+      return fingerprint === deviceId;
+    } catch (err) {
+      const mapped = mapLedgerError(err);
+      if (mapped.code === import_hwk_adapter_core2.HardwareErrorCode.WrongApp || mapped.code === import_hwk_adapter_core2.HardwareErrorCode.DeviceLocked) {
+        return true;
+      }
+      throw err;
+    }
+  }
+  /**
+   * Derive an address at the fixed testnet path for fingerprint generation.
+   */
+  async _deriveAddressForFingerprint(connectId, chain) {
+    const path = import_hwk_adapter_core2.CHAIN_FINGERPRINT_PATHS[chain];
+    if (chain === "evm") {
+      const result = await this.connectorCall(connectId, "evmGetAddress", {
+        path,
+        showOnDevice: false
+      });
+      return result.address;
+    }
+    if (chain === "btc") {
+      const result = await this.connectorCall(connectId, "btcGetPublicKey", {
+        path,
+        showOnDevice: false
+      });
+      return result.xpub;
+    }
+    if (chain === "sol") {
+      const result = await this.connectorCall(connectId, "solGetAddress", {
+        path,
+        showOnDevice: false
+      });
+      return result.address;
+    }
+    if (chain === "tron") {
+      const result = await this.connectorCall(connectId, "tronGetAddress", {
+        path,
+        showOnDevice: false
+      });
+      return result.address;
+    }
+    throw new Error(`Unsupported chain for fingerprint: ${chain}`);
+  }
+  /**
+   * Wait for user to connect and unlock device.
+   * Emits 'ui-request' event via the adapter's own emitter.
+   * The consumer (monorepo adapter wrapper) listens for this and shows UI.
+   * When user confirms, they call adapter.deviceConnectResponse() which resolves this promise.
+   * Times out after 60 seconds if no response is received.
+   */
+  _waitForDeviceConnect(attempt) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          this._deviceConnectResolve = null;
+          reject(new Error("Ledger device connect timed out after 60 seconds"));
+        }
+      }, _LedgerAdapter.DEVICE_CONNECT_TIMEOUT_MS);
+      this._deviceConnectResolve = (cancelled) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        this._deviceConnectResolve = null;
+        if (cancelled) {
+          reject(
+            Object.assign(new Error("User cancelled Ledger connection"), {
+              _tag: "DeviceNotRecognizedError"
+            })
+          );
+        } else {
+          resolve();
+        }
+      };
+      this.emitter.emit(import_hwk_adapter_core2.UI_REQUEST.REQUEST_DEVICE_CONNECT, {
+        type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_DEVICE_CONNECT,
+        payload: {
+          message: "Please connect and unlock your Ledger device",
+          retryCount: attempt,
+          maxRetries: _LedgerAdapter.MAX_DEVICE_RETRY
+        }
+      });
+    });
+  }
+  /**
+   * Called by consumer to respond to ui-request-device-connect.
+   * type='confirm' → retry search, type='cancel' → abort.
+   */
+  deviceConnectResponse(type) {
+    if (this._deviceConnectResolve) {
+      this._deviceConnectResolve(type === "cancel");
+    }
+  }
+  async ensureConnected(connectId) {
+    if (connectId && this._sessions.has(connectId)) {
+      return connectId;
+    }
+    if (this._sessions.size > 0) {
+      return this._sessions.keys().next().value;
+    }
+    if (this._connectingPromise) {
+      return this._connectingPromise;
+    }
+    this._connectingPromise = this._doConnect();
+    try {
+      return await this._connectingPromise;
+    } finally {
+      this._connectingPromise = null;
+    }
+  }
+  async _doConnect() {
+    for (let attempt = 0; attempt < _LedgerAdapter.MAX_DEVICE_RETRY; attempt++) {
+      const devices = await this.searchDevices();
+      if (devices.length > 0) {
+        return this._connectFirstOrSelect(devices);
+      }
+      if (attempt < _LedgerAdapter.MAX_DEVICE_RETRY - 1) {
+        await this._waitForDeviceConnect(attempt + 1);
+      }
+    }
+    throw Object.assign(
+      new Error(
+        "No Ledger device found after multiple attempts. Please connect and unlock your device."
+      ),
+      { _tag: "DeviceNotRecognizedError" }
+    );
+  }
+  async _connectFirstOrSelect(devices) {
+    if (devices.length === 1) {
+      const result2 = await this.connectDevice(devices[0].connectId);
+      if (!result2.success) {
+        throw Object.assign(new Error(result2.payload.error), { _tag: "DeviceNotRecognizedError" });
+      }
+      return devices[0].connectId;
+    }
+    if (this._uiHandler?.onSelectDevice) {
+      const selectedConnectId = await this._uiHandler.onSelectDevice(devices);
+      const result2 = await this.connectDevice(selectedConnectId);
+      if (!result2.success) {
+        throw Object.assign(new Error(result2.payload.error), { _tag: "DeviceNotRecognizedError" });
+      }
+      return selectedConnectId;
+    }
+    const result = await this.connectDevice(devices[0].connectId);
+    if (!result.success) {
+      throw Object.assign(new Error(result.payload.error), { _tag: "DeviceNotRecognizedError" });
+    }
+    return devices[0].connectId;
+  }
+  /**
+   * Call the connector with automatic session resolution and disconnect retry.
+   *
+   * 1. Resolves a valid connectId via ensureConnected()
+   * 2. Looks up sessionId from _sessions
+   * 3. Calls connector.call()
+   * 4. On disconnect error: clears stale session, re-connects, retries once
+   */
+  async connectorCall(connectId, method, params) {
+    console.log("[LedgerAdapter] connectorCall:", method, "connectId:", connectId || "(empty)");
+    const resolvedConnectId = await this.ensureConnected(connectId);
+    const sessionId = this._sessions.get(resolvedConnectId);
+    console.log(
+      "[LedgerAdapter] connectorCall resolved:",
+      method,
+      "resolvedConnectId:",
+      resolvedConnectId,
+      "sessionId:",
+      sessionId
+    );
+    if (!sessionId) {
+      throw Object.assign(new Error("Auto-connect succeeded but no session found"), {
+        _tag: "DeviceSessionNotFound"
+      });
+    }
+    try {
+      return await this.connector.call(sessionId, method, params);
+    } catch (err) {
+      const errObj = err;
+      console.log("[LedgerAdapter] connectorCall error:", method, {
+        message: errObj?.message,
+        _tag: errObj?._tag,
+        errorCode: errObj?.errorCode,
+        statusCode: errObj?.statusCode,
+        isDisconnected: isDeviceDisconnectedError(err),
+        isLocked: isDeviceLockedError(err)
+      });
+      if (isDeviceDisconnectedError(err)) {
+        console.log("[LedgerAdapter] disconnected, retrying with fresh connection...");
+        this._discoveredDevices.clear();
+        return this._retryWithFreshConnection(resolvedConnectId, method, params, err);
+      }
+      if (isDeviceLockedError(err)) {
+        await this._waitForDeviceConnect(0);
+        return this.connector.call(sessionId, method, params);
+      }
+      if (isTimeoutError(err)) {
+        console.log("[LedgerAdapter] timeout, retrying with fresh connection...");
+        this._discoveredDevices.delete(resolvedConnectId);
+        return this._retryWithFreshConnection(resolvedConnectId, method, params, err);
+      }
+      throw err;
+    }
+  }
+  /** Clear stale session, reconnect, and retry the call. */
+  async _retryWithFreshConnection(resolvedConnectId, method, params, originalErr) {
+    this._sessions.delete(resolvedConnectId);
+    const retryConnectId = await this.ensureConnected();
+    const retrySessionId = this._sessions.get(retryConnectId);
+    if (!retrySessionId) {
+      throw originalErr;
+    }
+    return this.connector.call(retrySessionId, 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);
+    if (err && typeof err === "object" && "code" in err && typeof err.code === "number") {
+      const e = err;
+      return (0, import_hwk_adapter_core2.failure)(e.code, e.message ?? "Unknown error");
+    }
+    const mapped = mapLedgerError(err);
+    return (0, import_hwk_adapter_core2.failure)(mapped.code, mapped.message);
+  }
+  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_hwk_adapter_core2.UI_REQUEST.REQUEST_BUTTON, {
+          type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_BUTTON,
+          payload: { device: deviceInfo }
+        });
+        break;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Device info mapping
+  // ---------------------------------------------------------------------------
+  connectorDeviceToDeviceInfo(device) {
+    const isBle = device.connectId && /^[0-9A-Fa-f]{4}$/.test(device.connectId);
+    return {
+      vendor: "ledger",
+      model: device.model ?? "unknown",
+      firmwareVersion: "",
+      deviceId: device.deviceId,
+      connectId: device.connectId,
+      label: device.name,
+      connectionType: isBle ? "ble" : "usb",
+      capabilities: device.capabilities
+    };
+  }
+  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"
+    };
+  }
+};
+// ---------------------------------------------------------------------------
+// Private helpers
+// ---------------------------------------------------------------------------
+/**
+ * Ensure at least one device is connected and return a valid connectId.
+ *
+ * - If a session already exists for the given connectId, reuse it.
+ * - If ANY session exists (Ledger IDs are ephemeral), reuse it.
+ * - Otherwise: search → 1 device: auto-connect, multiple: ask user, 0: throw.
+ */
+_LedgerAdapter.MAX_DEVICE_RETRY = 3;
+_LedgerAdapter.DEVICE_CONNECT_TIMEOUT_MS = 6e4;
+var LedgerAdapter = _LedgerAdapter;
+
+// 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;
+    /**
+     * Trigger browser device selection (WebHID requestDevice).
+     * Starts discovery for a short period, then stops.
+     */
+    /**
+     * Start BLE discovery if not already running.
+     * Does NOT stop — DMK keeps scanning in the background so that
+     * listenToAvailableDevices() always has fresh data.
+     */
+    this._discoverySub = null;
+    this._dmk = dmk;
+  }
+  /**
+   * One-shot enumeration: subscribe to listenToAvailableDevices,
+   * take the first emission, unsubscribe, return DeviceDescriptors.
+   */
+  enumerate() {
+    console.log(
+      "[DMK] enumerate() called, dmk exists:",
+      !!this._dmk,
+      "listenToAvailableDevices exists:",
+      typeof this._dmk?.listenToAvailableDevices
+    );
+    return new Promise((resolve) => {
+      let resolved = false;
+      let syncResult = null;
+      let sub = null;
+      sub = this._dmk.listenToAvailableDevices({}).subscribe({
+        next: (devices) => {
+          if (resolved) return;
+          resolved = true;
+          this._discovered.clear();
+          console.log(
+            "[DMK] enumerate raw devices:",
+            JSON.stringify(
+              devices.map((d) => ({
+                id: d.id,
+                deviceModel: d.deviceModel,
+                transport: d.transport,
+                name: d.name,
+                rssi: d.rssi,
+                // Dump all keys to see what else is available
+                _keys: Object.keys(d)
+              }))
+            )
+          );
+          for (const d of devices) {
+            this._discovered.set(d.id, d);
+          }
+          if (sub) {
+            sub.unsubscribe();
+            resolve(
+              devices.map((d) => ({
+                path: d.id,
+                type: d.deviceModel.model,
+                name: d.name,
+                transport: d.transport
+              }))
+            );
+          } else {
+            syncResult = devices;
+          }
+        },
+        error: () => {
+          if (!resolved) {
+            resolved = true;
+            resolve([]);
+          }
+        }
+      });
+      if (syncResult !== null) {
+        sub.unsubscribe();
+        const devices = syncResult;
+        resolve(
+          devices.map((d) => ({
+            path: d.id,
+            type: d.deviceModel.model,
+            name: d.name,
+            transport: d.transport
+          }))
+        );
+      }
+    });
+  }
+  /**
+   * 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);
+          console.log(
+            "[DMK] listen device:",
+            JSON.stringify({
+              id: d.id,
+              deviceModel: d.deviceModel,
+              name: d.name
+            })
+          );
+          if (!previousIds.has(d.id)) {
+            onChange({
+              type: "device-connected",
+              descriptor: {
+                path: d.id,
+                type: d.deviceModel.model,
+                name: d.name,
+                transport: d.transport
+              }
+            });
+          }
+        }
+        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;
+  }
+  requestDevice() {
+    if (this._discoverySub) {
+      return Promise.resolve();
+    }
+    console.log("[DMK] requestDevice() starting persistent BLE scan");
+    this._discoverySub = this._dmk.startDiscovering({}).subscribe({
+      next: (d) => {
+        console.log("[DMK] BLE discovered:", d.name || d.id);
+        this._discovered.set(d.id, d);
+      },
+      error: (err) => {
+        console.error("[DMK] BLE scan error:", err);
+        this._discoverySub = null;
+      }
+    });
+    return Promise.resolve();
+  }
+  /** 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;
+  }
+  stopDiscovery() {
+    if (this._discoverySub) {
+      this._discoverySub.unsubscribe();
+      this._discoverySub = null;
+      this._dmk.stopDiscovering();
+    }
+  }
+  dispose() {
+    this.stopListening();
+    this.stopDiscovery();
+    this._discovered.clear();
+    this._sessions.clear();
+    this._sessionToDevice.clear();
+    this._dmk.close();
+  }
+};
+
+// src/signer/deviceActionToPromise.ts
+var import_device_management_kit = require("@ledgerhq/device-management-kit");
+var DEFAULT_TIMEOUT_MS = 3e4;
+function deviceActionToPromise(action, onInteraction, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let sub;
+    let timer = null;
+    const resetTimer = () => {
+      if (timer) clearTimeout(timer);
+      if (timeoutMs > 0) {
+        timer = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            sub?.unsubscribe();
+            reject(new Error("Device action timed out \u2014 device may be locked or disconnected"));
+          }
+        }, timeoutMs);
+      }
+    };
+    resetTimer();
+    console.log("[DMK-Observable] subscribing to action.observable...");
+    sub = action.observable.subscribe({
+      next: (state) => {
+        console.log("[DMK-Observable] next received");
+        resetTimer();
+        console.log(
+          "[DMK-Observable] state:",
+          JSON.stringify({
+            status: state.status,
+            intermediateValue: state.status === import_device_management_kit.DeviceActionStatus.Pending ? state.intermediateValue : void 0,
+            hasOutput: state.status === import_device_management_kit.DeviceActionStatus.Completed,
+            hasError: state.status === import_device_management_kit.DeviceActionStatus.Error
+          })
+        );
+        if (settled) return;
+        if (state.status === import_device_management_kit.DeviceActionStatus.Completed) {
+          settled = true;
+          if (timer) clearTimeout(timer);
+          onInteraction?.("interaction-complete");
+          sub?.unsubscribe();
+          resolve(state.output);
+        } else if (state.status === import_device_management_kit.DeviceActionStatus.Error) {
+          settled = true;
+          if (timer) clearTimeout(timer);
+          onInteraction?.("interaction-complete");
+          sub?.unsubscribe();
+          reject(state.error);
+        } else if (state.status === import_device_management_kit.DeviceActionStatus.Pending && onInteraction) {
+          const interaction = state.intermediateValue?.requiredUserInteraction;
+          if (interaction && interaction !== "none") {
+            onInteraction(String(interaction));
+          }
+        }
+      },
+      error: (err) => {
+        if (!settled) {
+          settled = true;
+          if (timer) clearTimeout(timer);
+          sub?.unsubscribe();
+          reject(err);
+        }
+      },
+      complete: () => {
+        if (!settled) {
+          settled = true;
+          if (timer) clearTimeout(timer);
+          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 INTERACTIVE_TIMEOUT_MS = 5 * 6e4;
+var SignerEth = class {
+  constructor(_sdk) {
+    this._sdk = _sdk;
+  }
+  async getAddress(derivationPath, options) {
+    const checkOnDevice = options?.checkOnDevice ?? false;
+    console.log("[DMK] getAddress \u2192 DMK:", { derivationPath, checkOnDevice });
+    const action = this._sdk.getAddress(derivationPath, {
+      checkOnDevice
+    });
+    const timeout = checkOnDevice ? INTERACTIVE_TIMEOUT_MS : void 0;
+    return deviceActionToPromise(action, this.onInteraction, timeout);
+  }
+  async signTransaction(derivationPath, serializedTxHex) {
+    const action = this._sdk.signTransaction(derivationPath, hexToBytes(serializedTxHex));
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      INTERACTIVE_TIMEOUT_MS
+    );
+  }
+  async signMessage(derivationPath, message) {
+    const action = this._sdk.signMessage(derivationPath, hexToBytes(message));
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      INTERACTIVE_TIMEOUT_MS
+    );
+  }
+  async signTypedData(derivationPath, data) {
+    const action = this._sdk.signTypedData(derivationPath, data);
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      INTERACTIVE_TIMEOUT_MS
+    );
+  }
+};
+
+// 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) {
+    const hadCached = this._cache.has(sessionId);
+    this._cache.delete(sessionId);
+    console.log("[DMK] SignerManager.getOrCreate:", { sessionId, hadCached, creating: true });
+    const builder = await this._builderFn({ dmk: this._dmk, sessionId });
+    const sdkSigner = builder.build();
+    console.log("[DMK] SignerManager: new signer built");
+    const 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/connector/chains/evm.ts
+var import_hwk_adapter_core3 = require("@onekeyfe/hwk-adapter-core");
+
+// src/connector/chains/utils.ts
+function normalizePath(path) {
+  return path.startsWith("m/") ? path.slice(2) : path;
+}
+
+// src/connector/chains/evm.ts
+async function evmGetAddress(ctx, sessionId, params) {
+  const signer = await _getEthSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  const checkOnDevice = params.showOnDevice ?? false;
+  console.log("[DMK] evmGetAddress -> signer.getAddress:", { path, checkOnDevice });
+  try {
+    const result = await signer.getAddress(path, { checkOnDevice });
+    return { address: result.address, publicKey: result.publicKey };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function evmSignTransaction(ctx, sessionId, params) {
+  if (!params.serializedTx) {
+    throw Object.assign(
+      new Error(
+        "Ledger requires a pre-serialized transaction (serializedTx). Provide an RLP-encoded hex string."
+      ),
+      { code: import_hwk_adapter_core3.HardwareErrorCode.InvalidParams }
+    );
+  }
+  const signer = await _getEthSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const result = await signer.signTransaction(path, params.serializedTx);
+    return {
+      v: `0x${result.v.toString(16)}`,
+      r: (0, import_hwk_adapter_core3.padHex64)(result.r),
+      s: (0, import_hwk_adapter_core3.padHex64)(result.s)
+    };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function evmSignMessage(ctx, sessionId, params) {
+  const signer = await _getEthSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const result = await signer.signMessage(path, params.message);
+    const rHex = (0, import_hwk_adapter_core3.stripHex)(result.r).padStart(64, "0");
+    const sHex = (0, import_hwk_adapter_core3.stripHex)(result.s).padStart(64, "0");
+    const vHex = result.v.toString(16).padStart(2, "0");
+    return { signature: `0x${rHex}${sHex}${vHex}` };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function evmSignTypedData(ctx, sessionId, params) {
+  if (params.mode === "hash") {
+    throw Object.assign(
+      new Error(
+        'Ledger does not support hash-only EIP-712 signing. Use mode "full" with the complete typed data structure.'
+      ),
+      { code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported }
+    );
+  }
+  const signer = await _getEthSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const result = await signer.signTypedData(path, params.data);
+    const rHex = (0, import_hwk_adapter_core3.stripHex)(result.r).padStart(64, "0");
+    const sHex = (0, import_hwk_adapter_core3.stripHex)(result.s).padStart(64, "0");
+    const vHex = result.v.toString(16).padStart(2, "0");
+    return { signature: `0x${rHex}${sHex}${vHex}` };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function _getEthSigner(ctx, sessionId) {
+  const signerManager = await ctx.getSignerManager();
+  const signer = await signerManager.getOrCreate(sessionId);
+  signer.onInteraction = (interaction) => {
+    ctx.emit("ui-event", {
+      type: interaction,
+      payload: { sessionId }
+    });
+  };
+  return signer;
+}
+
+// src/connector/chains/btc.ts
+var import_hwk_adapter_core4 = require("@onekeyfe/hwk-adapter-core");
+
+// src/signer/SignerBtc.ts
+function hexToUtf8(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 new TextDecoder().decode(bytes);
+}
+var INTERACTIVE_TIMEOUT_MS2 = 5 * 6e4;
+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) {
+    console.log(
+      "[SignerBtc] getExtendedPublicKey called, path:",
+      derivationPath,
+      "options:",
+      JSON.stringify(options)
+    );
+    const action = this._sdk.getExtendedPublicKey(derivationPath, {
+      checkOnDevice: options?.checkOnDevice ?? false
+    });
+    try {
+      const result = await deviceActionToPromise(
+        action,
+        this.onInteraction
+      );
+      console.log(
+        "[SignerBtc] getExtendedPublicKey result type:",
+        typeof result,
+        "value:",
+        typeof result === "string" ? result.substring(0, 20) + "..." : JSON.stringify(result).substring(0, 50)
+      );
+      if (typeof result === "string") return result;
+      return result.extendedPublicKey;
+    } catch (err) {
+      console.error("[SignerBtc] getExtendedPublicKey error:", err);
+      throw err;
+    }
+  }
+  async getMasterFingerprint(options) {
+    const action = this._sdk.getMasterFingerprint(options);
+    const result = await deviceActionToPromise(
+      action,
+      this.onInteraction
+    );
+    return result.masterFingerprint;
+  }
+  /**
+   * Sign a PSBT and return the array of partial signatures.
+   * The `wallet` param is a DefaultWallet or WalletPolicy instance.
+   * The `psbt` param can be a hex string, base64 string, or Uint8Array.
+   */
+  async signPsbt(wallet, psbt, options) {
+    const action = this._sdk.signPsbt(wallet, psbt, options);
+    return deviceActionToPromise(action, this.onInteraction, INTERACTIVE_TIMEOUT_MS2);
+  }
+  /**
+   * Sign a PSBT and return the fully extracted raw transaction as a hex string.
+   * Like signPsbt, but also finalises the PSBT and extracts the transaction.
+   */
+  async signTransaction(wallet, psbt, options) {
+    const action = this._sdk.signTransaction(wallet, psbt, options);
+    return deviceActionToPromise(action, this.onInteraction, INTERACTIVE_TIMEOUT_MS2);
+  }
+  /**
+   * Sign a message with the BTC app (BIP-137 / "Bitcoin Signed Message").
+   * Returns `{ r, s, v }` signature object.
+   */
+  async signMessage(derivationPath, message, options) {
+    const action = this._sdk.signMessage(derivationPath, hexToUtf8(message), options);
+    return deviceActionToPromise(
+      action,
+      this.onInteraction,
+      INTERACTIVE_TIMEOUT_MS2
+    );
+  }
+};
+
+// src/connector/chains/btc.ts
+function readCompactSize(data, pos) {
+  const first = data[pos];
+  if (first < 253) return [first, 1];
+  if (first === 253) return [data[pos + 1] | data[pos + 2] << 8, 3];
+  return [0, 1];
+}
+function writeCompactSize(out, val) {
+  if (val < 253) {
+    out.push(val);
+  } else {
+    out.push(253, val & 255, val >>> 8 & 255);
+  }
+}
+function readKeyValue(data, pos) {
+  const start = pos;
+  const [keyLen, keyLenSize] = readCompactSize(data, pos);
+  pos += keyLenSize;
+  const keyType = data[pos];
+  pos += keyLen;
+  const [valLen, valLenSize] = readCompactSize(data, pos);
+  pos += valLenSize;
+  const value = data.slice(pos, pos + valLen);
+  pos += valLen;
+  return { bytes: data.slice(start, pos), end: pos, keyType, value };
+}
+function writeKv(out, key, value) {
+  writeCompactSize(out, key.length);
+  key.forEach((b) => out.push(b));
+  writeCompactSize(out, value.length);
+  value.forEach((b) => out.push(b));
+}
+async function btcGetAddress(ctx, sessionId, params) {
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const { DefaultWallet, DefaultDescriptorTemplate } = await ctx.importLedgerKit(
+      "@ledgerhq/device-signer-kit-bitcoin"
+    );
+    const purpose = path.split("/")[0]?.replace("'", "");
+    let template = DefaultDescriptorTemplate.NATIVE_SEGWIT;
+    if (purpose === "44") template = DefaultDescriptorTemplate.LEGACY;
+    else if (purpose === "49") template = DefaultDescriptorTemplate.NESTED_SEGWIT;
+    else if (purpose === "86") template = DefaultDescriptorTemplate.TAPROOT;
+    const wallet = new DefaultWallet(path, template);
+    console.log("[LedgerConnector] btcGetAddress params:", {
+      path,
+      purpose,
+      template,
+      addressIndex: params.addressIndex,
+      change: params.change,
+      showOnDevice: params.showOnDevice,
+      rawParams: JSON.stringify(params)
+    });
+    const result = await btcSigner.getWalletAddress(wallet, params.addressIndex ?? 0, {
+      checkOnDevice: params.showOnDevice ?? false,
+      change: params.change ?? false
+    });
+    return { address: result.address, path: params.path };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function btcGetPublicKey(ctx, sessionId, params) {
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  console.log("[LedgerConnector] btcGetPublicKey called, path:", path, "sessionId:", sessionId);
+  try {
+    const xpub = await btcSigner.getExtendedPublicKey(path, {
+      checkOnDevice: params.showOnDevice ?? false
+    });
+    console.log("[LedgerConnector] btcGetPublicKey success, xpub:", xpub?.substring(0, 20) + "...");
+    return { xpub, path: params.path };
+  } catch (err) {
+    console.error("[LedgerConnector] btcGetPublicKey error, path:", path, "err:", err);
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function btcSignTransaction(ctx, sessionId, params) {
+  if (!params.psbt) {
+    throw Object.assign(
+      new Error("Ledger requires PSBT format for BTC transaction signing. Provide params.psbt."),
+      { code: import_hwk_adapter_core4.HardwareErrorCode.InvalidParams }
+    );
+  }
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  try {
+    const { DefaultWallet, DefaultDescriptorTemplate } = await ctx.importLedgerKit(
+      "@ledgerhq/device-signer-kit-bitcoin"
+    );
+    const path = normalizePath(params.path || "84'/0'/0'");
+    const purpose = path.split("/")[0]?.replace("'", "");
+    let template = DefaultDescriptorTemplate.NATIVE_SEGWIT;
+    if (purpose === "44") template = DefaultDescriptorTemplate.LEGACY;
+    else if (purpose === "49") template = DefaultDescriptorTemplate.NESTED_SEGWIT;
+    else if (purpose === "86") template = DefaultDescriptorTemplate.TAPROOT;
+    const wallet = new DefaultWallet(path, template);
+    let psbtToSign = params.psbt;
+    if (purpose === "86" && params.inputDerivations?.length) {
+      psbtToSign = await _enrichTaprootPsbt(btcSigner, psbtToSign, params.inputDerivations);
+    }
+    const signedTxHex = await btcSigner.signTransaction(wallet, psbtToSign);
+    return { signedPsbt: (0, import_hwk_adapter_core4.stripHex)(signedTxHex) };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function btcSignMessage(ctx, sessionId, params) {
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const result = await btcSigner.signMessage(path, params.message);
+    const vHex = result.v.toString(16).padStart(2, "0");
+    const rHex = (0, import_hwk_adapter_core4.stripHex)(result.r).padStart(64, "0");
+    const sHex = (0, import_hwk_adapter_core4.stripHex)(result.s).padStart(64, "0");
+    return { signature: `${vHex}${rHex}${sHex}`, address: "" };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function btcGetMasterFingerprint(ctx, sessionId, params) {
+  const btcSigner = await _createBtcSigner(ctx, sessionId);
+  try {
+    const fingerprint = await btcSigner.getMasterFingerprint({
+      skipOpenApp: params?.skipOpenApp
+    });
+    const hex = Array.from(fingerprint).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return { masterFingerprint: hex };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function _createBtcSigner(ctx, sessionId) {
+  const dmk = await ctx.getOrCreateDmk();
+  const { SignerBtcBuilder } = await ctx.importLedgerKit("@ledgerhq/device-signer-kit-bitcoin");
+  const sdkSigner = new SignerBtcBuilder({ dmk, sessionId }).build();
+  const signer = new SignerBtc(sdkSigner);
+  signer.onInteraction = (interaction) => {
+    ctx.emit("ui-event", {
+      type: interaction,
+      payload: { sessionId }
+    });
+  };
+  return signer;
+}
+async function _enrichTaprootPsbt(btcSigner, psbtHex, inputDerivations) {
+  const masterFp = await btcSigner.getMasterFingerprint({ skipOpenApp: true });
+  const fpBytes = masterFp.length === 4 ? masterFp : new Uint8Array([0, 0, 0, 0]);
+  const raw = (0, import_hwk_adapter_core4.hexToBytes)(psbtHex);
+  const result = [];
+  let pos = 0;
+  for (let i = 0; i < 5; i++) result.push(raw[pos++]);
+  while (pos < raw.length && raw[pos] !== 0) {
+    const { bytes: kv, end } = readKeyValue(raw, pos);
+    kv.forEach((b) => result.push(b));
+    pos = end;
+  }
+  result.push(raw[pos++]);
+  for (let inputIdx = 0; pos < raw.length; inputIdx++) {
+    const inputKvs = [];
+    let witnessUtxoScript = null;
+    while (pos < raw.length && raw[pos] !== 0) {
+      const { bytes: kv, end, keyType, value } = readKeyValue(raw, pos);
+      inputKvs.push(kv);
+      if (keyType === 1 && value) {
+        const scriptStart = 8;
+        const scriptLen = value[scriptStart];
+        witnessUtxoScript = value.slice(scriptStart + 1, scriptStart + 1 + scriptLen);
+      }
+      pos = end;
+    }
+    inputKvs.forEach((kv) => kv.forEach((b) => result.push(b)));
+    if (witnessUtxoScript && witnessUtxoScript.length === 34 && witnessUtxoScript[0] === 81 && // OP_1
+    witnessUtxoScript[1] === 32 && // PUSH 32
+    inputDerivations[inputIdx]) {
+      const xOnlyKey = witnessUtxoScript.slice(2, 34);
+      const fullPath = inputDerivations[inputIdx].path;
+      writeKv(result, new Uint8Array([23]), xOnlyKey);
+      const pathComponents = fullPath.replace(/^m\//, "").split("/");
+      const pathBuf = new Uint8Array(1 + 4 + pathComponents.length * 4);
+      pathBuf[0] = 0;
+      pathBuf.set(fpBytes, 1);
+      for (let i = 0; i < pathComponents.length; i++) {
+        const comp = pathComponents[i];
+        const hardened = comp.endsWith("'");
+        let val = parseInt(hardened ? comp.slice(0, -1) : comp, 10);
+        if (hardened) val += 2147483648;
+        const off = 5 + i * 4;
+        pathBuf[off] = val & 255;
+        pathBuf[off + 1] = val >>> 8 & 255;
+        pathBuf[off + 2] = val >>> 16 & 255;
+        pathBuf[off + 3] = val >>> 24 & 255;
+      }
+      const tapBipKey = new Uint8Array(1 + 32);
+      tapBipKey[0] = 22;
+      tapBipKey.set(xOnlyKey, 1);
+      writeKv(result, tapBipKey, pathBuf);
+    }
+    result.push(raw[pos++]);
+  }
+  while (pos < raw.length) {
+    result.push(raw[pos++]);
+  }
+  return (0, import_hwk_adapter_core4.bytesToHex)(new Uint8Array(result));
+}
+
+// src/connector/chains/sol.ts
+var import_hwk_adapter_core5 = require("@onekeyfe/hwk-adapter-core");
+
+// src/signer/SignerSol.ts
+var SignerSol = class {
+  constructor(_sdk) {
+    this._sdk = _sdk;
+  }
+  /**
+   * Get the Solana address (base58-encoded Ed25519 public key) at the given derivation path.
+   */
+  async getAddress(derivationPath, options) {
+    const action = this._sdk.getAddress(derivationPath, {
+      checkOnDevice: options?.checkOnDevice ?? false
+    });
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+  /**
+   * Sign a Solana transaction.
+   */
+  async signTransaction(derivationPath, transaction, options) {
+    const action = this._sdk.signTransaction(derivationPath, transaction, options);
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+  /**
+   * Sign a message with the Solana app.
+   * DMK returns { signature: string } for signMessage (unlike signTransaction which returns Uint8Array).
+   */
+  async signMessage(derivationPath, message, options) {
+    const action = this._sdk.signMessage(derivationPath, message, options);
+    return deviceActionToPromise(action, this.onInteraction);
+  }
+};
+
+// src/connector/chains/sol.ts
+async function solGetAddress(ctx, sessionId, params) {
+  const solSigner = await _createSolSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  try {
+    const publicKey = await solSigner.getAddress(path, {
+      checkOnDevice: params.showOnDevice ?? false
+    });
+    return { address: publicKey, path: params.path };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function solSignTransaction(ctx, sessionId, params) {
+  const solSigner = await _createSolSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  const txBytes = (0, import_hwk_adapter_core5.hexToBytes)(params.serializedTx);
+  try {
+    const result = await solSigner.signTransaction(path, txBytes);
+    return { signature: (0, import_hwk_adapter_core5.bytesToHex)(result) };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function solSignMessage(ctx, sessionId, params) {
+  const solSigner = await _createSolSigner(ctx, sessionId);
+  const path = normalizePath(params.path);
+  const messageBytes = (0, import_hwk_adapter_core5.hexToBytes)(params.message);
+  try {
+    const result = await solSigner.signMessage(path, messageBytes);
+    return { signature: result.signature };
+  } catch (err) {
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+async function _createSolSigner(ctx, sessionId) {
+  const dmk = await ctx.getOrCreateDmk();
+  const { SignerSolanaBuilder } = await ctx.importLedgerKit("@ledgerhq/device-signer-kit-solana");
+  const sdkSigner = new SignerSolanaBuilder({ dmk, sessionId }).build();
+  const signer = new SignerSol(sdkSigner);
+  signer.onInteraction = (interaction) => {
+    ctx.emit("ui-event", {
+      type: interaction,
+      payload: { sessionId }
+    });
+  };
+  return signer;
+}
+
+// src/connector/chains/tron.ts
+var import_hwk_adapter_core7 = require("@onekeyfe/hwk-adapter-core");
+var import_hw_app_trx = __toESM(require("@ledgerhq/hw-app-trx"));
+
+// src/connector/chains/legacyAppRetry.ts
+var import_hwk_adapter_core6 = require("@onekeyfe/hwk-adapter-core");
+
+// src/app/AppManager.ts
+var import_device_management_kit2 = require("@ledgerhq/device-management-kit");
+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.
+   */
+  /**
+   * @param onConfirmOnDevice Called after OpenAppCommand succeeds —
+   *   the device is now showing a confirmation prompt to the user.
+   *   NOT called if the app is already open or if the app is not installed.
+   */
+  async ensureAppOpen(sessionId, targetAppName, onConfirmOnDevice) {
+    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);
+    onConfirmOnDevice?.();
+    await this._waitForApp(sessionId, targetAppName);
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  async _getCurrentApp(sessionId) {
+    const result = await this._dmk.sendCommand({
+      sessionId,
+      command: new import_device_management_kit2.GetAppAndVersionCommand()
+    });
+    if ((0, import_device_management_kit2.isSuccessCommandResult)(result)) {
+      return result.data.name;
+    }
+    throw new Error("Failed to get current app from device");
+  }
+  async _openApp(sessionId, appName) {
+    const result = await this._dmk.sendCommand({
+      sessionId,
+      command: new import_device_management_kit2.OpenAppCommand({ appName })
+    });
+    if (!(0, import_device_management_kit2.isSuccessCommandResult)(result)) {
+      const statusCode = result.statusCode;
+      throw Object.assign(
+        new Error(`Failed to open "${appName}": app may not be installed`),
+        { _tag: "OpenAppCommandError", errorCode: String(statusCode ?? ""), statusCode }
+      );
+    }
+  }
+  async _closeCurrentApp(sessionId) {
+    await this._dmk.sendCommand({
+      sessionId,
+      command: new import_device_management_kit2.CloseAppCommand()
+    });
+  }
+  /**
+   * 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));
+  }
+};
+
+// src/connector/chains/legacyAppRetry.ts
+var KNOWN_APP_CODES = {
+  Tron: /* @__PURE__ */ new Set([
+    27013,
+    // user denied
+    21781,
+    // device locked
+    27274,
+    // invalid BIP32 path
+    27275,
+    27276,
+    27277,
+    // app-specific data errors
+    27264,
+    // invalid data
+    27392,
+    // wrong parameter
+    26368
+    // wrong length
+  ])
+};
+function isLegacyWrongAppError(err, appName) {
+  if (isWrongAppError(err)) return true;
+  const msg = err instanceof Error ? err.message : "";
+  const match = msg.match(/0x([0-9a-fA-F]{4})/);
+  if (!match) return false;
+  const sw = parseInt(match[1], 16);
+  const knownCodes = KNOWN_APP_CODES[appName];
+  if (knownCodes?.has(sw)) return false;
+  return true;
+}
+async function withLegacyAppRetry(ctx, sessionId, appName, action) {
+  try {
+    return await action(sessionId);
+  } catch (err) {
+    ctx.emit("ui-event", {
+      type: import_hwk_adapter_core6.EConnectorInteraction.InteractionComplete,
+      payload: { sessionId }
+    });
+    if (isLegacyWrongAppError(err, appName)) {
+      const dmk = await ctx.getOrCreateDmk();
+      const appManager = new AppManager(dmk);
+      try {
+        await appManager.ensureAppOpen(sessionId, appName, () => {
+          ctx.emit("ui-event", {
+            type: import_hwk_adapter_core6.EConnectorInteraction.ConfirmOpenApp,
+            payload: { sessionId }
+          });
+        });
+      } catch (switchErr) {
+        ctx.emit("ui-event", {
+          type: import_hwk_adapter_core6.EConnectorInteraction.InteractionComplete,
+          payload: { sessionId }
+        });
+        throw ctx.wrapError(switchErr);
+      }
+      ctx.clearAllSigners();
+      ctx.emit("ui-event", {
+        type: import_hwk_adapter_core6.EConnectorInteraction.InteractionComplete,
+        payload: { sessionId }
+      });
+      return await action(sessionId);
+    }
+    ctx.invalidateSession(sessionId);
+    throw ctx.wrapError(err);
+  }
+}
+
+// src/transport/DmkTransport.ts
+var import_hw_transport = __toESM(require("@ledgerhq/hw-transport"));
+var DmkTransport = class extends import_hw_transport.default {
+  constructor(dmk, sessionId) {
+    super();
+    this._dmk = dmk;
+    this._sessionId = sessionId;
+  }
+  async exchange(apdu) {
+    const response = await this._dmk.sendApdu({
+      sessionId: this._sessionId,
+      apdu: new Uint8Array(apdu)
+    });
+    const result = Buffer.alloc(response.data.length + 2);
+    if (response.data.length > 0) {
+      result.set(response.data, 0);
+    }
+    result.set(response.statusCode, response.data.length);
+    return result;
+  }
+  async close() {
+  }
+};
+
+// src/connector/chains/tron.ts
+async function tronGetAddress(ctx, sessionId, params) {
+  const path = normalizePath(params.path);
+  return withLegacyAppRetry(ctx, sessionId, "Tron", async (sid) => {
+    const trx = await _createTrx(ctx, sid);
+    if (params.showOnDevice) {
+      ctx.emit("ui-event", {
+        type: import_hwk_adapter_core7.EConnectorInteraction.ConfirmOnDevice,
+        payload: { sessionId: sid }
+      });
+    }
+    const result = await trx.getAddress(path, params.showOnDevice ?? false);
+    ctx.emit("ui-event", {
+      type: import_hwk_adapter_core7.EConnectorInteraction.InteractionComplete,
+      payload: { sessionId: sid }
+    });
+    return { address: result.address, publicKey: result.publicKey, path: params.path };
+  });
+}
+async function tronSignTransaction(ctx, sessionId, params) {
+  if (!params.rawTxHex) {
+    throw Object.assign(
+      new Error("TRON signing requires a protobuf-encoded raw transaction hex (rawTxHex)."),
+      { code: import_hwk_adapter_core7.HardwareErrorCode.InvalidParams }
+    );
+  }
+  const path = normalizePath(params.path);
+  return withLegacyAppRetry(ctx, sessionId, "Tron", async (sid) => {
+    const trx = await _createTrx(ctx, sid);
+    ctx.emit("ui-event", {
+      type: import_hwk_adapter_core7.EConnectorInteraction.ConfirmOnDevice,
+      payload: { sessionId: sid }
+    });
+    const signature = await trx.signTransaction(path, params.rawTxHex, []);
+    ctx.emit("ui-event", {
+      type: import_hwk_adapter_core7.EConnectorInteraction.InteractionComplete,
+      payload: { sessionId: sid }
+    });
+    return { signature };
+  });
+}
+async function tronSignMessage(ctx, sessionId, params) {
+  const path = normalizePath(params.path);
+  return withLegacyAppRetry(ctx, sessionId, "Tron", async (sid) => {
+    const trx = await _createTrx(ctx, sid);
+    ctx.emit("ui-event", {
+      type: import_hwk_adapter_core7.EConnectorInteraction.ConfirmOnDevice,
+      payload: { sessionId: sid }
+    });
+    const signature = await trx.signPersonalMessage(path, params.messageHex);
+    ctx.emit("ui-event", {
+      type: import_hwk_adapter_core7.EConnectorInteraction.InteractionComplete,
+      payload: { sessionId: sid }
+    });
+    return { signature };
+  });
+}
+async function _createTrx(ctx, sessionId) {
+  const dmk = await ctx.getOrCreateDmk();
+  return new import_hw_app_trx.default(new DmkTransport(dmk, sessionId));
+}
+
+// src/connector/LedgerConnectorBase.ts
+async function defaultLedgerKitImporter(pkg) {
+  switch (pkg) {
+    case "@ledgerhq/device-management-kit":
+      return import("@ledgerhq/device-management-kit");
+    case "@ledgerhq/device-signer-kit-ethereum":
+      return import("@ledgerhq/device-signer-kit-ethereum");
+    case "@ledgerhq/device-signer-kit-bitcoin":
+      return import("@ledgerhq/device-signer-kit-bitcoin");
+    case "@ledgerhq/device-signer-kit-solana":
+      return import("@ledgerhq/device-signer-kit-solana");
+    default:
+      throw new Error(`Unknown Ledger kit package: ${pkg}`);
+  }
+}
+var LedgerConnectorBase = class {
+  constructor(createTransport, options) {
+    this._deviceManager = null;
+    this._signerManager = null;
+    this._dmk = null;
+    this._eventHandlers = /* @__PURE__ */ new Map();
+    // ---------------------------------------------------------------------------
+    // ConnectId <-> DMK path mapping
+    //
+    // DMK uses internal paths (BLE MAC, USB UUID) that may change across sessions.
+    // _resolveConnectId() maps these to stable external IDs (BLE: "A58F", USB: same).
+    // This bidirectional map is the SINGLE SOURCE OF TRUTH for all connectId usage.
+    // ---------------------------------------------------------------------------
+    this._connectIdToPath = /* @__PURE__ */ new Map();
+    // "A58F" -> "D5:75:7D:4B:51:E8"
+    this._pathToConnectId = /* @__PURE__ */ new Map();
+    this._createTransport = createTransport;
+    this._connectionType = options?.connectionType ?? "usb";
+    this._providedDmk = options?.dmk;
+    this._importLedgerKit = options?.importLedgerKit ?? defaultLedgerKitImporter;
+    if (this._providedDmk) {
+      this._initManagers(this._providedDmk);
+    }
+    this._ctx = {
+      emit: (event, data) => this._emit(event, data),
+      invalidateSession: (sid) => this._invalidateSession(sid),
+      wrapError: (err) => this._wrapError(err),
+      getOrCreateDmk: () => this._getOrCreateDmk(),
+      getDeviceManager: () => this._getDeviceManager(),
+      getSignerManager: () => this._getSignerManager(),
+      clearAllSigners: () => this._signerManager?.clearAll(),
+      replaceSession: (oldSid, newSid) => this._replaceSession(oldSid, newSid),
+      importLedgerKit: this._importLedgerKit
+    };
+  }
+  // "D5:75:7D:4B:51:E8" -> "A58F"
+  /** Register a connectId <-> path mapping from a device descriptor. */
+  _registerDeviceId(descriptor) {
+    const connectId = this._resolveConnectId(descriptor);
+    this._connectIdToPath.set(connectId, descriptor.path);
+    this._pathToConnectId.set(descriptor.path, connectId);
+    return connectId;
+  }
+  /** Get DMK path from external connectId. Falls back to connectId itself. */
+  _getPathForConnectId(connectId) {
+    return this._connectIdToPath.get(connectId) ?? connectId;
+  }
+  /** Get external connectId from DMK path. Falls back to path itself. */
+  _getConnectIdForPath(path) {
+    return this._pathToConnectId.get(path) ?? path;
+  }
+  // ---------------------------------------------------------------------------
+  // Protected — hooks for subclasses
+  // ---------------------------------------------------------------------------
+  /**
+   * Resolve the connectId for a discovered device descriptor.
+   * Default: use the DMK path (ephemeral UUID).
+   * Override in subclasses to extract stable identifiers (e.g. BLE hex ID).
+   */
+  _resolveConnectId(descriptor) {
+    return descriptor.path;
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Device discovery
+  // ---------------------------------------------------------------------------
+  async searchDevices() {
+    const dm = await this._getDeviceManager();
+    let descriptors = await dm.enumerate();
+    if (descriptors.length === 0) {
+      try {
+        await dm.requestDevice();
+      } catch {
+      }
+      descriptors = await dm.enumerate();
+    }
+    const result = descriptors.map((d) => {
+      const connectId = this._registerDeviceId(d);
+      return {
+        connectId,
+        deviceId: d.path,
+        name: d.name || d.type || "Ledger",
+        model: d.type
+      };
+    });
+    return result;
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Connection
+  // ---------------------------------------------------------------------------
+  async connect(deviceId) {
+    const dm = await this._getDeviceManager();
+    await this.searchDevices();
+    const dmkPath = deviceId ? this._getPathForConnectId(deviceId) : void 0;
+    let targetPath = dmkPath;
+    if (!targetPath) {
+      const descriptors = await dm.enumerate();
+      if (descriptors.length === 0) {
+        throw new Error(
+          `No Ledger device found. Make sure the device is connected${this._connectionType === "ble" ? " nearby with Bluetooth enabled" : " via USB"} and unlocked.`
+        );
+      }
+      targetPath = descriptors[0].path;
+    }
+    const externalConnectId = this._getConnectIdForPath(targetPath);
+    const doConnect = async (path) => {
+      const sessionId = await dm.connect(path);
+      const session = {
+        sessionId,
+        deviceInfo: {
+          vendor: "ledger",
+          model: "unknown",
+          firmwareVersion: "unknown",
+          deviceId: path,
+          connectId: externalConnectId,
+          connectionType: this._connectionType,
+          capabilities: { persistentDeviceIdentity: false }
+        }
+      };
+      this._emit("device-connect", {
+        device: {
+          connectId: externalConnectId,
+          deviceId: path,
+          name: "Ledger"
+        }
+      });
+      return session;
+    };
+    try {
+      return await doConnect(targetPath);
+    } catch {
+      this._resetSignersAndSessions();
+      const dm2 = await this._getDeviceManager();
+      await this.searchDevices();
+      const retryPath = this._getPathForConnectId(externalConnectId);
+      if (!retryPath || retryPath === externalConnectId) {
+        const descriptors = await dm2.enumerate();
+        if (descriptors.length === 0) {
+          throw new Error(
+            `No Ledger device found after retry. Make sure the device is connected${this._connectionType === "ble" ? " nearby with Bluetooth enabled" : " via USB"} and unlocked.`
+          );
+        }
+        return doConnect(descriptors[0].path);
+      }
+      return doConnect(retryPath);
+    }
+  }
+  async disconnect(sessionId) {
+    if (!this._deviceManager) return;
+    const deviceId = this._deviceManager.getDeviceId(sessionId);
+    this._signerManager?.invalidate(sessionId);
+    await this._deviceManager.disconnect(sessionId);
+    if (deviceId) {
+      this._emit("device-disconnect", { connectId: deviceId });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Method dispatch
+  // ---------------------------------------------------------------------------
+  async call(sessionId, method, params) {
+    console.log("[DMK] call:", method, JSON.stringify(params));
+    switch (method) {
+      // EVM
+      case "evmGetAddress":
+        return evmGetAddress(this._ctx, sessionId, params);
+      case "evmSignTransaction":
+        return evmSignTransaction(this._ctx, sessionId, params);
+      case "evmSignMessage":
+        return evmSignMessage(this._ctx, sessionId, params);
+      case "evmSignTypedData":
+        return evmSignTypedData(this._ctx, sessionId, params);
+      // BTC
+      case "btcGetAddress":
+        return btcGetAddress(this._ctx, sessionId, params);
+      case "btcGetPublicKey":
+        return btcGetPublicKey(this._ctx, sessionId, params);
+      case "btcSignTransaction":
+        return btcSignTransaction(this._ctx, sessionId, params);
+      case "btcSignMessage":
+        return btcSignMessage(this._ctx, sessionId, params);
+      case "btcGetMasterFingerprint":
+        return btcGetMasterFingerprint(
+          this._ctx,
+          sessionId,
+          params
+        );
+      // SOL
+      case "solGetAddress":
+        return solGetAddress(this._ctx, sessionId, params);
+      case "solSignTransaction":
+        return solSignTransaction(this._ctx, sessionId, params);
+      case "solSignMessage":
+        return solSignMessage(this._ctx, sessionId, params);
+      // TRON
+      case "tronGetAddress":
+        return tronGetAddress(this._ctx, sessionId, params);
+      case "tronSignTransaction":
+        return tronSignTransaction(this._ctx, sessionId, params);
+      case "tronSignMessage":
+        return tronSignMessage(this._ctx, sessionId, params);
+      default:
+        throw new Error(`LedgerConnector: unknown method "${method}"`);
+    }
+  }
+  async cancel(_sessionId) {
+  }
+  uiResponse(_response) {
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Events
+  // ---------------------------------------------------------------------------
+  on(event, handler) {
+    if (!this._eventHandlers.has(event)) {
+      this._eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this._eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    this._eventHandlers.get(event)?.delete(handler);
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Reset
+  // ---------------------------------------------------------------------------
+  reset() {
+    this._resetAll();
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- DMK / Manager lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * Lazily create or return the DMK instance.
+   * If a DMK was provided via constructor, it is used directly.
+   * Otherwise, one is created via the transport factory.
+   */
+  async _getOrCreateDmk() {
+    console.log(
+      "[DMK] _getOrCreateDmk called, _dmk exists:",
+      !!this._dmk,
+      "_providedDmk exists:",
+      !!this._providedDmk,
+      "stack:",
+      new Error().stack?.split("\n").slice(1, 4).join(" | ")
+    );
+    if (this._dmk) return this._dmk;
+    if (this._providedDmk) {
+      this._dmk = this._providedDmk;
+      return this._dmk;
+    }
+    const { DeviceManagementKitBuilder } = await this._importLedgerKit(
+      "@ledgerhq/device-management-kit"
+    );
+    const transportFactory = await this._createTransport();
+    console.log(
+      "[DMK] _getOrCreateDmk: transportFactory type:",
+      typeof transportFactory,
+      "value:",
+      String(transportFactory).substring(0, 80)
+    );
+    const dmk = new DeviceManagementKitBuilder().addTransport(transportFactory).build();
+    this._dmk = dmk;
+    console.log(
+      "[DMK] _getOrCreateDmk: DMK created, methods:",
+      Object.getOwnPropertyNames(Object.getPrototypeOf(dmk)).join(", ")
+    );
+    return dmk;
+  }
+  _initManagers(dmk) {
+    this._dmk = dmk;
+    this._deviceManager = new LedgerDeviceManager(dmk);
+    const importKit = this._importLedgerKit;
+    this._signerManager = new SignerManager(dmk, async (args) => {
+      const mod = await importKit("@ledgerhq/device-signer-kit-ethereum");
+      return new mod.SignerEthBuilder(args);
+    });
+  }
+  async _getDeviceManager() {
+    if (this._deviceManager) return this._deviceManager;
+    const dmk = await this._getOrCreateDmk();
+    this._initManagers(dmk);
+    return this._deviceManager;
+  }
+  async _getSignerManager() {
+    if (!this._signerManager) {
+      const dmk = await this._getOrCreateDmk();
+      this._initManagers(dmk);
+    }
+    return this._signerManager;
+  }
+  _invalidateSession(sessionId) {
+    this._signerManager?.invalidate(sessionId);
+  }
+  /**
+   * Replace an old session with a new one after app switch.
+   * Updates the connectId→path mapping so subsequent calls() use the new session,
+   * and emits device-connect so the adapter updates its _sessions Map.
+   */
+  _replaceSession(oldSessionId, _newSessionId) {
+    const dm = this._deviceManager;
+    if (!dm) return;
+    const oldDeviceId = dm.getDeviceId(oldSessionId);
+    const connectId = oldDeviceId ? this._pathToConnectId.get(oldDeviceId) : void 0;
+    this._signerManager?.invalidate(oldSessionId);
+    if (connectId) {
+      this._emit("device-connect", {
+        device: {
+          connectId,
+          deviceId: connectId,
+          name: "Ledger"
+        }
+      });
+    }
+  }
+  /**
+   * Light reset: clear signer/session state but keep DMK, BLE scan, and ID mapping alive.
+   * Used by connect() retry — we want to re-discover with the same transport.
+   */
+  _resetSignersAndSessions() {
+    console.log(
+      "[DMK] _resetSignersAndSessions called, stack:",
+      new Error().stack?.split("\n").slice(1, 3).join(" | ")
+    );
+    this._signerManager?.clearAll();
+    this._signerManager = null;
+    this._deviceManager = null;
+  }
+  _resetAll() {
+    console.log(
+      "[DMK] _resetAll called, stack:",
+      new Error().stack?.split("\n").slice(1, 3).join(" | ")
+    );
+    this._signerManager?.clearAll();
+    this._deviceManager?.dispose();
+    this._deviceManager = null;
+    this._signerManager = null;
+    this._dmk = null;
+    this._connectIdToPath.clear();
+    this._pathToConnectId.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- Events
+  // ---------------------------------------------------------------------------
+  _emit(event, data) {
+    const handlers = this._eventHandlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch {
+        }
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private -- Error handling
+  // ---------------------------------------------------------------------------
+  _wrapError(err) {
+    const mapped = mapLedgerError(err);
+    const error = new Error(mapped.message);
+    Object.assign(error, { code: mapped.code });
+    return error;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppManager,
+  DmkTransport,
+  LedgerAdapter,
+  LedgerConnectorBase,
+  LedgerDeviceManager,
+  SignerBtc,
+  SignerEth,
+  SignerManager,
+  SignerSol,
+  deviceActionToPromise,
+  isDeviceLockedError,
+  mapLedgerError
+});
+//# sourceMappingURL=index.js.map