@onekeyfe/hwk-ledger-adapter 1.1.26-alpha.8 → 1.1.26-patch.1

package/dist/index.mjs

@@ -3,9 +3,11 @@ import {
   CHAIN_FINGERPRINT_PATHS,
   DEVICE,
   DeviceJobQueue,
+  EConnectorInteraction,
   HardwareErrorCode as HardwareErrorCode2,
   TypedEventEmitter,
   UI_REQUEST,
+  UI_REQUEST_PREEMPTED_TAG,
   UiRequestRegistry,
   deriveDeviceFingerprint,
   failure,
@@ -14,24 +16,32 @@ import {
 
 // src/errors.ts
 import { HardwareErrorCode, enrichErrorMessage } from "@onekeyfe/hwk-adapter-core";
-function ledgerFailure(code, error, appName) {
+var MULTIPLE_USB_LEDGER_DEVICES_ERROR_MESSAGE = "Multiple Ledger USB devices are connected. Please connect only one Ledger device and try again.";
+function createMultipleUsbLedgerDevicesError() {
+  return Object.assign(new Error(MULTIPLE_USB_LEDGER_DEVICES_ERROR_MESSAGE), {
+    code: HardwareErrorCode.DeviceOneDeviceOnly
+  });
+}
+function ledgerFailure(code, error, appName, tag, params) {
   const payload = { error, code };
   if (appName !== void 0) payload.appName = appName;
+  if (tag !== void 0) payload._tag = tag;
+  if (params !== void 0) payload.params = params;
   return { success: false, payload };
 }
 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"]);
-var STEP_BLIND_SIGN_FALLBACK = "signer.eth.steps.blindSignTransactionFallback";
+var STEP_BLIND_SIGN_TRANSACTION_FALLBACK = "signer.eth.steps.blindSignTransactionFallback";
 function getEthAppErrorCode(err) {
   if (!err || typeof err !== "object") return null;
   const e = err;
-  if (e._tag === "EthAppCommandError" && typeof e.errorCode === "string") {
+  if (e._tag === ERROR_TAG.EthAppCommand && typeof e.errorCode === "string") {
     return e.errorCode.toLowerCase();
   }
   const orig = e.originalError;
-  if (orig?._tag === "EthAppCommandError" && typeof orig.errorCode === "string") {
+  if (orig?._tag === ERROR_TAG.EthAppCommand && typeof orig.errorCode === "string") {
     return orig.errorCode.toLowerCase();
   }
   return null;
@@ -88,13 +98,8 @@ function mapBtcAppError(hex) {
       return null;
   }
 }
-function mapEthAppError(ethCode, lastStep) {
+function mapEthAppErrorCode(ethCode) {
   switch (ethCode) {
-    case "6a80":
-      if (lastStep === STEP_BLIND_SIGN_FALLBACK) {
-        return HardwareErrorCode.EvmBlindSigningRequired;
-      }
-      return null;
     case "6984":
       return HardwareErrorCode.EvmClearSignPluginMissing;
     case "6a84":
@@ -107,16 +112,133 @@ function mapEthAppError(ethCode, lastStep) {
       return null;
   }
 }
+function classifyEthAppError(err) {
+  const ethCode = getEthAppErrorCode(err);
+  if (!ethCode) return null;
+  if (ethCode === "6a80") {
+    return hasBlindSignFallbackStep(err) ? HardwareErrorCode.EvmBlindSigningRequired : null;
+  }
+  return mapEthAppErrorCode(ethCode);
+}
+var ERROR_TAG = {
+  // SDK-mint
+  DeviceNotAdvertising: "DeviceNotAdvertisingError",
+  // BLE scan miss
+  DeviceNotInDiscoveryCache: "DeviceNotInDiscoveryCacheError",
+  // dm.connect() before enumerate
+  BlePairingTimeout: "BlePairingTimeoutError",
+  // SMP 30s timeout
+  BleGattBondingFailed: "BleGattBondingFailedError",
+  // other GATT failure
+  UserAborted: "UserAborted",
+  DeviceAppStuck: "DeviceAppStuck",
+  // chain app wedged (APDU 0x6901)
+  DeviceTransportStuck: "DeviceTransportStuck",
+  // DMK transport queue wedged
+  // DMK-reuse (DMK throws same string; we synthesize too)
+  DeviceLocked: "DeviceLockedError",
+  DeviceNotRecognized: "DeviceNotRecognizedError",
+  DeviceSessionNotFound: "DeviceSessionNotFound",
+  OpenAppCommand: "OpenAppCommandError",
+  // DMK-only (read only)
+  EthAppCommand: "EthAppCommandError",
+  UserRefusedOnDevice: "UserRefusedOnDevice",
+  WrongAppOpened: "WrongAppOpenedError",
+  InvalidStatusWord: "InvalidStatusWordError",
+  AlreadySendingApdu: "AlreadySendingApduError",
+  UnknownDeviceExchange: "UnknownDeviceExchangeError",
+  NoAccessibleDevice: "NoAccessibleDeviceError",
+  UnknownDevice: "UnknownDeviceError",
+  DeviceSessionRefresher: "DeviceSessionRefresherError",
+  DeviceNotInitialized: "DeviceNotInitializedError",
+  OpeningConnection: "OpeningConnectionError",
+  DeviceDisconnectedBeforeSendingApdu: "DeviceDisconnectedBeforeSendingApdu",
+  DeviceDisconnectedWhileSending: "DeviceDisconnectedWhileSendingError",
+  Disconnect: "DisconnectError",
+  ReconnectionFailed: "ReconnectionFailedError",
+  WebHIDDisconnect: "WebHIDDisconnectError",
+  // ble-plx surfaces this when GATT notification setup fails — typical
+  // outcome when the user doesn't confirm pairing on the device, or the
+  // existing bond is invalid. Observed in production after ~30s.
+  PairingRefused: "PairingRefusedError"
+};
 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 (e._tag === ERROR_TAG.DeviceLocked) 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 isDeviceNotAdvertisingError(err) {
+  if (!err || typeof err !== "object") return false;
+  return err._tag === ERROR_TAG.DeviceNotAdvertising;
+}
+var PAIRING_FAILURE_TAGS = /* @__PURE__ */ new Set([
+  ERROR_TAG.BlePairingTimeout,
+  ERROR_TAG.BleGattBondingFailed,
+  ERROR_TAG.PairingRefused
+]);
+function isBlePairingFailureError(err) {
+  if (!err || typeof err !== "object") return false;
+  const tag = err._tag;
+  if (tag && PAIRING_FAILURE_TAGS.has(tag)) return true;
+  const orig = err.originalError;
+  if (orig != null && isBlePairingFailureError(orig)) return true;
+  return false;
+}
+var CONNECTION_LEVEL_TAGS = /* @__PURE__ */ new Set([
+  ERROR_TAG.DeviceLocked,
+  ERROR_TAG.DeviceNotAdvertising,
+  ERROR_TAG.BlePairingTimeout,
+  ERROR_TAG.BleGattBondingFailed,
+  ERROR_TAG.PairingRefused,
+  ERROR_TAG.DeviceNotRecognized,
+  ERROR_TAG.NoAccessibleDevice,
+  ERROR_TAG.UnknownDevice,
+  ERROR_TAG.DeviceSessionNotFound,
+  ERROR_TAG.DeviceSessionRefresher,
+  ERROR_TAG.DeviceNotInitialized,
+  ERROR_TAG.OpeningConnection,
+  ERROR_TAG.DeviceDisconnectedBeforeSendingApdu,
+  ERROR_TAG.DeviceDisconnectedWhileSending,
+  ERROR_TAG.Disconnect,
+  ERROR_TAG.ReconnectionFailed,
+  ERROR_TAG.WebHIDDisconnect
+]);
+var DEVICE_NOT_FOUND_TAGS = /* @__PURE__ */ new Set([
+  ERROR_TAG.NoAccessibleDevice,
+  ERROR_TAG.UnknownDevice,
+  ERROR_TAG.DeviceNotInitialized,
+  // SDK-internal: dm.connect() called before _discovered was populated.
+  // Map to DeviceNotFound so non-BLE-direct paths get a sensible error code.
+  ERROR_TAG.DeviceNotInDiscoveryCache
+]);
+var DEVICE_BUSY_TAGS = /* @__PURE__ */ new Set([ERROR_TAG.OpeningConnection]);
+var DEVICE_DISCONNECTED_TAGS = /* @__PURE__ */ new Set([
+  ERROR_TAG.DeviceNotRecognized,
+  ERROR_TAG.DeviceSessionNotFound,
+  ERROR_TAG.DeviceSessionRefresher,
+  ERROR_TAG.DeviceDisconnectedBeforeSendingApdu,
+  ERROR_TAG.DeviceDisconnectedWhileSending,
+  ERROR_TAG.Disconnect,
+  ERROR_TAG.ReconnectionFailed,
+  ERROR_TAG.WebHIDDisconnect
+]);
+function isConnectionLevelError(err) {
+  if (!err || typeof err !== "object") return false;
+  const tag = err._tag;
+  if (tag && CONNECTION_LEVEL_TAGS.has(tag)) return true;
+  const e = err;
+  if (e.originalError != null && isConnectionLevelError(e.originalError)) return true;
+  if (e.error != null && e._tag && isConnectionLevelError(e.error)) return true;
+  return false;
+}
+function isKnownConnectionTag(tag) {
+  return typeof tag === "string" && CONNECTION_LEVEL_TAGS.has(tag);
+}
 function hasStatusCode(err, codeSet) {
   if (!err || typeof err !== "object") return false;
   const e = err;
@@ -126,10 +248,39 @@ function hasStatusCode(err, codeSet) {
   if (e.error != null && e._tag && hasStatusCode(e.error, codeSet)) return true;
   return false;
 }
+function hasBlindSignFallbackStep(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e._lastStep === STEP_BLIND_SIGN_TRANSACTION_FALLBACK) return true;
+  if (Array.isArray(e._deviceActionSteps) && e._deviceActionSteps.includes(STEP_BLIND_SIGN_TRANSACTION_FALLBACK)) {
+    return true;
+  }
+  if (e.originalError != null && hasBlindSignFallbackStep(e.originalError)) return true;
+  if (e.error != null && e._tag && hasBlindSignFallbackStep(e.error)) return true;
+  return false;
+}
+function isDeviceNotFoundError(err) {
+  if (!err || typeof err !== "object") return false;
+  const tag = err._tag;
+  if (tag && DEVICE_NOT_FOUND_TAGS.has(tag)) return true;
+  const e = err;
+  if (e.originalError != null && isDeviceNotFoundError(e.originalError)) return true;
+  if (e.error != null && e._tag && isDeviceNotFoundError(e.error)) return true;
+  return false;
+}
+function isDeviceBusyError(err) {
+  if (!err || typeof err !== "object") return false;
+  const tag = err._tag;
+  if (tag && DEVICE_BUSY_TAGS.has(tag)) return true;
+  const e = err;
+  if (e.originalError != null && isDeviceBusyError(e.originalError)) return true;
+  if (e.error != null && e._tag && isDeviceBusyError(e.error)) return true;
+  return false;
+}
 function isUserRejectedError(err) {
   if (!err || typeof err !== "object") return false;
   const e = err;
-  if (e._tag === "UserRefusedOnDevice") return true;
+  if (e._tag === ERROR_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;
@@ -137,7 +288,7 @@ function isUserRejectedError(err) {
 function isWrongAppError(err) {
   if (!err || typeof err !== "object") return false;
   const e = err;
-  if (e._tag === "WrongAppOpenedError" || e._tag === "InvalidStatusWordError") {
+  if (e._tag === ERROR_TAG.WrongAppOpened || e._tag === ERROR_TAG.InvalidStatusWord) {
     if (hasStatusCode(err, WRONG_APP_CODES)) return true;
   }
   if (typeof e.message === "string") {
@@ -151,7 +302,6 @@ function isWrongAppError(err) {
 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;
@@ -159,7 +309,8 @@ function isAppNotInstalledError(err) {
 function isDeviceDisconnectedError(err) {
   if (!err || typeof err !== "object") return false;
   const e = err;
-  if (e._tag === "DeviceNotRecognizedError" || e._tag === "DeviceSessionNotFound") return true;
+  const tag = e._tag;
+  if (typeof tag === "string" && DEVICE_DISCONNECTED_TAGS.has(tag)) return true;
   if (typeof e.message === "string") {
     const msg = e.message.toLowerCase();
     if (msg.includes("disconnected") || msg.includes("not found") || msg.includes("no device") || msg.includes("unplugged"))
@@ -179,7 +330,22 @@ function isTimeoutError(err) {
   if (e.code === HardwareErrorCode.OperationTimeout) return true;
   return false;
 }
-function mapLedgerError(err) {
+function isAppStuckByApdu(err) {
+  if (!err || typeof err !== "object") return false;
+  const tag = err._tag;
+  if (tag === ERROR_TAG.DeviceAppStuck) return true;
+  return extractApduHex(err) === "6901";
+}
+function isTransportStuck(err) {
+  if (!err || typeof err !== "object") return false;
+  const tag = err._tag;
+  return tag === ERROR_TAG.DeviceTransportStuck || // already wrapped form
+  tag === ERROR_TAG.UnknownDeviceExchange || tag === ERROR_TAG.AlreadySendingApdu;
+}
+function isStuckAppStateError(err) {
+  return isAppStuckByApdu(err) || isTransportStuck(err);
+}
+function mapLedgerError(err, opts) {
   let originalMessage = "Unknown Ledger error";
   if (err instanceof Error) {
     originalMessage = err.message;
@@ -190,60 +356,127 @@ function mapLedgerError(err) {
   let code;
   if (isDeviceLockedError(err)) {
     code = HardwareErrorCode.DeviceLocked;
+  } else if (isDeviceNotAdvertisingError(err) || isDeviceNotFoundError(err)) {
+    code = HardwareErrorCode.DeviceNotFound;
+  } else if (isDeviceBusyError(err)) {
+    code = HardwareErrorCode.DeviceBusy;
+  } else if (isBlePairingFailureError(err)) {
+    code = HardwareErrorCode.BlePairingTimeout;
   } else if (isUserRejectedError(err)) {
     code = HardwareErrorCode.UserRejected;
   } else if (isWrongAppError(err)) {
     code = HardwareErrorCode.WrongApp;
   } else if (isAppNotInstalledError(err)) {
-    code = HardwareErrorCode.AppNotOpen;
+    code = HardwareErrorCode.AppNotInstalled;
   } else if (isDeviceDisconnectedError(err)) {
     code = HardwareErrorCode.DeviceDisconnected;
   } else if (isTimeoutError(err)) {
     code = HardwareErrorCode.OperationTimeout;
   } else {
-    const ethCode = getEthAppErrorCode(err);
-    const lastStep = err && typeof err === "object" ? err._lastStep : void 0;
-    const ethMapped = ethCode ? mapEthAppError(ethCode, lastStep) : null;
+    const ethMapped = classifyEthAppError(err);
     const apduHex = ethMapped ? null : extractApduHex(err);
     const chainMapped = apduHex ? mapSolanaAppError(apduHex) ?? mapTronAppError(apduHex) ?? mapBtcAppError(apduHex) : null;
     code = ethMapped ?? chainMapped ?? HardwareErrorCode.UnknownError;
   }
-  const appName = err && typeof err === "object" ? err.appName : void 0;
+  const errAppName = err && typeof err === "object" ? err.appName : void 0;
+  const appName = errAppName ?? opts?.defaultAppName;
   return { code, message: enrichErrorMessage(code, originalMessage), appName };
 }
 
-// src/utils/debugLog.ts
-var enabled = false;
-function setDebugEnabled(value) {
-  enabled = value;
+// src/utils/ledgerDmkTransport.ts
+function isLedgerDmkBleTransport(transport) {
+  const normalized = transport?.toUpperCase();
+  return normalized === "BLE" || normalized?.endsWith("_BLE") === true;
 }
-function isDebugEnabled() {
-  return enabled;
+function isLedgerBleConnectionType(connectionType) {
+  return connectionType === "ble";
 }
-function debugLog(...args) {
-  if (enabled) {
-    console.debug(...args);
+function isLedgerBleDescriptor(connectionType, descriptor) {
+  return isLedgerBleConnectionType(connectionType) || isLedgerDmkBleTransport(descriptor.transport);
+}
+
+// src/utils/sdkEventBus.ts
+var listeners = /* @__PURE__ */ new Set();
+function onSdkEvent(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function offSdkEvent(listener) {
+  listeners.delete(listener);
+}
+function emitSdkEvent(event) {
+  if (listeners.size === 0) return;
+  for (const listener of listeners) {
+    try {
+      listener(event);
+    } catch {
+    }
   }
 }
-function debugError(...args) {
-  if (enabled) {
-    console.error(...args);
+function emitLog(level, ...args) {
+  if (listeners.size === 0) return;
+  const message = args.map((a) => typeof a === "string" ? a : safeStringify(a)).join(" ");
+  emitSdkEvent({ type: "log", level, message });
+}
+function safeStringify(value) {
+  if (value instanceof Error) {
+    return value.stack ? `${value.message}
+${value.stack}` : value.message;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
   }
 }
 
+// src/utils/debugLog.ts
+function debugLog(...args) {
+  emitLog("debug", ...args);
+}
+function debugError(...args) {
+  emitLog("error", ...args);
+}
+
 // src/adapter/LedgerAdapter.ts
 function formatDeviceMismatchError(expected, actual) {
   return `Wrong device: expected ${expected}, got ${actual}`;
 }
+var BTC_HIGH_INDEX_THRESHOLD = 100;
+function btcAccountIndexFromPath(path) {
+  const segments = path.replace(/^m\//, "").split("/");
+  if (segments.length < 3) return null;
+  const accountSeg = segments[2].replace(/['h]$/i, "");
+  const accountIndex = parseInt(accountSeg, 10);
+  return Number.isFinite(accountIndex) ? accountIndex : null;
+}
 var _LedgerAdapter = class _LedgerAdapter {
-  constructor(connector, options) {
+  constructor(connector) {
     this.vendor = "ledger";
     this.emitter = new TypedEventEmitter();
-    // Device cache: tracks discovered devices from connector events
     this._discoveredDevices = /* @__PURE__ */ new Map();
-    // Session tracking: maps connectId -> sessionId
     this._sessions = /* @__PURE__ */ new Map();
     this._uiRegistry = new UiRequestRegistry();
+    // BTC App rejects account index >= 100 unless display=true. Cached per
+    // adapter instance: first 100+ path asks the user once via UI request,
+    // subsequent 100+ paths in the same session auto-promote silently.
+    // The Ledger device itself still requires a per-call confirmation — that's
+    // the Ledger app's safety boundary, not ours to bypass.
+    this._btcHighIndexConfirmedThisSession = false;
+    // Shared across concurrent callers — only `cancel()` aborts.
+    this._doConnectAbortController = null;
+    // ---------------------------------------------------------------------------
+    // 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 → exactly 1 USB device auto-connects; multiple or none throws.
+     */
     // Mutex for ensureConnected — prevents concurrent calls from establishing duplicate connections
     this._connectingPromise = null;
     // ---------------------------------------------------------------------------
@@ -266,47 +499,30 @@ var _LedgerAdapter = class _LedgerAdapter {
         payload: { connectId: data.connectId }
       });
     };
-    this.uiRequestHandler = (data) => {
-      this.handleUiEvent(data);
-    };
-    this.uiEventHandler = (data) => {
-      this.handleUiEvent(data);
+    // Forward low-level connector 'ui-event' (the four EConnectorInteraction values)
+    // to the public hw.emitter so consumers only need to subscribe in one place
+    // (hw.on instead of also reaching into connector.on).
+    this.uiEventForwarder = (event) => {
+      this.emitter.emit("ui-event", event);
     };
     this.connector = connector;
-    this._handleSelectDevice = options?.handleSelectDevice ?? false;
-    this._jobQueue = new DeviceJobQueue({
-      emit: (event, data) => this.emitter.emit(event, data),
-      uiRegistry: this._uiRegistry
-    });
+    this._jobQueue = new DeviceJobQueue();
     this.registerEventListeners();
   }
-  /**
-   * Classify a method's interruptibility.
-   * - Signing / typed data / transaction → 'confirm' (user may decide via preemption UI)
-   * - Read-only queries (getAddress / getPublicKey / getMasterFingerprint) → 'safe'
-   *   (auto-cancels any pending read for the same device)
-   */
-  static _getInterruptibility(method) {
-    if (method.toLowerCase().includes("sign")) return "confirm";
-    return "safe";
-  }
-  // ---------------------------------------------------------------------------
   // Transport
-  // ---------------------------------------------------------------------------
-  // Transport is decided at connector creation time. These methods
-  // satisfy the IHardwareWallet interface with sensible defaults.
   get activeTransport() {
-    return this.connector.connectionType === "ble" ? "ble" : "hid";
+    return isLedgerBleConnectionType(this.connector.connectionType) ? "ble" : "hid";
   }
   getAvailableTransports() {
     return this.activeTransport ? [this.activeTransport] : [];
   }
-  async switchTransport(_type) {
+  // Connector is bound at construction; switching requires a new adapter.
+  switchTransport(_type) {
+    return Promise.resolve();
   }
-  // ---------------------------------------------------------------------------
   // Lifecycle
-  // ---------------------------------------------------------------------------
-  async init(_config) {
+  init(_config) {
+    return Promise.resolve();
   }
   /**
    * Clear cached device/session state without tearing down the adapter.
@@ -319,6 +535,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     this._connectingPromise = null;
     this._uiRegistry.reset();
     this._jobQueue.clear();
+    this._btcHighIndexConfirmedThisSession = false;
   }
   async dispose() {
     this._uiRegistry.reset();
@@ -327,6 +544,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     this.connector.reset();
     this._discoveredDevices.clear();
     this._sessions.clear();
+    this._btcHighIndexConfirmedThisSession = false;
     this.emitter.removeAllListeners();
   }
   uiResponse(response) {
@@ -335,10 +553,17 @@ var _LedgerAdapter = class _LedgerAdapter {
   // ---------------------------------------------------------------------------
   // Device management
   // ---------------------------------------------------------------------------
-  async searchDevices() {
+  async searchDevices(options) {
+    if (options?.resetSession) {
+      this._doConnectAbortController?.abort();
+      this._sessions.clear();
+      this._connectingPromise = null;
+      this._doConnectAbortController = null;
+      this._btcHighIndexConfirmedThisSession = false;
+    }
     await this._ensureDevicePermission();
     const devices = await this.connector.searchDevices();
-    debugLog("[DMK] adapter.searchDevices raw:", JSON.stringify(devices));
+    this._discoveredDevices.clear();
     for (const d of devices) {
       if (d.connectId) {
         this._discoveredDevices.set(d.connectId, this.connectorDeviceToDeviceInfo(d));
@@ -347,11 +572,41 @@ var _LedgerAdapter = class _LedgerAdapter {
     if (this._discoveredDevices.size === 0) {
       await this._ensureDevicePermission();
     }
+    debugLog(
+      `[LedgerAdapter] searchDevices() return count=${this._discoveredDevices.size} ids=[${[
+        ...this._discoveredDevices.keys()
+      ].join(",")}]`
+    );
     return Array.from(this._discoveredDevices.values());
   }
+  // USB single-session invariant: evict all sessions, best-effort (see connectDevice).
+  async _evictAllSessions() {
+    if (this._sessions.size === 0) return;
+    const stale = [...this._sessions.values()];
+    this._sessions.clear();
+    for (const sid of stale) {
+      try {
+        await this.connector.disconnect(sid);
+      } catch {
+      }
+    }
+  }
+  static _createDeviceBusyError(method) {
+    return Object.assign(new Error(`Ledger device is busy while calling ${method}`), {
+      code: HardwareErrorCode2.DeviceBusy
+    });
+  }
   async connectDevice(connectId) {
-    await this._ensureDevicePermission(connectId);
     try {
+      if (isLedgerBleConnectionType(this.connector.connectionType) && !connectId) {
+        throw Object.assign(new Error("Ledger BLE connectId is required."), {
+          code: HardwareErrorCode2.DeviceNotFound
+        });
+      }
+      if (!isLedgerBleConnectionType(this.connector.connectionType)) {
+        await this._evictAllSessions();
+      }
+      await this._ensureDevicePermission(connectId);
       const session = await this.connector.connect(connectId);
       this._sessions.set(connectId, session.sessionId);
       if (session.deviceInfo) {
@@ -387,7 +642,6 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Chain call helper
   // ---------------------------------------------------------------------------
   async callChain(connectId, deviceId, chain, method, params, skipFingerprint = false) {
-    await this._ensureDevicePermission(connectId, deviceId);
     try {
       const result = await this.connectorCall(connectId, method, params, {
         chain,
@@ -399,45 +653,12 @@ var _LedgerAdapter = class _LedgerAdapter {
       return this.errorToFailure(err);
     }
   }
-  /**
-   * Batch version of callChain — checks permission once,
-   * fingerprint is verified on the first call inside connectorCall.
-   */
-  async callChainBatch(connectId, deviceId, chain, method, params, onProgress, skipFingerprint = false) {
-    await this._ensureDevicePermission(connectId, deviceId);
-    const results = [];
-    for (let i = 0; i < params.length; i++) {
-      try {
-        const result = await this.connectorCall(connectId, method, params[i], {
-          chain,
-          deviceId,
-          // Only verify fingerprint on the first call in the batch
-          skipFingerprint: skipFingerprint || i > 0
-        });
-        results.push(result);
-        onProgress?.({ index: i, total: params.length });
-      } catch (err) {
-        return this.errorToFailure(err);
-      }
-    }
-    return 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
-    );
-  }
   evmSignTransaction(connectId, deviceId, params) {
     return this.callChain(connectId, deviceId, "evm", "evmSignTransaction", params);
   }
@@ -453,16 +674,6 @@ var _LedgerAdapter = class _LedgerAdapter {
   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);
   }
@@ -490,16 +701,6 @@ var _LedgerAdapter = class _LedgerAdapter {
   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
-    );
-  }
   solSignTransaction(connectId, deviceId, params) {
     return this.callChain(connectId, deviceId, "sol", "solSignTransaction", params);
   }
@@ -510,38 +711,13 @@ var _LedgerAdapter = class _LedgerAdapter {
   // 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
-    );
+    return this.callChain(connectId, deviceId, "tron", "tronGetAddress", params);
   }
   tronSignTransaction(connectId, deviceId, params) {
-    return this.callChain(
-      connectId,
-      deviceId,
-      "tron",
-      "tronSignTransaction",
-      params,
-      true
-    );
+    return this.callChain(connectId, deviceId, "tron", "tronSignTransaction", params);
   }
   tronSignMessage(connectId, deviceId, params) {
-    return this.callChain(
-      connectId,
-      deviceId,
-      "tron",
-      "tronSignMessage",
-      params,
-      true
-    );
+    return this.callChain(connectId, deviceId, "tron", "tronSignMessage", params);
   }
   on(event, listener) {
     this.emitter.on(event, listener);
@@ -550,30 +726,41 @@ var _LedgerAdapter = class _LedgerAdapter {
     this.emitter.off(event, listener);
   }
   cancel(connectId) {
-    const sessionId = this._sessions.get(connectId) ?? connectId;
-    this._jobQueue.forceCancelActive(connectId || "__ledger_default__");
-    void this.connector.cancel(sessionId);
+    const userAbortReason = Object.assign(new Error("User aborted operation"), {
+      code: HardwareErrorCode2.UserAborted,
+      _tag: ERROR_TAG.UserAborted
+    });
+    this._lastCancelReason = userAbortReason;
+    setTimeout(() => {
+      if (this._lastCancelReason === userAbortReason) {
+        this._lastCancelReason = void 0;
+      }
+    }, 2e3);
+    this._uiRegistry.cancel();
+    if (connectId) {
+      this._jobQueue.cancelActiveAndPending(connectId, userAbortReason);
+    } else {
+      this._jobQueue.cancelActiveAndPending(void 0, userAbortReason);
+    }
+    if (connectId) {
+      const sessionId = this._sessions.get(connectId) ?? connectId;
+      void this.connector.cancel(sessionId);
+    } else {
+      for (const sid of this._sessions.values()) void this.connector.cancel(sid);
+    }
+    if (this._connectingPromise) {
+      this._doConnectAbortController?.abort(userAbortReason);
+    }
   }
   // ---------------------------------------------------------------------------
   // Chain fingerprint
   // ---------------------------------------------------------------------------
   async getChainFingerprint(connectId, deviceId, chain) {
-    debugLog(
-      "[LedgerAdapter] getChainFingerprint called, chain:",
-      chain,
-      "connectId:",
-      connectId || "(empty)",
-      "sessions:",
-      this._sessions.size
-    );
-    await this._ensureDevicePermission(connectId, deviceId);
-    debugLog("[LedgerAdapter] getChainFingerprint permission ok, computing fingerprint");
     try {
       const fingerprint = await this._computeChainFingerprint(
         chain,
-        (method, params) => this.connectorCall(connectId, method, params)
+        (method, params) => this.connectorCall(connectId, method, params, void 0, deviceId)
       );
-      debugLog("[LedgerAdapter] getChainFingerprint result:", fingerprint?.substring(0, 20));
       return success(fingerprint);
     } catch (err) {
       debugError("[LedgerAdapter] getChainFingerprint error:", chain, err);
@@ -644,102 +831,252 @@ var _LedgerAdapter = class _LedgerAdapter {
     if (signal?.aborted) {
       _LedgerAdapter._throwIfAborted(signal);
     }
+    const waitPromise = this._uiRegistry.wait(
+      UI_REQUEST.REQUEST_DEVICE_CONNECT
+    );
     this.emitter.emit(UI_REQUEST.REQUEST_DEVICE_CONNECT, {
       type: UI_REQUEST.REQUEST_DEVICE_CONNECT,
       payload: {
+        vendor: "ledger",
+        reason: "device-not-found",
         message: "Please connect and unlock your Ledger device"
       }
     });
-    const waitPromise = this._uiRegistry.wait(
-      UI_REQUEST.REQUEST_DEVICE_CONNECT
-    );
     let payload;
-    if (signal) {
-      const onAbort = () => {
-        this._uiRegistry.cancel(UI_REQUEST.REQUEST_DEVICE_CONNECT);
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
-      try {
+    try {
+      if (signal) {
+        const onAbort = () => {
+          this._uiRegistry.cancel(UI_REQUEST.REQUEST_DEVICE_CONNECT);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        try {
+          payload = await waitPromise;
+        } finally {
+          signal.removeEventListener("abort", onAbort);
+        }
+      } else {
         payload = await waitPromise;
-      } finally {
-        signal.removeEventListener("abort", onAbort);
       }
-    } else {
-      payload = await waitPromise;
+    } catch (err) {
+      this.emitter.emit(UI_REQUEST.CLOSE_UI_WINDOW, {
+        type: UI_REQUEST.CLOSE_UI_WINDOW,
+        payload: {}
+      });
+      throw Object.assign(new Error("User cancelled Ledger connection"), {
+        _tag: ERROR_TAG.UserAborted,
+        code: HardwareErrorCode2.UserAborted,
+        cause: err
+      });
     }
     if (!payload?.confirmed) {
       throw Object.assign(new Error("User cancelled Ledger connection"), {
-        _tag: "DeviceNotRecognizedError"
+        _tag: ERROR_TAG.UserAborted,
+        code: HardwareErrorCode2.UserAborted
       });
     }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 800);
+    });
   }
-  async ensureConnected(connectId) {
-    if (connectId && this._sessions.has(connectId)) {
-      return connectId;
-    }
-    if (this._sessions.size > 0) {
-      const firstKey = this._sessions.keys().next().value;
-      return firstKey;
+  /**
+   * Decide whether a BTC pubkey call needs `showOnDevice=true` because of
+   * the BTC App's account-index policy, asking the user once per session.
+   *
+   * Returns the params to pass through (with `showOnDevice` possibly
+   * promoted), or `null` if the user declined.
+   */
+  async _gateBtcHighIndex(params) {
+    const accountIndex = btcAccountIndexFromPath(params.path);
+    if (params.showOnDevice) return params;
+    if (accountIndex === null || accountIndex < BTC_HIGH_INDEX_THRESHOLD) {
+      return params;
     }
-    if (this._connectingPromise) {
-      return this._connectingPromise;
+    if (this._btcHighIndexConfirmedThisSession) {
+      return { ...params, showOnDevice: true };
     }
-    this._connectingPromise = this._doConnect();
+    const confirmed = await this._waitForBtcHighIndexConfirm(params.path, accountIndex);
+    if (!confirmed) return null;
+    this._btcHighIndexConfirmedThisSession = true;
+    return { ...params, showOnDevice: true };
+  }
+  async _waitForBtcHighIndexConfirm(path, accountIndex) {
+    const waitPromise = this._uiRegistry.wait(
+      UI_REQUEST.REQUEST_BTC_HIGH_INDEX_CONFIRM
+    );
+    this.emitter.emit(UI_REQUEST.REQUEST_BTC_HIGH_INDEX_CONFIRM, {
+      type: UI_REQUEST.REQUEST_BTC_HIGH_INDEX_CONFIRM,
+      payload: {
+        vendor: "ledger",
+        path,
+        accountIndex
+      }
+    });
     try {
-      return await this._connectingPromise;
-    } finally {
-      this._connectingPromise = null;
+      const payload = await waitPromise;
+      return !!payload?.confirmed;
+    } catch (err) {
+      this.emitter.emit(UI_REQUEST.CLOSE_UI_WINDOW, {
+        type: UI_REQUEST.CLOSE_UI_WINDOW,
+        payload: {}
+      });
+      return false;
     }
   }
-  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();
+  // Layer 1 entry. Caller signal only races the outer awaiter; the shared
+  // `_doConnect` runs under its own internal controller so caller A's cancel
+  // doesn't kill caller B's await.
+  async ensureConnected(connectId, signal) {
+    if (signal.aborted) _LedgerAdapter._throwIfAborted(signal);
+    if (isLedgerBleConnectionType(this.connector.connectionType) && !connectId) {
+      throw Object.assign(new Error("Ledger BLE connectId is required."), {
+        code: HardwareErrorCode2.DeviceNotFound
+      });
+    }
+    if (connectId && this._sessions.has(connectId)) return connectId;
+    if (!connectId && this._sessions.size > 0) {
+      if (!isLedgerBleConnectionType(this.connector.connectionType) && this._sessions.size > 1) {
+        throw Object.assign(
+          new Error(
+            "Ledger USB session invariant violated: more than one session is active. Please reconnect the device."
+          ),
+          { code: HardwareErrorCode2.DeviceOneDeviceOnly }
+        );
       }
+      return this._sessions.keys().next().value;
     }
-    throw Object.assign(
-      new Error(
-        "No Ledger device found after multiple attempts. Please connect and unlock your device."
-      ),
-      { _tag: "DeviceNotRecognizedError" }
-    );
+    if (!this._connectingPromise) {
+      this._doConnectAbortController = new AbortController();
+      const innerSignal = this._doConnectAbortController.signal;
+      this._connectingPromise = (async () => {
+        try {
+          return await this._doConnect(innerSignal, connectId);
+        } finally {
+          this._connectingPromise = null;
+          this._doConnectAbortController = null;
+        }
+      })();
+    }
+    return this._abortable(signal, this._connectingPromise);
   }
-  async _connectFirstOrSelect(devices) {
-    const chosenConnectId = devices.length === 1 ? devices[0].connectId : await this._chooseDeviceFromList(devices);
-    const result = await this.connectDevice(chosenConnectId);
-    if (!result.success) {
-      throw Object.assign(new Error(result.payload.error), {
-        _tag: "DeviceNotRecognizedError"
+  // Layer 1 main loop — the ONLY place in SDK that emits unlock dialog.
+  // Bounded by MAX_DOCONNECT_CONFIRMS — after N Confirms with no progress,
+  // throw DeviceNotFound so the user is kicked out of the loop.
+  async _doConnect(internalSignal, targetConnectId) {
+    if (isLedgerBleConnectionType(this.connector.connectionType) && targetConnectId) {
+      try {
+        return await this._connectDeviceOrThrow(targetConnectId);
+      } catch (err) {
+        if (!isDeviceLockedError(err) && !isDeviceNotAdvertisingError(err) && !isDeviceDisconnectedError(err)) {
+          throw err;
+        }
+        this._discoveredDevices.delete(targetConnectId);
+        if (isDeviceDisconnectedError(err)) {
+          try {
+            this.connector.reset?.();
+          } catch {
+          }
+        }
+      }
+    }
+    let confirms = 0;
+    while (!internalSignal.aborted) {
+      this.emitter.emit("ui-event", {
+        type: EConnectorInteraction.Searching,
+        payload: { sessionId: "" }
       });
+      let devices = await this.searchDevices();
+      if (devices.length === 0) {
+        for (let i = 0; i < 3 && !internalSignal.aborted; i += 1) {
+          await new Promise((resolve) => {
+            setTimeout(resolve, 1e3);
+          });
+          devices = await this.searchDevices();
+          if (devices.length > 0) break;
+        }
+      }
+      if (devices.length > 0) {
+        try {
+          return await this._connectFirstOrSelect(devices, targetConnectId);
+        } catch (err) {
+          if (!isDeviceLockedError(err) && !isDeviceNotAdvertisingError(err) && !isDeviceDisconnectedError(err)) {
+            throw err;
+          }
+          this._discoveredDevices.clear();
+          if (isDeviceDisconnectedError(err)) {
+            try {
+              this.connector.reset?.();
+            } catch {
+            }
+          }
+        }
+      }
+      if (confirms >= _LedgerAdapter.MAX_DOCONNECT_CONFIRMS) {
+        throw Object.assign(
+          new Error(
+            "Device not connected after multiple attempts. Please ensure your Ledger is awake, unlocked, and in range, then try again."
+          ),
+          { code: HardwareErrorCode2.DeviceNotFound }
+        );
+      }
+      await this._waitForDeviceConnect(internalSignal);
+      confirms += 1;
     }
-    return chosenConnectId;
+    _LedgerAdapter._throwIfAborted(internalSignal);
+    throw new Error("_doConnect aborted");
   }
-  async _chooseDeviceFromList(devices) {
-    if (!this._handleSelectDevice) {
+  async _connectFirstOrSelect(devices, targetConnectId) {
+    if (!isLedgerBleConnectionType(this.connector.connectionType) && devices.length > 1) {
       debugLog(
-        `[DMK] Multiple Ledger devices found (${devices.length}); handleSelectDevice=false, picking first (${devices[0].connectId}).`
+        `[DMK] Multiple Ledger USB devices found (${devices.length}); refusing to auto-select by ephemeral connectId.`
       );
-      return devices[0].connectId;
+      throw createMultipleUsbLedgerDevicesError();
     }
-    this.emitter.emit(UI_REQUEST.REQUEST_SELECT_DEVICE, {
-      type: UI_REQUEST.REQUEST_SELECT_DEVICE,
-      payload: { devices }
-    });
-    const response = await this._uiRegistry.wait(
-      UI_REQUEST.REQUEST_SELECT_DEVICE
-    );
-    const chosen = devices.find((d) => d.connectId === response?.sdkConnectId);
-    if (!chosen) {
-      throw Object.assign(
-        new Error(`Selected sdkConnectId '${response?.sdkConnectId}' not in discovered list`),
-        { _tag: "DeviceNotRecognizedError" }
+    if (targetConnectId) {
+      const target = devices.find(
+        (d) => d.connectId === targetConnectId || d.deviceId === targetConnectId
       );
+      if (target) {
+        return this._connectDeviceOrThrow(target.connectId);
+      }
+      if (!isLedgerBleConnectionType(this.connector.connectionType) && devices.length === 1) {
+        debugLog(
+          `[LedgerAdapter] target ${targetConnectId} not in fresh enumeration; accepting sole USB device ${devices[0].connectId} (assumed ephemeral path change)`
+        );
+        return this._connectDeviceOrThrow(devices[0].connectId);
+      }
+      const err = Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
+        code: HardwareErrorCode2.DeviceNotFound
+      });
+      if (isLedgerBleConnectionType(this.connector.connectionType)) {
+        err._tag = ERROR_TAG.DeviceNotAdvertising;
+      }
+      throw err;
+    }
+    if (isLedgerBleConnectionType(this.connector.connectionType)) {
+      throw Object.assign(new Error("Ledger BLE connectId is required."), {
+        code: HardwareErrorCode2.DeviceNotFound
+      });
+    }
+    if (devices.length !== 1) {
+      throw Object.assign(new Error("Ledger device not found."), {
+        code: HardwareErrorCode2.DeviceNotFound
+      });
+    }
+    return this._connectDeviceOrThrow(devices[0].connectId);
+  }
+  async _connectDeviceOrThrow(chosenConnectId) {
+    const result = await this.connectDevice(chosenConnectId);
+    if (!result.success) {
+      const payload = result.payload;
+      const rethrow = Object.assign(new Error(payload.error), {
+        code: payload.code
+      });
+      if (payload._tag !== void 0) {
+        rethrow._tag = payload._tag;
+      }
+      throw rethrow;
     }
-    return chosen.connectId;
+    return chosenConnectId;
   }
   /**
    * Call the connector with automatic session resolution and disconnect retry.
@@ -749,30 +1086,31 @@ var _LedgerAdapter = class _LedgerAdapter {
    * 3. Calls connector.call()
    * 4. On disconnect error: clears stale session, re-connects, retries once
    */
-  async connectorCall(connectId, method, params, fingerprint) {
+  async connectorCall(connectId, method, params, fingerprint, permissionDeviceId) {
     debugLog("[LedgerAdapter] connectorCall:", method, "connectId:", connectId || "(empty)");
     const queueKey = connectId || "__ledger_default__";
-    const interruptibility = _LedgerAdapter._getInterruptibility(method);
     return this._jobQueue.enqueue(
       queueKey,
-      async (signal) => this._runConnectorCall(connectId, method, params, signal, fingerprint),
-      { interruptibility, label: method }
+      async (signal) => this._runConnectorCall(connectId, method, params, signal, fingerprint, permissionDeviceId),
+      {
+        label: method,
+        rejectIfBusy: true,
+        busyError: _LedgerAdapter._createDeviceBusyError(method)
+      }
     );
   }
   /**
-   * Race a promise against an abort signal. If the signal fires, rejects with the
-   * signal's reason (or a generic Error). The underlying connector.call() cannot
-   * actually be cancelled on Ledger DMK, but the caller gets the abort immediately.
+   * Race a promise against an abort signal. On abort, rejects with
+   * signal.reason → instance _lastCancelReason → generic Error('Aborted').
    */
-  static _abortable(signal, promise) {
+  _abortable(signal, promise) {
+    const getAbortReason = () => signal.reason ?? this._lastCancelReason ?? new Error("Aborted");
     if (signal.aborted) {
-      return Promise.reject(
-        signal.reason ?? new Error("Aborted")
-      );
+      return Promise.reject(getAbortReason());
     }
     return new Promise((resolve, reject) => {
       const onAbort = () => {
-        reject(signal.reason ?? new Error("Aborted"));
+        reject(getAbortReason());
       };
       signal.addEventListener("abort", onAbort, { once: true });
       promise.then(
@@ -794,40 +1132,49 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
   }
   /** Actual work done under the job queue — connection, fingerprint, call, and recovery. */
-  async _runConnectorCall(connectId, method, params, signal, fingerprint) {
+  async _runConnectorCall(connectId, method, params, signal, fingerprint, permissionDeviceId) {
     _LedgerAdapter._throwIfAborted(signal);
-    const resolvedConnectId = await _LedgerAdapter._abortable(
-      signal,
-      this.ensureConnected(connectId)
+    await this._ensureDevicePermission(
+      connectId,
+      permissionDeviceId ?? fingerprint?.deviceId,
+      signal
     );
     _LedgerAdapter._throwIfAborted(signal);
+    let effectiveParams = params;
+    if (method === "btcGetPublicKey") {
+      const gatedParams = await this._gateBtcHighIndex(params);
+      if (gatedParams === null) {
+        throw Object.assign(new Error("User cancelled BTC high-index confirmation"), {
+          _tag: ERROR_TAG.UserAborted,
+          code: HardwareErrorCode2.UserAborted
+        });
+      }
+      effectiveParams = gatedParams;
+    }
+    const resolvedConnectId = await this.ensureConnected(connectId, signal);
     const sessionId = this._sessions.get(resolvedConnectId);
-    debugLog(
-      "[LedgerAdapter] connectorCall resolved:",
-      method,
-      "resolvedConnectId:",
-      resolvedConnectId,
-      "sessionId:",
-      sessionId
-    );
     if (!sessionId) {
       throw Object.assign(new Error("Auto-connect succeeded but no session found"), {
-        _tag: "DeviceSessionNotFound"
+        _tag: ERROR_TAG.DeviceSessionNotFound
       });
     }
-    if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
-      const fp = await _LedgerAdapter._abortable(
-        signal,
-        this._verifyDeviceFingerprintWithSession(sessionId, fingerprint.deviceId, fingerprint.chain)
-      );
-      if (!fp.success) {
-        throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
-          code: HardwareErrorCode2.DeviceMismatch
-        });
-      }
-    }
     try {
-      return await _LedgerAdapter._abortable(signal, this.connector.call(sessionId, method, params));
+      if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
+        const fp = await this._abortable(
+          signal,
+          this._verifyDeviceFingerprintWithSession(
+            sessionId,
+            fingerprint.deviceId,
+            fingerprint.chain
+          )
+        );
+        if (!fp.success) {
+          throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+            code: HardwareErrorCode2.DeviceMismatch
+          });
+        }
+      }
+      return await this._abortable(signal, this.connector.call(sessionId, method, effectiveParams));
     } catch (err) {
       if (signal.aborted) throw err;
       const errObj = err;
@@ -837,37 +1184,241 @@ var _LedgerAdapter = class _LedgerAdapter {
         errorCode: errObj?.errorCode,
         statusCode: errObj?.statusCode,
         isDisconnected: isDeviceDisconnectedError(err),
-        isLocked: isDeviceLockedError(err)
+        isLocked: isDeviceLockedError(err),
+        isNotAdvertising: isDeviceNotAdvertisingError(err),
+        isStuckApp: isStuckAppStateError(err)
       });
-      if (isDeviceDisconnectedError(err)) {
-        debugLog("[LedgerAdapter] disconnected, retrying with fresh connection...");
-        this._discoveredDevices.clear();
-        return this._retryWithFreshConnection(resolvedConnectId, method, params, signal, err);
+      if (isStuckAppStateError(err)) {
+        try {
+          this._sessions.delete(resolvedConnectId);
+          this._discoveredDevices.delete(resolvedConnectId);
+          this.connector.reset?.();
+        } catch {
+        }
+        debugLog(
+          "[LedgerAdapter] stuck-app retry: method=",
+          method,
+          "delayMs=",
+          _LedgerAdapter.STUCK_APP_RETRY_DELAY_MS,
+          "_tag=",
+          err?._tag
+        );
+        try {
+          const retryResult = await this._retryAfterStuckApp(
+            resolvedConnectId,
+            method,
+            effectiveParams,
+            signal,
+            err,
+            fingerprint
+          );
+          debugLog("[LedgerAdapter] stuck-app retry succeeded: method=", method);
+          return retryResult;
+        } catch (retryErr) {
+          if (signal.aborted) throw retryErr;
+          if (isStuckAppStateError(retryErr)) {
+            debugLog("[LedgerAdapter] stuck-app retry exhausted (2nd 6901): method=", method);
+            throw err;
+          }
+          debugLog(
+            "[LedgerAdapter] stuck-app retry threw non-stuck error: method=",
+            method,
+            "retryErrTag=",
+            retryErr?._tag
+          );
+          throw retryErr;
+        }
       }
-      if (isDeviceLockedError(err)) {
-        await this._waitForDeviceConnect(signal);
-        _LedgerAdapter._throwIfAborted(signal);
-        return _LedgerAdapter._abortable(signal, this.connector.call(sessionId, method, params));
+      if (isDeviceLockedError(err) || isDeviceNotAdvertisingError(err) || isDeviceDisconnectedError(err)) {
+        let lastErr = err;
+        for (let attempt = 0; attempt < _LedgerAdapter.MAX_BUSINESS_RETRY_BUDGET; attempt += 1) {
+          if (signal.aborted) throw lastErr;
+          try {
+            this._sessions.delete(resolvedConnectId);
+            this._discoveredDevices.delete(resolvedConnectId);
+            if (isDeviceDisconnectedError(lastErr)) {
+              try {
+                this.connector.reset?.();
+              } catch {
+              }
+            }
+            const reConnectId = await this.ensureConnected(resolvedConnectId, signal);
+            const reSessionId = this._sessions.get(reConnectId);
+            if (!reSessionId) throw lastErr;
+            if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
+              const fp = await this._abortable(
+                signal,
+                this._verifyDeviceFingerprintWithSession(
+                  reSessionId,
+                  fingerprint.deviceId,
+                  fingerprint.chain
+                )
+              );
+              if (!fp.success) {
+                throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+                  code: HardwareErrorCode2.DeviceMismatch
+                });
+              }
+            }
+            return await this._abortable(
+              signal,
+              this.connector.call(reSessionId, method, effectiveParams)
+            );
+          } catch (retryErr) {
+            if (signal.aborted) throw retryErr;
+            lastErr = retryErr;
+            const canRetry = attempt < _LedgerAdapter.MAX_BUSINESS_RETRY_BUDGET - 1 && (isDeviceLockedError(retryErr) || isDeviceNotAdvertisingError(retryErr) || isDeviceDisconnectedError(retryErr));
+            if (!canRetry) {
+              throw retryErr;
+            }
+          }
+        }
+        throw lastErr;
       }
       if (isTimeoutError(err)) {
         debugLog("[LedgerAdapter] timeout, retrying with fresh connection...");
         this._discoveredDevices.delete(resolvedConnectId);
-        return this._retryWithFreshConnection(resolvedConnectId, method, params, signal, err);
+        return this._retryWithFreshConnection(
+          resolvedConnectId,
+          method,
+          effectiveParams,
+          signal,
+          err,
+          fingerprint
+        );
+      }
+      if (isConnectionLevelError(err)) {
+        debugLog("[LedgerAdapter] connection-level fail-closed reset");
+        this._sessions.delete(resolvedConnectId);
+        this._discoveredDevices.delete(resolvedConnectId);
+        this.connector.reset();
+        const codeNum = err?.code;
+        throw Object.assign(err, {
+          code: codeNum ?? HardwareErrorCode2.DeviceDisconnected
+        });
       }
       throw err;
     }
   }
-  /** Clear stale session, reconnect, and retry the call. */
-  async _retryWithFreshConnection(resolvedConnectId, method, params, signal, originalErr) {
-    this._sessions.delete(resolvedConnectId);
-    _LedgerAdapter._throwIfAborted(signal);
-    const retryConnectId = await this.ensureConnected();
-    _LedgerAdapter._throwIfAborted(signal);
+  /**
+   * Stuck-app recovery: pause for the device's UI transition, then retry once.
+   *
+   * Caller has already cleared the session + reset connector. We wait so Stax
+   * finishes its post-CloseApp animation, then go through ensureConnected +
+   * fingerprint check + call exactly once. Caller decides what to do on a
+   * second stuck-app hit.
+   */
+  async _retryAfterStuckApp(resolvedConnectId, method, params, signal, originalErr, fingerprint) {
+    await this._sleepAbortable(_LedgerAdapter.STUCK_APP_RETRY_DELAY_MS, signal);
+    const retryConnectId = await this.ensureConnected(resolvedConnectId, signal);
+    const retrySessionId = this._sessions.get(retryConnectId);
+    if (!retrySessionId) throw originalErr;
+    if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
+      const fp = await this._abortable(
+        signal,
+        this._verifyDeviceFingerprintWithSession(
+          retrySessionId,
+          fingerprint.deviceId,
+          fingerprint.chain
+        )
+      );
+      if (!fp.success) {
+        throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+          code: HardwareErrorCode2.DeviceMismatch
+        });
+      }
+    }
+    return this._abortable(signal, this.connector.call(retrySessionId, method, params));
+  }
+  _sleepAbortable(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(signal.reason ?? new Error("Aborted"));
+        return;
+      }
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(signal.reason ?? new Error("Aborted"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  /**
+   * Clear stale session, reconnect, and retry the call.
+   *
+   * Timeout recovery starts with a full connector reset. After an APDU
+   * timeout, DMK/transport state may still emit malformed responses; retrying
+   * on the same DMK can poison the next chain switch.
+   */
+  async _retryWithFreshConnection(targetConnectId, method, params, signal, originalErr, fingerprint) {
+    this.connector.reset();
+    this._sessions.clear();
+    this._discoveredDevices.clear();
+    this._connectingPromise = null;
+    const retryConnectId = await this.ensureConnected(targetConnectId, signal);
     const retrySessionId = this._sessions.get(retryConnectId);
     if (!retrySessionId) {
       throw originalErr;
     }
-    return _LedgerAdapter._abortable(signal, this.connector.call(retrySessionId, method, params));
+    try {
+      if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
+        const fp = await this._abortable(
+          signal,
+          this._verifyDeviceFingerprintWithSession(
+            retrySessionId,
+            fingerprint.deviceId,
+            fingerprint.chain
+          )
+        );
+        if (!fp.success) {
+          throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+            code: HardwareErrorCode2.DeviceMismatch
+          });
+        }
+      }
+      return await this._abortable(signal, this.connector.call(retrySessionId, method, params));
+    } catch (retryErr) {
+      if (signal.aborted) throw retryErr;
+      this.connector.reset();
+      this._sessions.clear();
+      this._discoveredDevices.clear();
+      this._connectingPromise = null;
+      if (!isDeviceDisconnectedError(retryErr) && !isTimeoutError(retryErr)) {
+        throw retryErr;
+      }
+      debugLog(
+        "[LedgerAdapter] fresh-session retry still failed; resetting connector and rebuilding DMK"
+      );
+      this.connector.reset();
+      this._sessions.clear();
+      this._discoveredDevices.clear();
+      this._connectingPromise = null;
+      const finalConnectId = await this.ensureConnected(targetConnectId, signal);
+      const finalSessionId = this._sessions.get(finalConnectId);
+      if (!finalSessionId) {
+        throw originalErr;
+      }
+      if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
+        const fp = await this._abortable(
+          signal,
+          this._verifyDeviceFingerprintWithSession(
+            finalSessionId,
+            fingerprint.deviceId,
+            fingerprint.chain
+          )
+        );
+        if (!fp.success) {
+          throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
+            code: HardwareErrorCode2.DeviceMismatch
+          });
+        }
+      }
+      return this._abortable(signal, this.connector.call(finalSessionId, method, params));
+    }
   }
   /**
    * Ensure OS-level device permission (Bluetooth / USB) before proceeding.
@@ -881,7 +1432,10 @@ var _LedgerAdapter = class _LedgerAdapter {
    * - No connectId (searchDevices): environment-level permission
    * - With connectId (business methods): device-level permission
    */
-  async _ensureDevicePermission(connectId, deviceId) {
+  async _ensureDevicePermission(connectId, deviceId, signal) {
+    if (signal?.aborted) {
+      _LedgerAdapter._throwIfAborted(signal);
+    }
     const transportType = this.activeTransport ?? "hid";
     const waitPromise = this._uiRegistry.wait(
       UI_REQUEST.REQUEST_DEVICE_PERMISSION,
@@ -891,10 +1445,37 @@ var _LedgerAdapter = class _LedgerAdapter {
       type: UI_REQUEST.REQUEST_DEVICE_PERMISSION,
       payload: { transportType, connectId, deviceId }
     });
-    const { granted } = await waitPromise;
+    let response;
+    const onAbort = () => {
+      this._uiRegistry.cancel(UI_REQUEST.REQUEST_DEVICE_PERMISSION);
+    };
+    try {
+      signal?.addEventListener("abort", onAbort, { once: true });
+      response = await waitPromise;
+    } catch (err) {
+      if (signal?.aborted) {
+        _LedgerAdapter._throwIfAborted(signal);
+      }
+      if (err?._tag === UI_REQUEST_PREEMPTED_TAG) {
+        this.emitter.emit(UI_REQUEST.CLOSE_UI_WINDOW, {
+          type: UI_REQUEST.CLOSE_UI_WINDOW,
+          payload: {}
+        });
+        throw Object.assign(new Error("Device permission request superseded"), {
+          _tag: ERROR_TAG.UserAborted,
+          code: HardwareErrorCode2.UserAborted,
+          cause: err
+        });
+      }
+      throw err;
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+    }
+    const { granted, reason, message } = response;
     if (!granted) {
-      throw Object.assign(new Error("Device permission denied"), {
-        code: HardwareErrorCode2.DevicePermissionDenied
+      throw Object.assign(new Error(message ?? "Device permission denied"), {
+        code: HardwareErrorCode2.DevicePermissionDenied,
+        reason
       });
     }
   }
@@ -904,89 +1485,61 @@ var _LedgerAdapter = class _LedgerAdapter {
    */
   errorToFailure(err) {
     debugError("[LedgerAdapter] error:", err);
+    const tag = err && typeof err === "object" ? err._tag : void 0;
     if (err && typeof err === "object" && "code" in err && typeof err.code === "number") {
       const e = err;
-      return ledgerFailure(e.code, e.message ?? "Unknown error", e.appName);
+      const params = e.code === HardwareErrorCode2.DevicePermissionDenied && e.reason ? { permissionDeniedReason: e.reason } : void 0;
+      return ledgerFailure(e.code, e.message ?? "Unknown error", e.appName, tag, params);
     }
     const mapped = mapLedgerError(err);
-    return ledgerFailure(mapped.code, mapped.message, mapped.appName);
+    return ledgerFailure(mapped.code, mapped.message, mapped.appName, tag);
   }
   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);
+    this.connector.on("ui-event", this.uiEventForwarder);
   }
   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(UI_REQUEST.REQUEST_BUTTON, {
-          type: UI_REQUEST.REQUEST_BUTTON,
-          payload: { device: deviceInfo }
-        });
-        break;
-    }
+    this.connector.off("ui-event", this.uiEventForwarder);
   }
   // ---------------------------------------------------------------------------
   // Device info mapping
   // ---------------------------------------------------------------------------
   connectorDeviceToDeviceInfo(device) {
-    const isBle = device.connectId && /^[0-9A-Fa-f]{4}$/.test(device.connectId);
     return {
       vendor: "ledger",
       model: device.model ?? "unknown",
+      modelName: device.modelName,
       firmwareVersion: "",
       deviceId: device.deviceId,
       connectId: device.connectId,
       label: device.name,
-      connectionType: isBle ? "ble" : "usb",
+      connectionType: this.connector.connectionType,
+      rssi: device.rssi,
+      isConnectable: device.isConnectable,
+      serialNumber: device.serialNumber,
       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;
+// Layer 2 retry budget after connection-class error. Each round delegates
+// to Layer 1 (which owns the unlock prompt). Layer 2 never emits UI itself.
+_LedgerAdapter.MAX_BUSINESS_RETRY_BUDGET = 3;
+// Stuck-app (APDU 0x6901) retry pause. Ledger Stax often returns 6901 when
+// OpenAppCommand lands mid-transition right after CloseApp; a short wait
+// lets the device finish its UI animation before we retry once.
+_LedgerAdapter.STUCK_APP_RETRY_DELAY_MS = 500;
+// Layer 1 confirm budget. After N failed Confirm cycles (user keeps clicking
+// Confirm but device never shows up / never unlocks), throw DeviceNotFound
+// instead of looping forever.
+_LedgerAdapter.MAX_DOCONNECT_CONFIRMS = 3;
 var LedgerAdapter = _LedgerAdapter;
 
+// src/connector/LedgerConnectorBase.ts
+import { HardwareErrorCode as HardwareErrorCode7 } from "@onekeyfe/hwk-adapter-core";
+
 // src/device/LedgerDeviceManager.ts
 var LedgerDeviceManager = class {
   constructor(dmk) {
@@ -1023,7 +1576,9 @@ var LedgerDeviceManager = class {
           if (resolved) return;
           resolved = true;
           this._discovered.clear();
-          debugLog("[DMK] enumerate raw devices:", devices.length);
+          debugLog(
+            `[DMK] enumerate count=${devices.length} ids=[${devices.map((d) => d.id).join(",")}]`
+          );
           for (const d of devices) {
             this._discovered.set(d.id, d);
           }
@@ -1033,8 +1588,10 @@ var LedgerDeviceManager = class {
               devices.map((d) => ({
                 path: d.id,
                 type: d.deviceModel.model,
+                modelName: d.deviceModel.name,
                 name: d.name,
-                transport: d.transport
+                transport: d.transport,
+                rssi: d.rssi
               }))
             );
           } else {
@@ -1055,8 +1612,10 @@ var LedgerDeviceManager = class {
           devices.map((d) => ({
             path: d.id,
             type: d.deviceModel.model,
+            modelName: d.deviceModel.name,
             name: d.name,
-            transport: d.transport
+            transport: d.transport,
+            rssi: d.rssi
           }))
         );
       }
@@ -1080,8 +1639,10 @@ var LedgerDeviceManager = class {
               descriptor: {
                 path: d.id,
                 type: d.deviceModel.model,
+                modelName: d.deviceModel.name,
                 name: d.name,
-                transport: d.transport
+                transport: d.transport,
+                rssi: d.rssi
               }
             });
           }
@@ -1096,10 +1657,58 @@ var LedgerDeviceManager = class {
       }
     });
   }
-  stopListening() {
-    this._listenSub?.unsubscribe();
-    this._listenSub = null;
-  }
+  stopListening() {
+    this._listenSub?.unsubscribe();
+    this._listenSub = null;
+  }
+  /**
+   * Resolve to the latest snapshot of advertising devices observed within
+   * `timeoutMs`. Rewrites `_discovered` so it tracks the live list.
+   *
+   * `listenToAvailableDevices` is a BehaviorSubject — it emits the cached
+   * list on subscribe and *only* re-emits when the list changes. A stable
+   * list of currently-advertising devices therefore produces only the
+   * subscription frame; treating that frame as "fossil to be discarded"
+   * caused devices to flicker in/out of the UI as searches alternated
+   * between "saw a change frame" and "saw only the cached frame".
+   *
+   * The window still gives a chance for the active scan to update the list
+   * (e.g. drop a peripheral that just stopped broadcasting), but if nothing
+   * changes we trust the snapshot — DMK silence on a stable list means
+   * "everything's still there".
+   */
+  getLiveDevices(timeoutMs = 1500) {
+    debugLog(`[DMK] getLiveDevices() called, timeoutMs=${timeoutMs}`);
+    void this.requestDevice();
+    return new Promise((resolve) => {
+      let done = false;
+      let lastSeen = [];
+      let sub = null;
+      const finish = (devices) => {
+        if (done) return;
+        done = true;
+        sub?.unsubscribe();
+        clearTimeout(timer);
+        this._discovered.clear();
+        for (const d of devices) this._discovered.set(d.id, d);
+        debugLog(
+          `[DMK] getLiveDevices() resolved count=${devices.length} ids=[${devices.map((d) => d.id).join(",")}]`
+        );
+        resolve(devices);
+      };
+      const timer = setTimeout(() => finish(lastSeen), timeoutMs);
+      sub = this._dmk.listenToAvailableDevices({}).subscribe({
+        next: (devices) => {
+          lastSeen = devices;
+        },
+        error: (err) => {
+          debugError("[DMK] getLiveDevices() error:", err);
+          finish(lastSeen);
+        },
+        complete: () => finish(lastSeen)
+      });
+    });
+  }
   requestDevice() {
     if (this._discoverySub) {
       return Promise.resolve();
@@ -1117,11 +1726,33 @@ var LedgerDeviceManager = class {
     });
     return Promise.resolve();
   }
+  /** Lookup a previously-discovered device's display name. */
+  getDeviceName(deviceId) {
+    return this._discovered.get(deviceId)?.name;
+  }
+  /** Lookup minimal model/signal info from a previously-discovered device. */
+  getDiscoveredDeviceInfo(deviceId) {
+    const d = this._discovered.get(deviceId);
+    if (!d) return void 0;
+    return {
+      model: d.deviceModel?.model,
+      modelName: d.deviceModel?.name,
+      name: d.name,
+      rssi: d.rssi
+    };
+  }
+  hasDiscoveredDevice(deviceId) {
+    return this._discovered.has(deviceId);
+  }
   /** 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 err = new Error(
+        `Device "${deviceId}" not found in discovery cache. Call enumerate() or listen() first.`
+      );
+      err._tag = ERROR_TAG.DeviceNotInDiscoveryCache;
+      throw err;
     }
     const sessionId = await this._dmk.connect({ device });
     this._sessions.set(deviceId, sessionId);
@@ -1160,6 +1791,19 @@ var LedgerDeviceManager = class {
     this._sessionToDevice.clear();
     this._dmk.close();
   }
+  /**
+   * Tear down RxJS subscriptions and local state without closing the DMK.
+   * For light-reset paths that want to drop session state but keep the
+   * underlying transport alive for retry. Call this instead of orphaning
+   * the manager — bare null assignment leaks _listenSub / _discoverySub.
+   */
+  disposeKeepingDmk() {
+    this.stopListening();
+    this.stopDiscovery();
+    this._discovered.clear();
+    this._sessions.clear();
+    this._sessionToDevice.clear();
+  }
 };
 
 // src/signer/SignerManager.ts
@@ -1171,11 +1815,12 @@ import { hexToBytes } from "@onekeyfe/hwk-adapter-core";
 
 // src/signer/deviceActionToPromise.ts
 import { DeviceActionStatus } from "@ledgerhq/device-management-kit";
-var DEFAULT_TIMEOUT_MS = 3e4;
-function deviceActionToPromise(action, onInteraction, timeoutMs = DEFAULT_TIMEOUT_MS, onRegisterCanceller) {
+var IDLE_WATCHDOG_MS = 65e3;
+function deviceActionToPromise(action, onInteraction, timeoutMs = IDLE_WATCHDOG_MS, onRegisterCanceller) {
   return new Promise((resolve, reject) => {
     let settled = false;
     let lastStep;
+    const observedSteps = [];
     let sub;
     let timer = null;
     const cancelAction = () => {
@@ -1188,44 +1833,59 @@ function deviceActionToPromise(action, onInteraction, timeoutMs = DEFAULT_TIMEOU
       } catch {
       }
     };
-    const resetTimer = () => {
+    const armIdleWatchdog = () => {
       if (timer) clearTimeout(timer);
       if (timeoutMs > 0) {
         timer = setTimeout(() => {
           if (!settled) {
             settled = true;
             cancelAction();
-            reject(new Error("Device action timed out \u2014 device may be locked or disconnected"));
+            reject(
+              new Error(
+                "Ledger transport unresponsive: no DMK state change within the watchdog window. The device may have lost connection."
+              )
+            );
           }
         }, timeoutMs);
       }
     };
-    resetTimer();
+    armIdleWatchdog();
     if (onRegisterCanceller) {
-      onRegisterCanceller(() => {
-        if (settled) return;
+      onRegisterCanceller((reason) => {
+        if (settled) {
+          return;
+        }
         settled = true;
         if (timer) clearTimeout(timer);
         cancelAction();
-        reject(new Error("Device action cancelled"));
+        const err = new Error(reason?.message ?? "Device action cancelled");
+        if (reason?.code !== void 0) {
+          err.code = reason.code;
+        }
+        if (reason?.tag) {
+          Object.defineProperty(err, "_tag", {
+            value: reason.tag,
+            configurable: true,
+            enumerable: false,
+            writable: true
+          });
+        }
+        reject(err);
       });
     }
-    debugLog("[DMK-Observable] subscribing to action.observable...");
     sub = action.observable.subscribe({
       next: (state) => {
-        if (settled) return;
-        resetTimer();
+        if (settled) {
+          return;
+        }
+        armIdleWatchdog();
         const step = state?.intermediateValue?.step;
-        if (step) lastStep = step;
-        debugLog(
-          "[DMK-Observable] state:",
-          JSON.stringify({
-            status: state.status,
-            intermediateValue: state.status === DeviceActionStatus.Pending ? state.intermediateValue : void 0,
-            hasOutput: state.status === DeviceActionStatus.Completed,
-            hasError: state.status === DeviceActionStatus.Error
-          })
-        );
+        if (step) {
+          lastStep = step;
+          if (observedSteps[observedSteps.length - 1] !== step) {
+            observedSteps.push(step);
+          }
+        }
         if (state.status === DeviceActionStatus.Completed) {
           settled = true;
           if (timer) clearTimeout(timer);
@@ -1237,10 +1897,14 @@ function deviceActionToPromise(action, onInteraction, timeoutMs = DEFAULT_TIMEOU
           if (timer) clearTimeout(timer);
           onInteraction?.("interaction-complete");
           sub?.unsubscribe();
-          rejectWithLastStep(state.error, lastStep, reject);
+          rejectWithStepContext(state.error, lastStep, observedSteps, reject);
         } else if (state.status === DeviceActionStatus.Pending && onInteraction) {
           const interaction = state.intermediateValue?.requiredUserInteraction;
           if (interaction && interaction !== "none") {
+            if (interaction === "unlock-device" && timer) {
+              clearTimeout(timer);
+              timer = null;
+            }
             onInteraction(String(interaction));
           }
         }
@@ -1250,7 +1914,7 @@ function deviceActionToPromise(action, onInteraction, timeoutMs = DEFAULT_TIMEOU
           settled = true;
           if (timer) clearTimeout(timer);
           sub?.unsubscribe();
-          rejectWithLastStep(err, lastStep, reject);
+          rejectWithStepContext(err, lastStep, observedSteps, reject);
         }
       },
       complete: () => {
@@ -1263,15 +1927,25 @@ function deviceActionToPromise(action, onInteraction, timeoutMs = DEFAULT_TIMEOU
     });
   });
 }
-function rejectWithLastStep(err, lastStep, reject) {
-  if (err && typeof err === "object" && lastStep) {
+function rejectWithStepContext(err, lastStep, observedSteps, reject) {
+  if (err && typeof err === "object" && (lastStep || observedSteps.length > 0)) {
     try {
-      Object.defineProperty(err, "_lastStep", {
-        value: lastStep,
-        configurable: true,
-        enumerable: false,
-        writable: true
-      });
+      if (lastStep) {
+        Object.defineProperty(err, "_lastStep", {
+          value: lastStep,
+          configurable: true,
+          enumerable: false,
+          writable: true
+        });
+      }
+      if (observedSteps.length > 0) {
+        Object.defineProperty(err, "_deviceActionSteps", {
+          value: [...observedSteps],
+          configurable: true,
+          enumerable: false,
+          writable: true
+        });
+      }
     } catch {
     }
   }
@@ -1337,7 +2011,8 @@ var SignerManager = class _SignerManager {
   async getOrCreate(sessionId) {
     debugLog("[DMK] SignerManager.getOrCreate:", { sessionId });
     const builder = await this._builderFn({ dmk: this._dmk, sessionId });
-    return new SignerEth(builder.build());
+    const builderWithContext = builder.withContextModule ? builder.withContextModule(_SignerManager._createContextModule()) : builder;
+    return new SignerEth(builderWithContext.build());
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
   invalidate(_sessionId) {
@@ -1346,10 +2021,24 @@ var SignerManager = class _SignerManager {
   clearAll() {
   }
   static _defaultBuilder() {
-    return (args) => {
-      const contextModule = new ContextModuleBuilder({}).removeDefaultLoaders().build();
-      return new SignerEthBuilder(args).withContextModule(contextModule);
+    return (args) => new SignerEthBuilder(args);
+  }
+  static _createContextModule() {
+    const contextModule = new ContextModuleBuilder({}).removeDefaultLoaders().build();
+    return _SignerManager.wrapBlindSigningReportNonBlocking(contextModule);
+  }
+  static wrapBlindSigningReportNonBlocking(contextModule) {
+    const report = contextModule.report.bind(contextModule);
+    contextModule.report = async (params) => {
+      try {
+        void report(params).catch((err) => {
+          debugLog("[DMK] ContextModule.report failed:", err);
+        });
+      } catch (err) {
+        debugLog("[DMK] ContextModule.report failed:", err);
+      }
     };
+    return contextModule;
   }
 };
 
@@ -1357,20 +2046,20 @@ var SignerManager = class _SignerManager {
 import { HardwareErrorCode as HardwareErrorCode3, padHex64, stripHex } from "@onekeyfe/hwk-adapter-core";
 
 // src/connector/chains/utils.ts
-import { EConnectorInteraction } from "@onekeyfe/hwk-adapter-core";
+import { EConnectorInteraction as EConnectorInteraction2 } from "@onekeyfe/hwk-adapter-core";
 function normalizePath(path) {
   return path.startsWith("m/") ? path.slice(2) : path;
 }
 function collapseSignerInteraction(interaction) {
   switch (interaction) {
     case "confirm-open-app":
-      return EConnectorInteraction.ConfirmOpenApp;
+      return EConnectorInteraction2.ConfirmOpenApp;
     case "unlock-device":
-      return EConnectorInteraction.UnlockDevice;
+      return EConnectorInteraction2.UnlockDevice;
     case "interaction-complete":
-      return EConnectorInteraction.InteractionComplete;
+      return EConnectorInteraction2.InteractionComplete;
     default:
-      return EConnectorInteraction.ConfirmOnDevice;
+      return EConnectorInteraction2.ConfirmOnDevice;
   }
 }
 
@@ -1459,6 +2148,7 @@ async function _getEthSigner(ctx, sessionId) {
   const signerManager = await ctx.getSignerManager();
   const signer = await signerManager.getOrCreate(sessionId);
   signer.onInteraction = (interaction) => {
+    debugLog("[LedgerConnector] evm.onInteraction:", interaction);
     ctx.emit("ui-event", {
       type: collapseSignerInteraction(interaction),
       payload: { sessionId }
@@ -1659,6 +2349,7 @@ async function btcSignTransaction(ctx, sessionId, params) {
     const path = normalizePath(params.path || "84'/0'/0'");
     const purpose = path.split("/")[0]?.replace(/'/g, "");
     const template = _purposeToTemplate(purpose, DefaultDescriptorTemplate);
+    debugLog("[LedgerConnector] btcSignTransaction wallet:", { path, purpose, template });
     const wallet = new DefaultWallet(path, template);
     const signedTxHex = await btcSigner.signTransaction(wallet, params.psbt);
     return { serializedTx: stripHex2(signedTxHex) };
@@ -1683,8 +2374,10 @@ async function btcSignPsbt(ctx, sessionId, params) {
     const path = normalizePath(params.path || "84'/0'/0'");
     const purpose = path.split("/")[0]?.replace(/'/g, "");
     const template = _purposeToTemplate(purpose, DefaultDescriptorTemplate);
+    debugLog("[LedgerConnector] btcSignPsbt wallet:", { path, purpose, template });
     const wallet = new DefaultWallet(path, template);
     const signatures = await btcSigner.signPsbt(wallet, params.psbt);
+    debugLog("[LedgerConnector] btcSignPsbt signatures received:", signatures.length);
     const signedPsbtHex = _applySignaturesToPsbt(params.psbt, signatures);
     return { signedPsbt: signedPsbtHex };
   } catch (err) {
@@ -1731,6 +2424,7 @@ async function _createBtcSigner(ctx, sessionId) {
   const sdkSigner = new SignerBtcBuilder({ dmk, sessionId }).build();
   const signer = new SignerBtc(sdkSigner);
   signer.onInteraction = (interaction) => {
+    debugLog("[LedgerConnector] btc.onInteraction:", interaction);
     ctx.emit("ui-event", {
       type: collapseSignerInteraction(interaction),
       payload: { sessionId }
@@ -1901,6 +2595,7 @@ async function _createSolSigner(ctx, sessionId) {
   const sdkSigner = new SignerSolanaBuilder({ dmk, sessionId }).withContextModule(contextModule).build();
   const signer = new SignerSol(sdkSigner);
   signer.onInteraction = (interaction) => {
+    debugLog("[LedgerConnector] sol.onInteraction:", interaction);
     ctx.emit("ui-event", {
       type: collapseSignerInteraction(interaction),
       payload: { sessionId }
@@ -1913,11 +2608,11 @@ async function _createSolSigner(ctx, sessionId) {
 }
 
 // src/connector/chains/tron.ts
-import { EConnectorInteraction as EConnectorInteraction3, HardwareErrorCode as HardwareErrorCode5 } from "@onekeyfe/hwk-adapter-core";
+import { HardwareErrorCode as HardwareErrorCode6 } from "@onekeyfe/hwk-adapter-core";
 import Trx from "@ledgerhq/hw-app-trx";
 
-// src/connector/chains/legacyAppRetry.ts
-import { EConnectorInteraction as EConnectorInteraction2 } from "@onekeyfe/hwk-adapter-core";
+// src/connector/chains/legacyChainCall.ts
+import { EConnectorInteraction as EConnectorInteraction3 } from "@onekeyfe/hwk-adapter-core";
 
 // src/app/AppManager.ts
 import {
@@ -1926,6 +2621,7 @@ import {
   OpenAppCommand,
   isSuccessCommandResult
 } from "@ledgerhq/device-management-kit";
+import { HardwareErrorCode as HardwareErrorCode5 } from "@onekeyfe/hwk-adapter-core";
 var APP_NAME_MAP = {
   ETH: "Ethereum",
   BTC: "Bitcoin",
@@ -1961,9 +2657,16 @@ var AppManager = class {
    * 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.
+   * @param onConfirmOnDevice Called BEFORE OpenAppCommand is issued — the
+   *   device is about to display "Open <app>" on screen and wait for the
+   *   user's button press. UI consumers should show their "open app" prompt
+   *   in response. NOT called when the target app is already open (no user
+   *   interaction needed in that case).
+   *
+   * Important: OpenAppCommand is blocking. It does not resolve until the user
+   *   has physically confirmed on the device, so anything that runs AFTER
+   *   `await this._openApp(...)` lands AFTER the prompt is already gone.
+   *   Hence the callback must fire BEFORE that await.
    */
   async ensureAppOpen(sessionId, targetAppName, onConfirmOnDevice) {
     const currentApp = await this._getCurrentApp(sessionId);
@@ -1974,8 +2677,8 @@ var AppManager = class {
       await this._closeCurrentApp(sessionId);
       await this._waitForApp(sessionId, DASHBOARD_APP_NAME);
     }
-    await this._openApp(sessionId, targetAppName);
     onConfirmOnDevice?.();
+    await this._openApp(sessionId, targetAppName);
     await this._waitForApp(sessionId, targetAppName);
   }
   // ---------------------------------------------------------------------------
@@ -1987,9 +2690,34 @@ var AppManager = class {
       command: new GetAppAndVersionCommand()
     });
     if (isSuccessCommandResult(result)) {
+      debugLog("[AppManager] currentApp:", result.data.name);
       return result.data.name;
     }
-    throw new Error("Failed to get current app from device");
+    const errResult = result;
+    const dmkErr = errResult.error ?? {};
+    const original = dmkErr.originalError;
+    debugLog(
+      "[AppManager] _getCurrentApp failed sessionId=",
+      sessionId,
+      "tag=",
+      dmkErr._tag,
+      "errorCode=",
+      dmkErr.errorCode,
+      "message=",
+      dmkErr.message,
+      "originalErrorMessage=",
+      original?.message ?? String(original ?? "")
+    );
+    throw Object.assign(
+      new Error(
+        dmkErr.message ?? "Failed to get current app from device"
+      ),
+      {
+        _tag: dmkErr._tag,
+        errorCode: dmkErr.errorCode,
+        originalError: original
+      }
+    );
   }
   async _openApp(sessionId, appName) {
     const result = await this._dmk.sendCommand({
@@ -1998,8 +2726,11 @@ var AppManager = class {
     });
     if (!isSuccessCommandResult(result)) {
       const { statusCode } = result;
+      const hasStatusCode2 = statusCode != null && statusCode !== "";
+      debugLog("[AppManager] openApp failed:", appName, "statusCode:", statusCode);
       throw Object.assign(new Error(`Failed to open "${appName}"`), {
-        _tag: "OpenAppCommandError",
+        _tag: ERROR_TAG.OpenAppCommand,
+        code: hasStatusCode2 ? void 0 : HardwareErrorCode5.AppNotInstalled,
         errorCode: String(statusCode ?? ""),
         statusCode,
         appName
@@ -2007,6 +2738,7 @@ var AppManager = class {
     }
   }
   async _closeCurrentApp(sessionId) {
+    debugLog("[AppManager] closeCurrentApp");
     await this._dmk.sendCommand({
       sessionId,
       command: new CloseAppCommand()
@@ -2017,15 +2749,23 @@ var AppManager = class {
    * or throw after `_maxRetries` attempts.
    */
   async _waitForApp(sessionId, expectedAppName) {
+    let lastSeen = "";
     for (let i = 0; i < this._maxRetries; i++) {
       await this._wait();
       const current = await this._getCurrentApp(sessionId);
+      lastSeen = current;
       if (current === expectedAppName) {
         return;
       }
     }
+    debugLog(
+      "[AppManager] waitForApp exhausted: expected=",
+      expectedAppName,
+      "lastSeen=",
+      lastSeen
+    );
     throw new Error(
-      `Ledger: failed to open "${expectedAppName}" after ${this._maxRetries} retries`
+      `Ledger: failed to open "${expectedAppName}" after ${this._maxRetries} retries (last seen: ${lastSeen})`
     );
   }
   _isDashboard(appName) {
@@ -2036,46 +2776,92 @@ var AppManager = class {
   }
 };
 
-// src/connector/chains/legacyAppRetry.ts
+// src/connector/chains/legacyChainCall.ts
 function isLegacyWrongAppError(err, _appName) {
   return isWrongAppError(err);
 }
-async function withLegacyAppRetry(ctx, sessionId, appName, action) {
-  try {
-    return await action(sessionId);
-  } catch (err) {
+async function withLegacyChainCall(ctx, sessionId, options, action) {
+  const { appName, needsConfirmation } = options;
+  let openAppPromptShown = false;
+  const onAppOpenPrompt = () => {
+    openAppPromptShown = true;
     ctx.emit("ui-event", {
-      type: EConnectorInteraction2.InteractionComplete,
+      type: EConnectorInteraction3.ConfirmOpenApp,
       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: EConnectorInteraction2.ConfirmOpenApp,
-            payload: { sessionId }
-          });
-        });
-      } catch (switchErr) {
-        ctx.emit("ui-event", {
-          type: EConnectorInteraction2.InteractionComplete,
-          payload: { sessionId }
-        });
-        throw ctx.wrapError(switchErr);
-      }
-      ctx.clearAllSigners();
+  };
+  const closeOpenAppUiIfShown = () => {
+    if (openAppPromptShown) {
+      ctx.emit("ui-event", {
+        type: EConnectorInteraction3.InteractionComplete,
+        payload: { sessionId }
+      });
+      openAppPromptShown = false;
+    }
+  };
+  try {
+    await _ensureAppOpen(ctx, sessionId, appName, onAppOpenPrompt);
+  } catch (err) {
+    debugLog(
+      "[LegacyChainCall] pre-flight ensureAppOpen failed:",
+      appName,
+      err?.message
+    );
+    closeOpenAppUiIfShown();
+    throw ctx.wrapError(err, { defaultAppName: appName });
+  }
+  const runOnce = async () => {
+    let confirmEmitted = false;
+    if (needsConfirmation) {
       ctx.emit("ui-event", {
-        type: EConnectorInteraction2.InteractionComplete,
+        type: EConnectorInteraction3.ConfirmOnDevice,
         payload: { sessionId }
       });
+      confirmEmitted = true;
+    }
+    try {
       return await action(sessionId);
+    } finally {
+      if (confirmEmitted || openAppPromptShown) {
+        ctx.emit("ui-event", {
+          type: EConnectorInteraction3.InteractionComplete,
+          payload: { sessionId }
+        });
+        openAppPromptShown = false;
+      }
     }
-    ctx.invalidateSession(sessionId);
-    throw ctx.wrapError(err);
+  };
+  try {
+    return await runOnce();
+  } catch (err) {
+    if (!isLegacyWrongAppError(err, appName)) {
+      debugLog("[LegacyChainCall] non-wrong-app failure:", appName, err?.message);
+      ctx.invalidateSession(sessionId);
+      throw ctx.wrapError(err, { defaultAppName: appName });
+    }
+    debugLog("[LegacyChainCall] wrong-app detected, retrying:", appName);
+    try {
+      await _ensureAppOpen(ctx, sessionId, appName, onAppOpenPrompt);
+    } catch (switchErr) {
+      debugLog(
+        "[LegacyChainCall] retry ensureAppOpen failed:",
+        appName,
+        switchErr?.message
+      );
+      closeOpenAppUiIfShown();
+      throw ctx.wrapError(switchErr, { defaultAppName: appName });
+    }
+    ctx.clearAllSigners();
+    const result = await runOnce();
+    debugLog("[LegacyChainCall] retry succeeded:", appName);
+    return result;
   }
 }
+async function _ensureAppOpen(ctx, sessionId, appName, onPrompt) {
+  const dmk = await ctx.getOrCreateDmk();
+  const appManager = new AppManager(dmk);
+  await appManager.ensureAppOpen(sessionId, appName, onPrompt);
+}
 
 // src/transport/DmkTransport.ts
 import Transport from "@ledgerhq/hw-transport";
@@ -2105,83 +2891,75 @@ var DmkTransport = class extends Transport {
 // src/connector/chains/tron.ts
 async function tronGetAddress(ctx, sessionId, params) {
   const path = normalizePath(params.path);
-  await _ensureTronAppOpen(ctx, sessionId);
-  return withLegacyAppRetry(ctx, sessionId, "Tron", async (sid) => {
-    const trx = await _createTrx(ctx, sid);
-    if (params.showOnDevice) {
-      ctx.emit("ui-event", {
-        type: EConnectorInteraction3.ConfirmOnDevice,
-        payload: { sessionId: sid }
-      });
+  const showOnDevice = params.showOnDevice ?? false;
+  return withLegacyChainCall(
+    ctx,
+    sessionId,
+    {
+      appName: "Tron",
+      // Only show "confirm on device" UI when the device is actually going
+      // to display the address for the user to verify.
+      needsConfirmation: showOnDevice
+    },
+    async (sid) => {
+      const trx = await _createTrx(ctx, sid);
+      const result = await trx.getAddress(path, showOnDevice);
+      return { address: result.address, publicKey: result.publicKey, path: params.path };
     }
-    const result = await trx.getAddress(path, params.showOnDevice ?? false);
-    ctx.emit("ui-event", {
-      type: EConnectorInteraction3.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: HardwareErrorCode5.InvalidParams }
+      { code: HardwareErrorCode6.InvalidParams }
     );
   }
   const path = normalizePath(params.path);
-  await _ensureTronAppOpen(ctx, sessionId);
-  return withLegacyAppRetry(ctx, sessionId, "Tron", async (sid) => {
-    const trx = await _createTrx(ctx, sid);
-    ctx.emit("ui-event", {
-      type: EConnectorInteraction3.ConfirmOnDevice,
-      payload: { sessionId: sid }
-    });
-    const signature = await trx.signTransaction(
-      path,
-      params.rawTxHex,
-      params.tokenSignatures ?? []
-    );
-    ctx.emit("ui-event", {
-      type: EConnectorInteraction3.InteractionComplete,
-      payload: { sessionId: sid }
-    });
-    return { signature };
-  });
+  return withLegacyChainCall(
+    ctx,
+    sessionId,
+    { appName: "Tron", needsConfirmation: true },
+    async (sid) => {
+      const trx = await _createTrx(ctx, sid);
+      const signature = await trx.signTransaction(
+        path,
+        params.rawTxHex,
+        params.tokenSignatures ?? []
+      );
+      return { signature };
+    }
+  );
 }
 async function tronSignMessage(ctx, sessionId, params) {
   const path = normalizePath(params.path);
-  await _ensureTronAppOpen(ctx, sessionId);
-  return withLegacyAppRetry(ctx, sessionId, "Tron", async (sid) => {
-    const trx = await _createTrx(ctx, sid);
-    ctx.emit("ui-event", {
-      type: EConnectorInteraction3.ConfirmOnDevice,
-      payload: { sessionId: sid }
-    });
-    const signature = await trx.signPersonalMessage(path, params.messageHex);
-    ctx.emit("ui-event", {
-      type: EConnectorInteraction3.InteractionComplete,
-      payload: { sessionId: sid }
-    });
-    return { signature };
-  });
+  return withLegacyChainCall(
+    ctx,
+    sessionId,
+    { appName: "Tron", needsConfirmation: true },
+    async (sid) => {
+      const trx = await _createTrx(ctx, sid);
+      const signature = await trx.signPersonalMessage(path, params.messageHex);
+      return { signature };
+    }
+  );
 }
 async function _createTrx(ctx, sessionId) {
   const dmk = await ctx.getOrCreateDmk();
   return new Trx(new DmkTransport(dmk, sessionId));
 }
-async function _ensureTronAppOpen(ctx, sessionId) {
-  const dmk = await ctx.getOrCreateDmk();
-  const appManager = new AppManager(dmk);
-  await appManager.ensureAppOpen(sessionId, "Tron", () => {
-    ctx.emit("ui-event", {
-      type: EConnectorInteraction3.ConfirmOpenApp,
-      payload: { sessionId }
-    });
-  });
-}
 
 // src/connector/LedgerConnectorBase.ts
+var METHOD_PREFIX_TO_APP_NAME = {
+  evm: "Ethereum",
+  btc: "Bitcoin",
+  sol: "Solana",
+  tron: "Tron"
+};
+var HARDWARE_ERROR_CODE_VALUES = new Set(
+  Object.values(HardwareErrorCode7).filter((value) => typeof value === "number")
+);
+var BLE_CONNECT_SCAN_TIMEOUT_MS = 1500;
 async function defaultLedgerKitImporter(pkg) {
   switch (pkg) {
     case "@ledgerhq/device-management-kit":
@@ -2205,16 +2983,6 @@ var LedgerConnectorBase = class {
     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();
-    // ---------------------------------------------------------------------------
     // Per-session DeviceAction cancellers
     //
     // Each chain handler registers its active DeviceAction's canceller via
@@ -2223,17 +2991,30 @@ var LedgerConnectorBase = class {
     // unsubscribes the observable and releases DMK's IntentQueue slot.
     // ---------------------------------------------------------------------------
     this._cancellers = /* @__PURE__ */ new Map();
+    // ---------------------------------------------------------------------------
+    // Per-session DMK state subscriptions
+    //
+    // DMK only emits `device-disconnect` on the connector when `disconnect()`
+    // is called explicitly. To pick up autonomous disconnects (USB unplug,
+    // BLE drop, device sleep, DMK transport reset) we subscribe to
+    // `_dmk.getDeviceSessionState({sessionId})` per active session and emit
+    // `device-disconnect` ourselves the moment DMK reports the device went
+    // to NOT_CONNECTED. The subscription is torn down on disconnect /
+    // reset / observable completion to avoid leaks.
+    // ---------------------------------------------------------------------------
+    this._sessionStateSubs = /* @__PURE__ */ new Map();
     this._createTransport = createTransport;
     this.connectionType = options?.connectionType ?? "usb";
     this._providedDmk = options?.dmk;
     this._importLedgerKit = options?.importLedgerKit ?? defaultLedgerKitImporter;
+    this._requirePreFlightScan = options?.requirePreFlightScan ?? false;
     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),
+      wrapError: (err, opts) => this._wrapError(err, opts),
       getOrCreateDmk: () => this._getOrCreateDmk(),
       getDeviceManager: () => this._getDeviceManager(),
       getSignerManager: () => this._getSignerManager(),
@@ -2244,38 +3025,23 @@ var LedgerConnectorBase = class {
       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).
+   * Override in subclasses only when the public connectId differs from the transport path.
    */
   _resolveConnectId(descriptor) {
     return descriptor.path;
   }
-  // ---------------------------------------------------------------------------
-  // IConnector -- Device discovery
-  // ---------------------------------------------------------------------------
-  async searchDevices() {
-    const dm = await this._getDeviceManager();
+  /**
+   * Authoritative discovery for this transport. Default = enumerate snapshot
+   * (USB/HID). BLE overrides to drive from a live scan window since DMK's
+   * enumerate() cache survives peripherals going offline.
+   */
+  async _discoverDescriptors(dm) {
     let descriptors = await dm.enumerate();
     if (descriptors.length === 0) {
       try {
@@ -2284,137 +3050,331 @@ var LedgerConnectorBase = class {
       }
       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 descriptors;
+  }
+  _assertSingleUsbDescriptor(descriptors) {
+    if (isLedgerBleConnectionType(this.connectionType) || descriptors.length <= 1) {
+      return;
+    }
+    debugLog(
+      `[DMK] Multiple Ledger USB devices found (${descriptors.length}); refusing to choose by ephemeral path. paths=[${descriptors.map((d) => d.path).join(",")}]`
+    );
+    throw createMultipleUsbLedgerDevicesError();
+  }
+  // ---------------------------------------------------------------------------
+  // IConnector -- Device discovery
+  // ---------------------------------------------------------------------------
+  async searchDevices() {
+    const dm = await this._getDeviceManager();
+    const descriptors = await this._discoverDescriptors(dm);
+    this._assertSingleUsbDescriptor(descriptors);
+    const resolvedDescriptors = descriptors.map((d) => ({
+      descriptor: d,
+      connectId: this._resolveConnectId(d)
+    }));
+    const result = resolvedDescriptors.map(({ descriptor: d, connectId }) => ({
+      connectId,
+      deviceId: d.path,
+      name: d.name || d.type || "Ledger",
+      model: d.type,
+      modelName: d.modelName,
+      rssi: d.rssi,
+      isConnectable: d.isConnectable,
+      serialNumber: d.serialNumber
+    }));
+    debugLog(
+      `[DMK] connector.searchDevices() return count=${result.length} ids=[${result.map((r) => r.connectId).join(",")}] paths=[${result.map((r) => r.deviceId).join(",")}]`
+    );
     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;
+    const callerSuppliedConnectId = Boolean(deviceId);
+    let targetPath = deviceId;
+    if (callerSuppliedConnectId && !isLedgerBleConnectionType(this.connectionType)) {
+      const dm = await this._getDeviceManager();
+      this._assertSingleUsbDescriptor(await this._discoverDescriptors(dm));
+    }
     if (!targetPath) {
-      const descriptors = await dm.enumerate();
-      if (descriptors.length === 0) {
+      const discovered = await this.searchDevices();
+      if (discovered.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.`
+          `No Ledger device found. Make sure the device is connected${isLedgerBleConnectionType(this.connectionType) ? " nearby with Bluetooth enabled" : " via USB"} and unlocked.`
         );
       }
-      targetPath = descriptors[0].path;
+      targetPath = discovered[0].deviceId;
     }
-    const externalConnectId = this._getConnectIdForPath(targetPath);
+    const externalConnectId = targetPath;
+    const HANG_CEILING_MS = 5 * 6e4;
+    const dmConnectWithObserve = async (dm, path) => {
+      if (!isLedgerBleConnectionType(this.connectionType)) return dm.connect(path);
+      let timeoutId;
+      let timedOut = false;
+      const connectPromise = dm.connect(path);
+      const hangPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          timedOut = true;
+          const err = new Error(
+            `Ledger BLE connect did not return within ${HANG_CEILING_MS / 6e4}min \u2014 DMK hang fallback.`
+          );
+          err._tag = ERROR_TAG.BlePairingTimeout;
+          err.code = HardwareErrorCode7.BlePairingTimeout;
+          reject(err);
+        }, HANG_CEILING_MS);
+      });
+      try {
+        return await Promise.race([connectPromise, hangPromise]);
+      } catch (err) {
+        const e = err;
+        debugLog("[DMK] dm.connect rejected \u2014 observed:", {
+          _tag: e?._tag,
+          message: e?.message,
+          errorCode: e?.errorCode,
+          statusCode: e?.statusCode,
+          originalTag: e?.originalError?._tag,
+          originalMessage: e?.originalError?.message
+        });
+        if (timedOut) {
+          void connectPromise.then(
+            (sessionId) => dm.disconnect(sessionId).catch(() => void 0),
+            () => void 0
+          );
+        }
+        throw err;
+      } finally {
+        if (timeoutId) clearTimeout(timeoutId);
+      }
+    };
+    const isBleDirectConnect = isLedgerBleConnectionType(this.connectionType) && callerSuppliedConnectId;
+    const throwNotAdvertising = () => {
+      const err = new Error(
+        "Ledger device is not currently advertising. Wake up and unlock the device, keep it nearby, then try again."
+      );
+      err._tag = ERROR_TAG.DeviceNotAdvertising;
+      err.code = HardwareErrorCode7.DeviceNotFound;
+      throw err;
+    };
     const doConnect = async (path) => {
-      const sessionId = await dm.connect(path);
+      const dm = await this._getDeviceManager();
+      if (isBleDirectConnect && !dm.hasDiscoveredDevice(path)) {
+        const live = await dm.getLiveDevices(BLE_CONNECT_SCAN_TIMEOUT_MS);
+        if (this._requirePreFlightScan && !live.some((d) => d.id === path)) {
+          throwNotAdvertising();
+        }
+      }
+      let sessionId;
+      try {
+        sessionId = await dmConnectWithObserve(dm, path);
+      } catch (err) {
+        if (isBleDirectConnect && err?._tag === ERROR_TAG.DeviceNotInDiscoveryCache) {
+          throwNotAdvertising();
+        }
+        throw err;
+      }
+      try {
+        this._watchSessionState(sessionId, externalConnectId);
+      } catch (subErr) {
+        debugLog("[DMK] state subscription failed during connect; disconnecting session:", subErr);
+        try {
+          await dm.disconnect(sessionId);
+        } catch {
+        }
+        throw subErr;
+      }
+      const info = dm.getDiscoveredDeviceInfo(path);
       const session = {
         sessionId,
         deviceInfo: {
           vendor: "ledger",
-          model: "unknown",
+          model: info?.model ?? "unknown",
+          modelName: info?.modelName,
           firmwareVersion: "unknown",
           deviceId: path,
           connectId: externalConnectId,
           connectionType: this.connectionType,
+          rssi: info?.rssi,
           capabilities: { persistentDeviceIdentity: false }
         }
       };
+      const name = dm.getDeviceName(path) ?? "Ledger";
       this._emit("device-connect", {
-        device: {
-          connectId: externalConnectId,
-          deviceId: path,
-          name: "Ledger"
-        }
+        device: { connectId: externalConnectId, deviceId: path, name }
       });
       return session;
     };
     try {
       return await doConnect(targetPath);
-    } catch {
+    } catch (err) {
       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.`
-          );
+      if (isLedgerBleConnectionType(this.connectionType)) {
+        const tag = err?._tag;
+        if (isKnownConnectionTag(tag)) {
+          throw err;
         }
-        return doConnect(descriptors[0].path);
+        const wrapped = new Error(
+          "Ledger Bluetooth pairing failed. Make sure the device is unlocked and nearby, then try again."
+        );
+        wrapped._tag = ERROR_TAG.BleGattBondingFailed;
+        wrapped.code = HardwareErrorCode7.BlePairingTimeout;
+        wrapped.originalError = err;
+        throw wrapped;
+      }
+      if (err && typeof err === "object" && err._tag) {
+        const taggedError = err instanceof Error ? err : Object.assign(
+          new Error(err.message ?? "Ledger device error"),
+          err
+        );
+        throw taggedError;
       }
-      return doConnect(retryPath);
+      throw new Error("Ledger device appears unplugged. Plug in the device and try again.");
     }
   }
   async disconnect(sessionId) {
     if (!this._deviceManager) return;
     const deviceId = this._deviceManager.getDeviceId(sessionId);
     this._signerManager?.invalidate(sessionId);
+    this._unwatchSessionState(sessionId);
     await this._deviceManager.disconnect(sessionId);
     if (deviceId) {
       this._emit("device-disconnect", { connectId: deviceId });
     }
   }
+  /**
+   * Subscribe to DMK's per-session state observable so that any autonomous
+   * disconnect (USB unplug, BLE drop, device sleep, transport reset) is
+   * surfaced as a `device-disconnect` event — without this, the upstream
+   * `LedgerAdapter._sessions` map would hold a dead session entry until
+   * the next call hit `DeviceSessionNotFound`.
+   *
+   * Subscribe failure is fatal — see the inline note at the subscribe call.
+   */
+  _watchSessionState(sessionId, externalConnectId) {
+    const dmk = this._dmk;
+    if (!dmk) return;
+    const previous = this._sessionStateSubs.get(sessionId);
+    if (previous) {
+      try {
+        previous.unsubscribe();
+      } catch {
+      }
+    }
+    const sub = dmk.getDeviceSessionState({ sessionId }).subscribe({
+      next: (state) => {
+        if (state?.deviceStatus === "NOT CONNECTED") {
+          this._handleAutonomousDisconnect(sessionId, externalConnectId);
+        }
+      },
+      error: () => {
+        this._handleAutonomousDisconnect(sessionId, externalConnectId);
+      },
+      complete: () => {
+        this._handleAutonomousDisconnect(sessionId, externalConnectId);
+      }
+    });
+    this._sessionStateSubs.set(sessionId, sub);
+  }
+  _unwatchSessionState(sessionId) {
+    const sub = this._sessionStateSubs.get(sessionId);
+    if (!sub) return;
+    try {
+      sub.unsubscribe();
+    } catch {
+    }
+    this._sessionStateSubs.delete(sessionId);
+  }
+  _handleAutonomousDisconnect(sessionId, externalConnectId) {
+    if (!this._sessionStateSubs.has(sessionId)) return;
+    debugLog(
+      "[DMK] autonomous disconnect detected \u2014 sessionId:",
+      sessionId,
+      "connectId:",
+      externalConnectId
+    );
+    this._unwatchSessionState(sessionId);
+    this._signerManager?.invalidate(sessionId);
+    this._cancellers.get(sessionId)?.({
+      code: HardwareErrorCode7.DeviceDisconnected,
+      tag: "DeviceDisconnected",
+      message: "Device disconnected"
+    });
+    this._cancellers.delete(sessionId);
+    this._emit("device-disconnect", { connectId: externalConnectId });
+  }
   // ---------------------------------------------------------------------------
   // IConnector -- Method dispatch
   // ---------------------------------------------------------------------------
   async call(sessionId, method, params) {
     debugLog("[DMK] call:", method, JSON.stringify(params));
+    try {
+      return await this._dispatch(sessionId, method, params);
+    } catch (err) {
+      if (isAppStuckByApdu(err)) {
+        throw Object.assign(new Error("Ledger app is unresponsive"), {
+          code: HardwareErrorCode7.DeviceAppStuck,
+          _tag: ERROR_TAG.DeviceAppStuck,
+          originalError: err
+        });
+      }
+      if (isTransportStuck(err)) {
+        throw Object.assign(new Error("Device communication interrupted, please retry"), {
+          code: HardwareErrorCode7.TransportError,
+          _tag: ERROR_TAG.DeviceTransportStuck,
+          originalError: err
+        });
+      }
+      throw err;
+    }
+  }
+  async _dispatch(sessionId, method, params) {
+    const ctx = this._ctxForMethod(method);
     switch (method) {
       // EVM
       case "evmGetAddress":
-        return evmGetAddress(this._ctx, sessionId, params);
+        return evmGetAddress(ctx, sessionId, params);
       case "evmSignTransaction":
-        return evmSignTransaction(this._ctx, sessionId, params);
+        return evmSignTransaction(ctx, sessionId, params);
       case "evmSignMessage":
-        return evmSignMessage(this._ctx, sessionId, params);
+        return evmSignMessage(ctx, sessionId, params);
       case "evmSignTypedData":
-        return evmSignTypedData(this._ctx, sessionId, params);
+        return evmSignTypedData(ctx, sessionId, params);
       // BTC
       case "btcGetAddress":
-        return btcGetAddress(this._ctx, sessionId, params);
+        return btcGetAddress(ctx, sessionId, params);
       case "btcGetPublicKey":
-        return btcGetPublicKey(this._ctx, sessionId, params);
+        return btcGetPublicKey(ctx, sessionId, params);
       case "btcSignTransaction":
-        return btcSignTransaction(this._ctx, sessionId, params);
+        return btcSignTransaction(ctx, sessionId, params);
       case "btcSignPsbt":
-        return btcSignPsbt(this._ctx, sessionId, params);
+        return btcSignPsbt(ctx, sessionId, params);
       case "btcSignMessage":
-        return btcSignMessage(this._ctx, sessionId, params);
+        return btcSignMessage(ctx, sessionId, params);
       case "btcGetMasterFingerprint":
         return btcGetMasterFingerprint(
-          this._ctx,
+          ctx,
           sessionId,
           params
         );
       // SOL
       case "solGetAddress":
-        return solGetAddress(this._ctx, sessionId, params);
+        return solGetAddress(ctx, sessionId, params);
       case "solSignTransaction":
-        return solSignTransaction(this._ctx, sessionId, params);
+        return solSignTransaction(ctx, sessionId, params);
       case "solSignMessage":
-        return solSignMessage(this._ctx, sessionId, params);
+        return solSignMessage(ctx, sessionId, params);
       // TRON
       case "tronGetAddress":
-        return tronGetAddress(this._ctx, sessionId, params);
+        return tronGetAddress(ctx, sessionId, params);
       case "tronSignTransaction":
-        return tronSignTransaction(this._ctx, sessionId, params);
+        return tronSignTransaction(ctx, sessionId, params);
       case "tronSignMessage": {
         const p = params;
         const internalParams = {
           path: p.path,
           messageHex: p.messageHex
         };
-        return tronSignMessage(this._ctx, sessionId, internalParams);
+        return tronSignMessage(ctx, sessionId, internalParams);
       }
       default:
         throw new Error(`LedgerConnector: unknown method "${method}"`);
@@ -2507,14 +3467,13 @@ var LedgerConnectorBase = class {
   }
   /**
    * 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.
+   * 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;
+    const connectId = oldDeviceId;
     this._signerManager?.invalidate(oldSessionId);
     if (connectId) {
       this._emit("device-connect", {
@@ -2527,13 +3486,18 @@ var LedgerConnectorBase = class {
     }
   }
   /**
-   * Light reset: clear signer/session state but keep DMK, BLE scan, and ID mapping alive.
+   * Light reset: clear signer/session state but keep DMK alive.
    * Used by connect() retry — we want to re-discover with the same transport.
+   *
+   * Note: drops the device manager but tears down its RxJS subs first via
+   * disposeKeepingDmk(). Bare null-assignment would leak _listenSub /
+   * _discoverySub and double-scan after the next _initManagers().
    */
   _resetSignersAndSessions() {
     debugLog("[DMK] _resetSignersAndSessions called");
     this._signerManager?.clearAll();
     this._signerManager = null;
+    this._deviceManager?.disposeKeepingDmk();
     this._deviceManager = null;
   }
   _resetAll() {
@@ -2545,13 +3509,18 @@ var LedgerConnectorBase = class {
       }
     }
     this._cancellers.clear();
+    for (const sub of this._sessionStateSubs.values()) {
+      try {
+        sub.unsubscribe();
+      } catch {
+      }
+    }
+    this._sessionStateSubs.clear();
     this._signerManager?.clearAll();
     this._deviceManager?.dispose();
     this._deviceManager = null;
     this._signerManager = null;
     this._dmk = null;
-    this._connectIdToPath.clear();
-    this._pathToConnectId.clear();
   }
   // ---------------------------------------------------------------------------
   // Private -- Events
@@ -2570,16 +3539,36 @@ var LedgerConnectorBase = class {
   // ---------------------------------------------------------------------------
   // Private -- Error handling
   // ---------------------------------------------------------------------------
-  _wrapError(err) {
-    const mapped = mapLedgerError(err);
-    const error = new Error(mapped.message);
+  /**
+   * Return a per-call ctx with the chain's Ledger app name pre-bound to
+   * wrapError, so chain handlers don't need to repeat `{ defaultAppName: 'X' }`
+   * at every catch site. Falls through unchanged for unknown methods.
+   */
+  _ctxForMethod(method) {
+    const prefix = /^(evm|btc|sol|tron)/.exec(method)?.[1];
+    const defaultAppName = prefix ? METHOD_PREFIX_TO_APP_NAME[prefix] : void 0;
+    if (!defaultAppName) return this._ctx;
+    return {
+      ...this._ctx,
+      wrapError: (err, opts) => this._wrapError(err, { defaultAppName, ...opts })
+    };
+  }
+  _wrapError(err, opts) {
     const src = err && typeof err === "object" ? err : {};
+    const hasSerializedCode = typeof src.code === "number" && HARDWARE_ERROR_CODE_VALUES.has(src.code);
+    const mapped = hasSerializedCode ? {
+      code: src.code,
+      message: typeof src.message === "string" ? src.message : "Unknown Ledger error",
+      appName: typeof src.appName === "string" ? src.appName : opts?.defaultAppName
+    } : mapLedgerError(err, opts);
+    const error = new Error(mapped.message);
     Object.assign(error, {
       code: mapped.code,
       appName: mapped.appName,
       _tag: src._tag,
       errorCode: src.errorCode,
-      _lastStep: src._lastStep
+      _lastStep: src._lastStep,
+      _deviceActionSteps: src._deviceActionSteps
     });
     Object.defineProperty(error, "originalError", {
       value: err,
@@ -2590,13 +3579,6 @@ var LedgerConnectorBase = class {
     return error;
   }
 };
-
-// src/utils/bleIdentity.ts
-function extractBleHexId(name) {
-  if (!name) return void 0;
-  const match = name.match(/\b([0-9A-Fa-f]{4})$/);
-  return match ? match[1].toUpperCase() : void 0;
-}
 export {
   AppManager,
   DmkTransport,
@@ -2607,12 +3589,15 @@ export {
   SignerEth,
   SignerManager,
   SignerSol,
+  debugLog,
   deviceActionToPromise,
-  extractBleHexId,
-  isDebugEnabled,
   isDeviceLockedError,
+  isLedgerBleConnectionType,
+  isLedgerBleDescriptor,
+  isLedgerDmkBleTransport,
   ledgerFailure,
   mapLedgerError,
-  setDebugEnabled
+  offSdkEvent,
+  onSdkEvent
 };
 //# sourceMappingURL=index.mjs.map