@onekeyfe/hwk-ledger-adapter 1.1.26-alpha.9 → 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,6 +330,21 @@ function isTimeoutError(err) {
   if (e.code === HardwareErrorCode.OperationTimeout) return true;
   return false;
 }
+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) {
@@ -190,20 +356,24 @@ function mapLedgerError(err, opts) {
   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;
@@ -213,38 +383,100 @@ function mapLedgerError(err, opts) {
   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;
     // ---------------------------------------------------------------------------
@@ -274,40 +506,23 @@ var _LedgerAdapter = class _LedgerAdapter {
       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.
@@ -320,6 +535,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     this._connectingPromise = null;
     this._uiRegistry.reset();
     this._jobQueue.clear();
+    this._btcHighIndexConfirmedThisSession = false;
   }
   async dispose() {
     this._uiRegistry.reset();
@@ -328,6 +544,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     this.connector.reset();
     this._discoveredDevices.clear();
     this._sessions.clear();
+    this._btcHighIndexConfirmedThisSession = false;
     this.emitter.removeAllListeners();
   }
   uiResponse(response) {
@@ -336,10 +553,16 @@ 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) {
@@ -349,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) {
@@ -389,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,
@@ -401,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);
   }
@@ -455,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);
   }
@@ -492,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);
   }
@@ -512,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);
@@ -552,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);
@@ -646,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;
     }
-    return chosen.connectId;
+    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 chosenConnectId;
   }
   /**
    * Call the connector with automatic session resolution and disconnect retry.
@@ -751,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(
@@ -796,31 +1132,195 @@ 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
       });
     }
+    try {
+      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;
+      debugLog("[LedgerAdapter] connectorCall error:", method, {
+        message: errObj?.message,
+        _tag: errObj?._tag,
+        errorCode: errObj?.errorCode,
+        statusCode: errObj?.statusCode,
+        isDisconnected: isDeviceDisconnectedError(err),
+        isLocked: isDeviceLockedError(err),
+        isNotAdvertising: isDeviceNotAdvertisingError(err),
+        isStuckApp: isStuckAppStateError(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) || 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,
+          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;
+    }
+  }
+  /**
+   * 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 _LedgerAdapter._abortable(
+      const fp = await this._abortable(
         signal,
-        this._verifyDeviceFingerprintWithSession(sessionId, fingerprint.deviceId, fingerprint.chain)
+        this._verifyDeviceFingerprintWithSession(
+          retrySessionId,
+          fingerprint.deviceId,
+          fingerprint.chain
+        )
       );
       if (!fp.success) {
         throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
@@ -828,48 +1328,97 @@ var _LedgerAdapter = class _LedgerAdapter {
         });
       }
     }
-    try {
-      return await _LedgerAdapter._abortable(signal, this.connector.call(sessionId, method, params));
-    } catch (err) {
-      if (signal.aborted) throw err;
-      const errObj = err;
-      debugLog("[LedgerAdapter] connectorCall error:", method, {
-        message: errObj?.message,
-        _tag: errObj?._tag,
-        errorCode: errObj?.errorCode,
-        statusCode: errObj?.statusCode,
-        isDisconnected: isDeviceDisconnectedError(err),
-        isLocked: isDeviceLockedError(err)
-      });
-      if (isDeviceDisconnectedError(err)) {
-        debugLog("[LedgerAdapter] disconnected, retrying with fresh connection...");
-        this._discoveredDevices.clear();
-        return this._retryWithFreshConnection(resolvedConnectId, method, params, signal, err);
-      }
-      if (isDeviceLockedError(err)) {
-        await this._waitForDeviceConnect(signal);
-        _LedgerAdapter._throwIfAborted(signal);
-        return _LedgerAdapter._abortable(signal, this.connector.call(sessionId, method, params));
-      }
-      if (isTimeoutError(err)) {
-        debugLog("[LedgerAdapter] timeout, retrying with fresh connection...");
-        this._discoveredDevices.delete(resolvedConnectId);
-        return this._retryWithFreshConnection(resolvedConnectId, method, params, signal, err);
+    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;
       }
-      throw err;
-    }
+      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. */
-  async _retryWithFreshConnection(resolvedConnectId, method, params, signal, originalErr) {
-    this._sessions.delete(resolvedConnectId);
-    _LedgerAdapter._throwIfAborted(signal);
-    const retryConnectId = await this.ensureConnected();
-    _LedgerAdapter._throwIfAborted(signal);
+  /**
+   * 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.
@@ -883,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,
@@ -893,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
       });
     }
   }
@@ -906,12 +1485,14 @@ 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);
@@ -927,32 +1508,38 @@ var _LedgerAdapter = class _LedgerAdapter {
   // 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
     };
   }
 };
-// ---------------------------------------------------------------------------
-// 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) {
@@ -989,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);
           }
@@ -999,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 {
@@ -1021,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
           }))
         );
       }
@@ -1046,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
               }
             });
           }
@@ -1066,6 +1661,54 @@ var LedgerDeviceManager = class {
     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();
@@ -1083,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);
@@ -1126,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
@@ -1137,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 = () => {
@@ -1154,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);
@@ -1203,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));
           }
         }
@@ -1216,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: () => {
@@ -1229,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 {
     }
   }
@@ -1303,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) {
@@ -1312,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;
   }
 };
 
@@ -1323,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;
   }
 }
 
@@ -1425,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 }
@@ -1700,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 }
@@ -1870,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 }
@@ -1882,11 +2608,11 @@ async function _createSolSigner(ctx, sessionId) {
 }
 
 // src/connector/chains/tron.ts
-import { 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/legacyChainCall.ts
-import { EConnectorInteraction as EConnectorInteraction2 } from "@onekeyfe/hwk-adapter-core";
+import { EConnectorInteraction as EConnectorInteraction3 } from "@onekeyfe/hwk-adapter-core";
 
 // src/app/AppManager.ts
 import {
@@ -1895,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",
@@ -1966,7 +2693,31 @@ var AppManager = class {
       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({
@@ -1975,9 +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
@@ -2033,14 +2786,14 @@ async function withLegacyChainCall(ctx, sessionId, options, action) {
   const onAppOpenPrompt = () => {
     openAppPromptShown = true;
     ctx.emit("ui-event", {
-      type: EConnectorInteraction2.ConfirmOpenApp,
+      type: EConnectorInteraction3.ConfirmOpenApp,
       payload: { sessionId }
     });
   };
   const closeOpenAppUiIfShown = () => {
     if (openAppPromptShown) {
       ctx.emit("ui-event", {
-        type: EConnectorInteraction2.InteractionComplete,
+        type: EConnectorInteraction3.InteractionComplete,
         payload: { sessionId }
       });
       openAppPromptShown = false;
@@ -2061,7 +2814,7 @@ async function withLegacyChainCall(ctx, sessionId, options, action) {
     let confirmEmitted = false;
     if (needsConfirmation) {
       ctx.emit("ui-event", {
-        type: EConnectorInteraction2.ConfirmOnDevice,
+        type: EConnectorInteraction3.ConfirmOnDevice,
         payload: { sessionId }
       });
       confirmEmitted = true;
@@ -2071,7 +2824,7 @@ async function withLegacyChainCall(ctx, sessionId, options, action) {
     } finally {
       if (confirmEmitted || openAppPromptShown) {
         ctx.emit("ui-event", {
-          type: EConnectorInteraction2.InteractionComplete,
+          type: EConnectorInteraction3.InteractionComplete,
           payload: { sessionId }
         });
         openAppPromptShown = false;
@@ -2159,7 +2912,7 @@ 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);
@@ -2203,6 +2956,10 @@ var METHOD_PREFIX_TO_APP_NAME = {
   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":
@@ -2226,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
@@ -2244,10 +2991,23 @@ 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);
     }
@@ -2265,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 {
@@ -2305,92 +3050,284 @@ 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();
-    let discovered = 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;
-    }
-    const externalConnectId = this._getConnectIdForPath(targetPath);
+      targetPath = discovered[0].deviceId;
+    }
+    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 realName = discovered.find((d) => d.connectId === externalConnectId)?.name ?? "Ledger";
+      const name = dm.getDeviceName(path) ?? "Ledger";
       this._emit("device-connect", {
-        device: {
-          connectId: externalConnectId,
-          deviceId: path,
-          name: realName
-        }
+        device: { connectId: externalConnectId, deviceId: path, name }
       });
       return session;
     };
     try {
       return await doConnect(targetPath);
-    } catch {
+    } catch (err) {
       this._resetSignersAndSessions();
-      const dm2 = await this._getDeviceManager();
-      discovered = 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
@@ -2530,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", {
@@ -2550,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() {
@@ -2568,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
@@ -2608,15 +3554,21 @@ var LedgerConnectorBase = class {
     };
   }
   _wrapError(err, opts) {
-    const mapped = mapLedgerError(err, opts);
-    const error = new Error(mapped.message);
     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,
@@ -2627,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,
@@ -2644,12 +3589,15 @@ export {
   SignerEth,
   SignerManager,
   SignerSol,
+  debugLog,
   deviceActionToPromise,
-  extractBleHexId,
-  isDebugEnabled,
   isDeviceLockedError,
+  isLedgerBleConnectionType,
+  isLedgerBleDescriptor,
+  isLedgerDmkBleTransport,
   ledgerFailure,
   mapLedgerError,
-  setDebugEnabled
+  offSdkEvent,
+  onSdkEvent
 };
 //# sourceMappingURL=index.mjs.map