@onekeyfe/hwk-ledger-adapter 1.2.0-alpha.12 → 1.2.0-alpha.13

package/dist/index.js

@@ -53,7 +53,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/adapter/LedgerAdapter.ts
-var import_hwk_adapter_core2 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core3 = require("@onekeyfe/hwk-adapter-core");
 
 // src/errors.ts
 var import_hwk_adapter_core = require("@onekeyfe/hwk-adapter-core");
@@ -75,30 +75,37 @@ 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_TRANSACTION_FALLBACK = "signer.eth.steps.blindSignTransactionFallback";
+var STEP_DETECT_BLIND_SIGNING = "signer.eth.steps.detectBlindSigning";
+var BLIND_SIGNING_STEPS = /* @__PURE__ */ new Set([
+  STEP_BLIND_SIGN_TRANSACTION_FALLBACK,
+  STEP_DETECT_BLIND_SIGNING
+]);
+function normalizeApduHex(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 65535) {
+    return value.toString(16).padStart(4, "0");
+  }
+  if (typeof value !== "string") return null;
+  const raw = value.toLowerCase().replace(/^0x/, "");
+  return /^[0-9a-f]{1,4}$/i.test(raw) ? raw.padStart(4, "0") : null;
+}
 function getEthAppErrorCode(err) {
   if (!err || typeof err !== "object") return null;
   const e = err;
-  if (e._tag === ERROR_TAG.EthAppCommand && typeof e.errorCode === "string") {
-    return e.errorCode.toLowerCase();
+  if (e._tag === ERROR_TAG.EthAppCommand) {
+    const code = normalizeApduHex(e.errorCode) ?? normalizeApduHex(e.statusCode) ?? normalizeApduHex(e.code);
+    if (code) return code;
   }
   const orig = e.originalError;
-  if (orig?._tag === ERROR_TAG.EthAppCommand && typeof orig.errorCode === "string") {
-    return orig.errorCode.toLowerCase();
+  if (orig?._tag === ERROR_TAG.EthAppCommand) {
+    return normalizeApduHex(orig.errorCode) ?? normalizeApduHex(orig.statusCode) ?? normalizeApduHex(orig.code);
   }
   return null;
 }
 function extractApduHex(err) {
   if (!err || typeof err !== "object") return null;
   const e = err;
-  if (typeof e.errorCode === "string" && /^[0-9a-f]+$/i.test(e.errorCode)) {
-    return e.errorCode.toLowerCase();
-  }
-  if (typeof e.statusCode === "number" && Number.isFinite(e.statusCode)) {
-    return e.statusCode.toString(16).padStart(4, "0");
-  }
-  if (typeof e.statusCode === "string" && /^[0-9a-f]+$/i.test(e.statusCode)) {
-    return e.statusCode.toLowerCase();
-  }
+  const direct = normalizeApduHex(e.errorCode) ?? normalizeApduHex(e.statusCode);
+  if (direct) return direct;
   if (e.originalError != null) {
     const nested = extractApduHex(e.originalError);
     if (nested) return nested;
@@ -157,10 +164,15 @@ function classifyEthAppError(err) {
   const ethCode = getEthAppErrorCode(err);
   if (!ethCode) return null;
   if (ethCode === "6a80") {
-    return hasBlindSignFallbackStep(err) ? import_hwk_adapter_core.HardwareErrorCode.EvmBlindSigningRequired : null;
+    return hasBlindSigningStep(err) ? import_hwk_adapter_core.HardwareErrorCode.EvmBlindSigningRequired : null;
   }
   return mapEthAppErrorCode(ethCode);
 }
+function classifyBlindSigningDetectionError(err) {
+  if (!hasBlindSigningStep(err)) return null;
+  if (hasInvalidArgumentCode(err)) return import_hwk_adapter_core.HardwareErrorCode.EvmBlindSigningRequired;
+  return null;
+}
 var ERROR_TAG = {
   // SDK-mint
   DeviceNotAdvertising: "DeviceNotAdvertisingError",
@@ -176,6 +188,10 @@ var ERROR_TAG = {
   // chain app wedged (APDU 0x6901)
   DeviceTransportStuck: "DeviceTransportStuck",
   // DMK transport queue wedged
+  // installApp resolved success but the app is still missing on device —
+  // DMK quirk. Surfaced as a distinct tag so callers can tell it apart from
+  // the original DMK-thrown AppNotInstalled.
+  AppInstallVerifyFailed: "AppInstallVerifyFailedError",
   // DMK-reuse (DMK throws same string; we synthesize too)
   DeviceLocked: "DeviceLockedError",
   DeviceNotRecognized: "DeviceNotRecognizedError",
@@ -201,7 +217,11 @@ var ERROR_TAG = {
   // 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"
+  PairingRefused: "PairingRefusedError",
+  // DMK remote-network failures (manager-api HTTP / secure-channel WS).
+  WebSocketConnection: "WebSocketConnectionError",
+  HttpFetch: "FetchError",
+  InvalidFirmwareMetadataResponse: "InvalidGetFirmwareMetadataResponseError"
 };
 function isDeviceLockedError(err) {
   if (!err || typeof err !== "object") return false;
@@ -289,15 +309,30 @@ function hasStatusCode(err, codeSet) {
   if (e.error != null && e._tag && hasStatusCode(e.error, codeSet)) return true;
   return false;
 }
-function hasBlindSignFallbackStep(err) {
+function hasDeviceActionStep(err, step) {
   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)) {
+  if (e._lastStep === step) return true;
+  if (Array.isArray(e._deviceActionSteps) && e._deviceActionSteps.includes(step)) {
     return true;
   }
-  if (e.originalError != null && hasBlindSignFallbackStep(e.originalError)) return true;
-  if (e.error != null && e._tag && hasBlindSignFallbackStep(e.error)) return true;
+  if (e.originalError != null && hasDeviceActionStep(e.originalError, step)) return true;
+  if (e.error != null && e._tag && hasDeviceActionStep(e.error, step)) return true;
+  return false;
+}
+function hasBlindSigningStep(err) {
+  for (const step of BLIND_SIGNING_STEPS) {
+    if (hasDeviceActionStep(err, step)) return true;
+  }
+  return false;
+}
+function hasInvalidArgumentCode(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  if (e.code === "INVALID_ARGUMENT") return true;
+  if (typeof e.message === "string" && e.message.includes("code=INVALID_ARGUMENT")) return true;
+  if (e.originalError != null && hasInvalidArgumentCode(e.originalError)) return true;
+  if (e.error != null && e._tag && hasInvalidArgumentCode(e.error)) return true;
   return false;
 }
 function isDeviceNotFoundError(err) {
@@ -326,6 +361,11 @@ function isUserRejectedError(err) {
   if (hasStatusCode(err, USER_REJECTED_CODES)) return true;
   return false;
 }
+function isUserAbortedError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  return e._tag === ERROR_TAG.UserAborted;
+}
 function isWrongAppError(err) {
   if (!err || typeof err !== "object") return false;
   const e = err;
@@ -352,6 +392,20 @@ function isOutOfMemoryError(err) {
   const e = err;
   return e._tag === "OutOfMemoryDAError";
 }
+var NETWORK_ERROR_TAGS = /* @__PURE__ */ new Set([
+  ERROR_TAG.WebSocketConnection,
+  ERROR_TAG.HttpFetch,
+  ERROR_TAG.InvalidFirmwareMetadataResponse
+]);
+function isNetworkError(err) {
+  if (!err || typeof err !== "object") return false;
+  const e = err;
+  const tag = e._tag;
+  if (typeof tag === "string" && NETWORK_ERROR_TAGS.has(tag)) return true;
+  if (e.originalError != null && isNetworkError(e.originalError)) return true;
+  if (e.error != null && isNetworkError(e.error)) return true;
+  return false;
+}
 function isDeviceDisconnectedError(err) {
   if (!err || typeof err !== "object") return false;
   const e = err;
@@ -408,6 +462,8 @@ function mapLedgerError(err, opts) {
     code = import_hwk_adapter_core.HardwareErrorCode.DeviceBusy;
   } else if (isBlePairingFailureError(err)) {
     code = import_hwk_adapter_core.HardwareErrorCode.BlePairingTimeout;
+  } else if (isUserAbortedError(err)) {
+    code = import_hwk_adapter_core.HardwareErrorCode.UserAborted;
   } else if (isUserRejectedError(err)) {
     code = import_hwk_adapter_core.HardwareErrorCode.UserRejected;
   } else if (isWrongAppError(err)) {
@@ -416,12 +472,14 @@ function mapLedgerError(err, opts) {
     code = import_hwk_adapter_core.HardwareErrorCode.AppNotInstalled;
   } else if (isOutOfMemoryError(err)) {
     code = import_hwk_adapter_core.HardwareErrorCode.DeviceOutOfMemory;
+  } else if (isNetworkError(err)) {
+    code = import_hwk_adapter_core.HardwareErrorCode.NetworkError;
   } else if (isDeviceDisconnectedError(err)) {
     code = import_hwk_adapter_core.HardwareErrorCode.DeviceDisconnected;
   } else if (isTimeoutError(err)) {
     code = import_hwk_adapter_core.HardwareErrorCode.OperationTimeout;
   } else {
-    const ethMapped = classifyEthAppError(err);
+    const ethMapped = classifyEthAppError(err) ?? classifyBlindSigningDetectionError(err);
     const apduHex = ethMapped ? null : extractApduHex(err);
     const chainMapped = apduHex ? mapSolanaAppError(apduHex) ?? mapTronAppError(apduHex) ?? mapBtcAppError(apduHex) : null;
     code = ethMapped ?? chainMapped ?? import_hwk_adapter_core.HardwareErrorCode.UnknownError;
@@ -431,17 +489,8 @@ function mapLedgerError(err, opts) {
   return { code, message: (0, import_hwk_adapter_core.enrichErrorMessage)(code, originalMessage), appName };
 }
 
-// src/utils/ledgerDmkTransport.ts
-function isLedgerDmkBleTransport(transport) {
-  const normalized = transport?.toUpperCase();
-  return normalized === "BLE" || normalized?.endsWith("_BLE") === true;
-}
-function isLedgerBleConnectionType(connectionType) {
-  return connectionType === "ble";
-}
-function isLedgerBleDescriptor(connectionType, descriptor) {
-  return isLedgerBleConnectionType(connectionType) || isLedgerDmkBleTransport(descriptor.transport);
-}
+// src/adapter/methods/allNetworkGetAddress.ts
+var import_hwk_adapter_core2 = require("@onekeyfe/hwk-adapter-core");
 
 // src/utils/sdkEventBus.ts
 var listeners = /* @__PURE__ */ new Set();
@@ -488,6 +537,216 @@ function debugError(...args) {
   emitLog("error", ...args);
 }
 
+// src/adapter/methods/allNetworkGetAddress.ts
+var LEDGER_BTC_NETWORK_COIN_MAP = {
+  tbtc: "Testnet",
+  bch: "Bcash",
+  ltc: "Litecoin",
+  neurai: "Neurai"
+};
+var LEDGER_UNSUPPORTED_ALLNETWORK_NETWORKS = /* @__PURE__ */ new Set(["doge", "dogecoin"]);
+function createAllNetworkGetAddress({
+  callChain,
+  getChainFingerprint
+}) {
+  return async function allNetworkGetAddress(connectId, _deviceId, params) {
+    debugLog("[LedgerAdapter][REQ]", { method: "allNetworkGetAddress", connectId, params });
+    const installContext = {};
+    const commonParams = {
+      autoInstallApp: params.autoInstallApp
+    };
+    const chainFingerprints = /* @__PURE__ */ new Map();
+    const result = await (0, import_hwk_adapter_core2.runAllNetworkGetAddress)({
+      connectId,
+      deviceId: _deviceId,
+      params,
+      normalizeItem: normalizeLedgerAllNetworkItem,
+      buildUnsupportedNetworkResponse: (item) => isUnsupportedLedgerAllNetworkNetwork(item) ? buildUnsupportedNetworkResponse(item) : void 0,
+      callItem: async ({ method, chain, item }) => {
+        const itemDeviceId = getItemDeviceId(item) ?? chainFingerprints.get(chain) ?? "";
+        return callAllNetworkMethod(
+          callChain,
+          connectId,
+          itemDeviceId,
+          method,
+          item,
+          commonParams,
+          installContext
+        );
+      },
+      attachIdentity: async ({ item, chain, payload }) => attachLedgerIdentity(
+        getChainFingerprint,
+        connectId,
+        item,
+        chain,
+        payload,
+        chainFingerprints
+      ),
+      shouldAbortBundle: isTopLevelAllNetworkFailure,
+      buildTopLevelFailure: (response) => {
+        const code = response.payload?.code ?? import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch;
+        return (0, import_hwk_adapter_core2.failure)(
+          code,
+          response.payload?.error ?? "All-network get-address aborted",
+          response.payload?.params
+        );
+      }
+    });
+    debugLog("[LedgerAdapter][RES]", {
+      method: "allNetworkGetAddress",
+      success: result.success,
+      payload: result
+    });
+    return result;
+  };
+}
+function isTopLevelAllNetworkFailure(response) {
+  if (response.success) {
+    return false;
+  }
+  const code = response.payload?.code;
+  return code === import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch || code === import_hwk_adapter_core2.HardwareErrorCode.UserAborted || code === import_hwk_adapter_core2.HardwareErrorCode.UserRejected;
+}
+function getItemDeviceId(item) {
+  const { deviceId } = item;
+  return typeof deviceId === "string" && deviceId.length > 0 ? deviceId : void 0;
+}
+function isUnsupportedLedgerAllNetworkNetwork(item) {
+  return LEDGER_UNSUPPORTED_ALLNETWORK_NETWORKS.has(item.network.toLowerCase());
+}
+function buildUnsupportedNetworkResponse(item) {
+  return {
+    ...item,
+    success: false,
+    payload: {
+      code: import_hwk_adapter_core2.HardwareErrorCode.ChainNotSupported,
+      error: `Ledger allNetwork does not support ${item.network.toLowerCase() === "doge" ? "Dogecoin" : item.network}`
+    }
+  };
+}
+function normalizeLedgerAllNetworkItem(method, item) {
+  if (method !== "btcGetAddress" && method !== "btcGetPublicKey") {
+    return item;
+  }
+  const itemWithCoin = item;
+  if (itemWithCoin.coin) {
+    return item;
+  }
+  const coin = LEDGER_BTC_NETWORK_COIN_MAP[item.network];
+  return coin ? { ...item, coin } : item;
+}
+async function attachLedgerIdentity(getChainFingerprint, connectId, item, chain, payload, chainFingerprints) {
+  const fingerprint = getItemDeviceId(item) || chainFingerprints.get(chain) || await bootstrapChainFingerprint(getChainFingerprint, connectId, chain);
+  if (!fingerprint) {
+    return buildFingerprintBootstrapFailure(item, chain);
+  }
+  chainFingerprints.set(chain, fingerprint);
+  return {
+    ...item,
+    success: true,
+    payload: {
+      ...payload,
+      deviceIdentity: {
+        vendor: "ledger",
+        type: "chainFingerprint",
+        chain,
+        value: fingerprint
+      },
+      chainFingerprint: fingerprint,
+      chainFingerprintChain: chain
+    }
+  };
+}
+async function bootstrapChainFingerprint(getChainFingerprint, connectId, chain) {
+  const response = await getChainFingerprint(connectId, chain);
+  return response.success ? response.payload : "";
+}
+function buildFingerprintBootstrapFailure(item, chain) {
+  return {
+    ...item,
+    success: false,
+    payload: {
+      code: import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch,
+      error: `Could not establish chain fingerprint for ${chain} after device call; refusing to return unverifiable result. Please retry.`
+    }
+  };
+}
+async function callAllNetworkMethod(callChain, connectId, deviceId, method, item, commonParams, installContext) {
+  switch (method) {
+    case "evmGetAddress":
+      return callChain(
+        connectId,
+        deviceId,
+        "evm",
+        "evmGetAddress",
+        item,
+        commonParams,
+        false,
+        installContext
+      );
+    case "btcGetAddress":
+      return callChain(
+        connectId,
+        deviceId,
+        "btc",
+        "btcGetAddress",
+        item,
+        commonParams,
+        false,
+        installContext
+      );
+    case "btcGetPublicKey":
+      return callChain(
+        connectId,
+        deviceId,
+        "btc",
+        "btcGetPublicKey",
+        item,
+        commonParams,
+        false,
+        installContext
+      );
+    case "solGetAddress":
+      return callChain(
+        connectId,
+        deviceId,
+        "sol",
+        "solGetAddress",
+        item,
+        commonParams,
+        false,
+        installContext
+      );
+    case "tronGetAddress":
+      return callChain(
+        connectId,
+        deviceId,
+        "tron",
+        "tronGetAddress",
+        item,
+        commonParams,
+        false,
+        installContext
+      );
+    default:
+      throw Object.assign(new Error(`Unsupported allNetwork method: ${method}`), {
+        code: import_hwk_adapter_core2.HardwareErrorCode.InvalidParams
+      });
+  }
+}
+
+// src/utils/ledgerDmkTransport.ts
+function isLedgerDmkBleTransport(transport) {
+  const normalized = transport?.toUpperCase();
+  return normalized === "BLE" || normalized?.endsWith("_BLE") === true;
+}
+function isLedgerBleConnectionType(connectionType) {
+  return connectionType === "ble";
+}
+function isLedgerBleDescriptor(connectionType, descriptor) {
+  return isLedgerBleConnectionType(connectionType) || isLedgerDmkBleTransport(descriptor.transport);
+}
+
 // src/adapter/LedgerAdapter.ts
 function formatDeviceMismatchError(expected, actual) {
   return `Wrong device: expected ${expected}, got ${actual}`;
@@ -503,10 +762,10 @@ function btcAccountIndexFromPath(path) {
 var _LedgerAdapter = class _LedgerAdapter {
   constructor(connector, options) {
     this.vendor = "ledger";
-    this.emitter = new import_hwk_adapter_core2.TypedEventEmitter();
+    this.emitter = new import_hwk_adapter_core3.TypedEventEmitter();
     this._discoveredDevices = /* @__PURE__ */ new Map();
     this._sessions = /* @__PURE__ */ new Map();
-    this._uiRegistry = new import_hwk_adapter_core2.UiRequestRegistry();
+    this._uiRegistry = new import_hwk_adapter_core3.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.
@@ -515,6 +774,11 @@ var _LedgerAdapter = class _LedgerAdapter {
     this._btcHighIndexConfirmedThisSession = false;
     // Shared across concurrent callers — only `cancel()` aborts.
     this._doConnectAbortController = null;
+    this._installProgressLastEmittedValue = -Infinity;
+    this.allNetworkGetAddress = createAllNetworkGetAddress({
+      callChain: this.callChain.bind(this),
+      getChainFingerprint: (connectId, chain) => this.getChainFingerprint(connectId, "", chain)
+    });
     // ---------------------------------------------------------------------------
     // Private helpers
     // ---------------------------------------------------------------------------
@@ -534,16 +798,16 @@ var _LedgerAdapter = class _LedgerAdapter {
       const deviceInfo = this.connectorDeviceToDeviceInfo(data.device);
       this._discoveredDevices.set(deviceInfo.connectId, deviceInfo);
       this._sessions.delete(deviceInfo.connectId);
-      this.emitter.emit(import_hwk_adapter_core2.DEVICE.CONNECT, {
-        type: import_hwk_adapter_core2.DEVICE.CONNECT,
+      this.emitter.emit(import_hwk_adapter_core3.DEVICE.CONNECT, {
+        type: import_hwk_adapter_core3.DEVICE.CONNECT,
         payload: deviceInfo
       });
     };
     this.deviceDisconnectHandler = (data) => {
       this._discoveredDevices.delete(data.connectId);
       this._sessions.delete(data.connectId);
-      this.emitter.emit(import_hwk_adapter_core2.DEVICE.DISCONNECT, {
-        type: import_hwk_adapter_core2.DEVICE.DISCONNECT,
+      this.emitter.emit(import_hwk_adapter_core3.DEVICE.DISCONNECT, {
+        type: import_hwk_adapter_core3.DEVICE.DISCONNECT,
         payload: { connectId: data.connectId }
       });
     };
@@ -553,7 +817,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     // exists (race during teardown) we drop. All other variants pass through
     // unchanged.
     this.uiEventForwarder = (event) => {
-      if (event.type === import_hwk_adapter_core2.EConnectorInteraction.AppInstallProgress) {
+      if (event.type === import_hwk_adapter_core3.EConnectorInteraction.AppInstallProgress) {
         let connectId;
         for (const [cid, sid] of this._sessions) {
           if (sid === event.payload.sessionId) {
@@ -568,12 +832,23 @@ var _LedgerAdapter = class _LedgerAdapter {
           );
           return;
         }
+        const { appName, progress } = event.payload;
+        const key = `${connectId}:${appName}`;
+        if (this._installProgressLastKey !== key || this._installProgressLastEmittedValue >= 1) {
+          this._installProgressLastEmittedValue = -Infinity;
+          this._installProgressLastKey = key;
+        }
+        const delta = progress - this._installProgressLastEmittedValue;
+        if (delta < _LedgerAdapter.APP_INSTALL_PROGRESS_MIN_DELTA && progress < 1) {
+          return;
+        }
+        this._installProgressLastEmittedValue = progress;
         this.emitter.emit("ui-event", {
-          type: import_hwk_adapter_core2.EConnectorInteraction.AppInstallProgress,
+          type: import_hwk_adapter_core3.EConnectorInteraction.AppInstallProgress,
           payload: {
             connectId,
-            appName: event.payload.appName,
-            progress: event.payload.progress
+            appName,
+            progress
           }
         });
         return;
@@ -582,7 +857,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     };
     this.connector = connector;
     this._defaultAutoInstallApp = options?.autoInstallApp ?? false;
-    this._jobQueue = new import_hwk_adapter_core2.DeviceJobQueue();
+    this._jobQueue = new import_hwk_adapter_core3.DeviceJobQueue();
     this.registerEventListeners();
   }
   // Transport
@@ -630,30 +905,42 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Device management
   // ---------------------------------------------------------------------------
   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();
-    this._discoveredDevices.clear();
-    for (const d of devices) {
-      if (d.connectId) {
-        this._discoveredDevices.set(d.connectId, this.connectorDeviceToDeviceInfo(d));
+    debugLog("[LedgerAdapter][REQ]", { method: "searchDevices", params: options });
+    try {
+      if (options?.resetSession) {
+        this._doConnectAbortController?.abort();
+        this._sessions.clear();
+        this._connectingPromise = null;
+        this._doConnectAbortController = null;
+        this._btcHighIndexConfirmedThisSession = false;
       }
-    }
-    if (this._discoveredDevices.size === 0) {
       await this._ensureDevicePermission();
+      const devices = await this.connector.searchDevices();
+      this._discoveredDevices.clear();
+      for (const d of devices) {
+        if (d.connectId) {
+          this._discoveredDevices.set(d.connectId, this.connectorDeviceToDeviceInfo(d));
+        }
+      }
+      if (this._discoveredDevices.size === 0) {
+        await this._ensureDevicePermission();
+      }
+      const result = Array.from(this._discoveredDevices.values());
+      debugLog("[LedgerAdapter][RES]", {
+        method: "searchDevices",
+        success: true,
+        payload: result
+      });
+      return result;
+    } catch (err) {
+      const e = err;
+      debugLog("[LedgerAdapter][RES]", {
+        method: "searchDevices",
+        success: false,
+        error: { message: e?.message, _tag: e?._tag, code: e?.code ?? e?.errorCode }
+      });
+      throw err;
     }
-    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() {
@@ -669,14 +956,15 @@ var _LedgerAdapter = class _LedgerAdapter {
   }
   static _createDeviceBusyError(method) {
     return Object.assign(new Error(`Ledger device is busy while calling ${method}`), {
-      code: import_hwk_adapter_core2.HardwareErrorCode.DeviceBusy
+      code: import_hwk_adapter_core3.HardwareErrorCode.DeviceBusy
     });
   }
   async connectDevice(connectId) {
+    debugLog("[LedgerAdapter][REQ]", { method: "connectDevice", connectId, params: { connectId } });
     try {
       if (isLedgerBleConnectionType(this.connector.connectionType) && !connectId) {
         throw Object.assign(new Error("Ledger BLE connectId is required."), {
-          code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound
+          code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
         });
       }
       if (!isLedgerBleConnectionType(this.connector.connectionType)) {
@@ -688,28 +976,79 @@ var _LedgerAdapter = class _LedgerAdapter {
       if (session.deviceInfo) {
         this._discoveredDevices.set(connectId, session.deviceInfo);
       }
-      return (0, import_hwk_adapter_core2.success)(connectId);
+      const result = (0, import_hwk_adapter_core3.success)(connectId);
+      debugLog("[LedgerAdapter][RES]", { method: "connectDevice", success: true, payload: result });
+      return result;
     } catch (err) {
-      return this.errorToFailure(err);
+      const failureResult = this.errorToFailure(err);
+      debugLog("[LedgerAdapter][RES]", {
+        method: "connectDevice",
+        success: false,
+        payload: failureResult
+      });
+      return failureResult;
     }
   }
   async disconnectDevice(connectId) {
-    const sessionId = this._sessions.get(connectId);
-    if (sessionId) {
-      await this.connector.disconnect(sessionId);
-      this._sessions.delete(connectId);
+    debugLog("[LedgerAdapter][REQ]", {
+      method: "disconnectDevice",
+      connectId,
+      params: { connectId }
+    });
+    try {
+      const sessionId = this._sessions.get(connectId);
+      if (sessionId) {
+        await this.connector.disconnect(sessionId);
+        this._sessions.delete(connectId);
+      }
+      debugLog("[LedgerAdapter][RES]", { method: "disconnectDevice", success: true });
+    } catch (err) {
+      const e = err;
+      debugLog("[LedgerAdapter][RES]", {
+        method: "disconnectDevice",
+        success: false,
+        error: { message: e?.message, _tag: e?._tag, code: e?.code ?? e?.errorCode }
+      });
+      throw err;
     }
   }
   async getDeviceInfo(connectId, deviceId) {
-    await this._ensureDevicePermission(connectId, deviceId);
-    const cached = this._discoveredDevices.get(connectId) ?? Array.from(this._discoveredDevices.values()).find((d) => d.deviceId === deviceId);
-    if (cached) {
-      return (0, import_hwk_adapter_core2.success)(cached);
+    debugLog("[LedgerAdapter][REQ]", {
+      method: "getDeviceInfo",
+      connectId,
+      params: { connectId, deviceId }
+    });
+    try {
+      await this._ensureDevicePermission(connectId, deviceId);
+      const cached = this._discoveredDevices.get(connectId) ?? Array.from(this._discoveredDevices.values()).find((d) => d.deviceId === deviceId);
+      if (cached) {
+        const result = (0, import_hwk_adapter_core3.success)(cached);
+        debugLog("[LedgerAdapter][RES]", {
+          method: "getDeviceInfo",
+          success: true,
+          payload: result
+        });
+        return result;
+      }
+      const notFound = (0, import_hwk_adapter_core3.failure)(
+        import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+        "Device not found in cache. Call searchDevices() or wait for a device-connected event first."
+      );
+      debugLog("[LedgerAdapter][RES]", {
+        method: "getDeviceInfo",
+        success: false,
+        payload: notFound
+      });
+      return notFound;
+    } catch (err) {
+      const e = err;
+      debugLog("[LedgerAdapter][RES]", {
+        method: "getDeviceInfo",
+        success: false,
+        error: { message: e?.message, _tag: e?._tag, code: e?.code ?? e?.errorCode }
+      });
+      throw err;
     }
-    return (0, import_hwk_adapter_core2.failure)(
-      import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound,
-      "Device not found in cache. Call searchDevices() or wait for a device-connected event first."
-    );
   }
   getSupportedChains() {
     return ["evm", "btc", "sol", "tron"];
@@ -717,7 +1056,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   // ---------------------------------------------------------------------------
   // Chain call helper
   // ---------------------------------------------------------------------------
-  async callChain(connectId, deviceId, chain, method, params, commonParams, skipFingerprint = false) {
+  async callChain(connectId, deviceId, chain, method, params, commonParams, skipFingerprint = false, installContext) {
     try {
       const result = await this.connectorCall(
         connectId,
@@ -729,183 +1068,204 @@ var _LedgerAdapter = class _LedgerAdapter {
           skipFingerprint
         },
         void 0,
-        commonParams
+        commonParams,
+        installContext
       );
-      return (0, import_hwk_adapter_core2.success)(result);
+      return (0, import_hwk_adapter_core3.success)(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
   }
+  static normalizeCallArgs(connectId, deviceId, params) {
+    return {
+      connectId: connectId ?? "",
+      deviceId: deviceId ?? "",
+      params: params ?? {}
+    };
+  }
+  static splitCommonParams(params) {
+    if (params && typeof params === "object") {
+      const {
+        autoInstallApp,
+        passphraseState: _passphraseState,
+        useEmptyPassphrase: _useEmptyPassphrase,
+        ...rest
+      } = params;
+      return {
+        commonParams: {
+          autoInstallApp: typeof autoInstallApp === "boolean" ? autoInstallApp : void 0
+        },
+        rest
+      };
+    }
+    return { commonParams: {}, rest: params ?? {} };
+  }
+  callChainWithMergedParams(connectId, deviceId, chain, method, params) {
+    const normalized = _LedgerAdapter.normalizeCallArgs(connectId, deviceId, params);
+    const { commonParams, rest } = _LedgerAdapter.splitCommonParams(normalized.params);
+    return this.callChain(
+      normalized.connectId,
+      normalized.deviceId,
+      chain,
+      method,
+      rest,
+      commonParams
+    );
+  }
   // ---------------------------------------------------------------------------
   // EVM chain methods
   // ---------------------------------------------------------------------------
-  evmGetAddress(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  evmGetAddress(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "evm",
       "evmGetAddress",
-      params,
-      commonParams
+      params
     );
   }
-  evmSignTransaction(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  evmSignTransaction(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "evm",
       "evmSignTransaction",
-      params,
-      commonParams
+      params
     );
   }
-  evmSignMessage(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  evmSignMessage(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "evm",
       "evmSignMessage",
-      params,
-      commonParams
+      params
     );
   }
-  evmSignTypedData(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  evmSignTypedData(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "evm",
       "evmSignTypedData",
-      params,
-      commonParams
+      params
     );
   }
   // ---------------------------------------------------------------------------
   // BTC chain methods
   // ---------------------------------------------------------------------------
-  btcGetAddress(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  btcGetAddress(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcGetAddress",
-      params,
-      commonParams
+      params
     );
   }
-  btcGetPublicKey(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  btcGetPublicKey(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcGetPublicKey",
-      params,
-      commonParams
+      params
     );
   }
-  btcSignTransaction(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  btcSignTransaction(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcSignTransaction",
-      params,
-      commonParams
+      params
     );
   }
-  btcSignPsbt(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  btcSignPsbt(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcSignPsbt",
-      params,
-      commonParams
+      params
     );
   }
-  btcSignMessage(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  btcSignMessage(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcSignMessage",
-      params,
-      commonParams
+      params
     );
   }
-  btcGetMasterFingerprint(connectId, deviceId, commonParams) {
-    return this.callChain(
+  btcGetMasterFingerprint(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "btc",
       "btcGetMasterFingerprint",
-      {},
-      commonParams
+      params
     );
   }
   // ---------------------------------------------------------------------------
   // SOL chain methods
   // ---------------------------------------------------------------------------
-  solGetAddress(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  solGetAddress(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "sol",
       "solGetAddress",
-      params,
-      commonParams
+      params
     );
   }
-  solSignTransaction(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  solSignTransaction(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "sol",
       "solSignTransaction",
-      params,
-      commonParams
+      params
     );
   }
-  solSignMessage(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  solSignMessage(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "sol",
       "solSignMessage",
-      params,
-      commonParams
+      params
     );
   }
   // ---------------------------------------------------------------------------
   // TRON chain methods
   // ---------------------------------------------------------------------------
-  tronGetAddress(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  tronGetAddress(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "tron",
       "tronGetAddress",
-      params,
-      commonParams
+      params
     );
   }
-  tronSignTransaction(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  tronSignTransaction(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "tron",
       "tronSignTransaction",
-      params,
-      commonParams
+      params
     );
   }
-  tronSignMessage(connectId, deviceId, params, commonParams) {
-    return this.callChain(
+  tronSignMessage(connectId, deviceId, params) {
+    return this.callChainWithMergedParams(
       connectId,
       deviceId,
       "tron",
       "tronSignMessage",
-      params,
-      commonParams
+      params
     );
   }
   // ---------------------------------------------------------------------------
@@ -916,7 +1276,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   async installApp(connectId, appName) {
     try {
       await this.connectorCall(connectId, "installApp", { appName });
-      return (0, import_hwk_adapter_core2.success)(void 0);
+      return (0, import_hwk_adapter_core3.success)(void 0);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -924,7 +1284,16 @@ var _LedgerAdapter = class _LedgerAdapter {
   async listInstalledApps(connectId) {
     try {
       const result = await this.connectorCall(connectId, "listInstalledApps", {});
-      return (0, import_hwk_adapter_core2.success)(result);
+      return (0, import_hwk_adapter_core3.success)(result);
+    } catch (err) {
+      return this.errorToFailure(err);
+    }
+  }
+  // Offline app-presence + unlock probe. No manager-api catalog (unlike listInstalledApps).
+  async listInstalledNames(connectId) {
+    try {
+      const result = await this.connectorCall(connectId, "listInstalledNames", {});
+      return (0, import_hwk_adapter_core3.success)(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -932,7 +1301,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   async listAvailableApps(connectId) {
     try {
       const result = await this.connectorCall(connectId, "listAvailableApps", {});
-      return (0, import_hwk_adapter_core2.success)(result);
+      return (0, import_hwk_adapter_core3.success)(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -940,7 +1309,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   async getLedgerFirmwareVersion(connectId) {
     try {
       const result = await this.connectorCall(connectId, "getFirmwareVersion", {});
-      return (0, import_hwk_adapter_core2.success)(result);
+      return (0, import_hwk_adapter_core3.success)(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -948,7 +1317,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   async getLedgerDeviceInfo(connectId) {
     try {
       const result = await this.connectorCall(connectId, "getDeviceInfo", {});
-      return (0, import_hwk_adapter_core2.success)(result);
+      return (0, import_hwk_adapter_core3.success)(result);
     } catch (err) {
       return this.errorToFailure(err);
     }
@@ -961,7 +1330,7 @@ var _LedgerAdapter = class _LedgerAdapter {
   }
   cancel(connectId) {
     const userAbortReason = Object.assign(new Error("User aborted operation"), {
-      code: import_hwk_adapter_core2.HardwareErrorCode.UserAborted,
+      code: import_hwk_adapter_core3.HardwareErrorCode.UserAborted,
       _tag: ERROR_TAG.UserAborted
     });
     this._lastCancelReason = userAbortReason;
@@ -995,7 +1364,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         chain,
         (method, params) => this.connectorCall(connectId, method, params, void 0, deviceId)
       );
-      return (0, import_hwk_adapter_core2.success)(fingerprint);
+      return (0, import_hwk_adapter_core3.success)(fingerprint);
     } catch (err) {
       debugError("[LedgerAdapter] getChainFingerprint error:", chain, err);
       return this.errorToFailure(err);
@@ -1018,7 +1387,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       return { success: false, expected: deviceId, actual: fingerprint };
     } catch (err) {
       const mapped = mapLedgerError(err);
-      if (mapped.code === import_hwk_adapter_core2.HardwareErrorCode.WrongApp || mapped.code === import_hwk_adapter_core2.HardwareErrorCode.DeviceLocked) {
+      if (mapped.code === import_hwk_adapter_core3.HardwareErrorCode.WrongApp || mapped.code === import_hwk_adapter_core3.HardwareErrorCode.DeviceLocked) {
         return { success: true };
       }
       throw err;
@@ -1043,7 +1412,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       const result = await callMethod("btcGetMasterFingerprint", {});
       return result.masterFingerprint;
     }
-    const path = import_hwk_adapter_core2.CHAIN_FINGERPRINT_PATHS[chain];
+    const path = import_hwk_adapter_core3.CHAIN_FINGERPRINT_PATHS[chain];
     let address;
     if (chain === "evm") {
       address = (await callMethod("evmGetAddress", { path, showOnDevice: false })).address.toLowerCase();
@@ -1054,7 +1423,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     } else {
       throw new Error(`Unsupported chain for fingerprint: ${chain}`);
     }
-    return (0, import_hwk_adapter_core2.deriveDeviceFingerprint)(address);
+    return (0, import_hwk_adapter_core3.deriveDeviceFingerprint)(address);
   }
   // Ledger WebUSB won't expose a locked device, so we can't auto-detect unlock.
   // The user must press Confirm after unlocking, which triggers a search retry.
@@ -1066,10 +1435,10 @@ var _LedgerAdapter = class _LedgerAdapter {
       _LedgerAdapter._throwIfAborted(signal);
     }
     const waitPromise = this._uiRegistry.wait(
-      import_hwk_adapter_core2.UI_REQUEST.REQUEST_DEVICE_CONNECT
+      import_hwk_adapter_core3.UI_REQUEST.REQUEST_DEVICE_CONNECT
     );
-    this.emitter.emit(import_hwk_adapter_core2.UI_REQUEST.REQUEST_DEVICE_CONNECT, {
-      type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_DEVICE_CONNECT,
+    this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.REQUEST_DEVICE_CONNECT, {
+      type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_DEVICE_CONNECT,
       payload: {
         vendor: "ledger",
         reason: "device-not-found",
@@ -1080,7 +1449,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     try {
       if (signal) {
         const onAbort = () => {
-          this._uiRegistry.cancel(import_hwk_adapter_core2.UI_REQUEST.REQUEST_DEVICE_CONNECT);
+          this._uiRegistry.cancel(import_hwk_adapter_core3.UI_REQUEST.REQUEST_DEVICE_CONNECT);
         };
         signal.addEventListener("abort", onAbort, { once: true });
         try {
@@ -1092,20 +1461,20 @@ var _LedgerAdapter = class _LedgerAdapter {
         payload = await waitPromise;
       }
     } catch (err) {
-      this.emitter.emit(import_hwk_adapter_core2.UI_REQUEST.CLOSE_UI_WINDOW, {
-        type: import_hwk_adapter_core2.UI_REQUEST.CLOSE_UI_WINDOW,
+      this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.CLOSE_UI_WINDOW, {
+        type: import_hwk_adapter_core3.UI_REQUEST.CLOSE_UI_WINDOW,
         payload: {}
       });
       throw Object.assign(new Error("User cancelled Ledger connection"), {
         _tag: ERROR_TAG.UserAborted,
-        code: import_hwk_adapter_core2.HardwareErrorCode.UserAborted,
+        code: import_hwk_adapter_core3.HardwareErrorCode.UserAborted,
         cause: err
       });
     }
     if (!payload?.confirmed) {
       throw Object.assign(new Error("User cancelled Ledger connection"), {
         _tag: ERROR_TAG.UserAborted,
-        code: import_hwk_adapter_core2.HardwareErrorCode.UserAborted
+        code: import_hwk_adapter_core3.HardwareErrorCode.UserAborted
       });
     }
     await new Promise((resolve) => {
@@ -1135,10 +1504,10 @@ var _LedgerAdapter = class _LedgerAdapter {
   }
   async _waitForBtcHighIndexConfirm(path, accountIndex) {
     const waitPromise = this._uiRegistry.wait(
-      import_hwk_adapter_core2.UI_REQUEST.REQUEST_BTC_HIGH_INDEX_CONFIRM
+      import_hwk_adapter_core3.UI_REQUEST.REQUEST_BTC_HIGH_INDEX_CONFIRM
     );
-    this.emitter.emit(import_hwk_adapter_core2.UI_REQUEST.REQUEST_BTC_HIGH_INDEX_CONFIRM, {
-      type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_BTC_HIGH_INDEX_CONFIRM,
+    this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.REQUEST_BTC_HIGH_INDEX_CONFIRM, {
+      type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_BTC_HIGH_INDEX_CONFIRM,
       payload: {
         vendor: "ledger",
         path,
@@ -1149,8 +1518,8 @@ var _LedgerAdapter = class _LedgerAdapter {
       const payload = await waitPromise;
       return !!payload?.confirmed;
     } catch (err) {
-      this.emitter.emit(import_hwk_adapter_core2.UI_REQUEST.CLOSE_UI_WINDOW, {
-        type: import_hwk_adapter_core2.UI_REQUEST.CLOSE_UI_WINDOW,
+      this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.CLOSE_UI_WINDOW, {
+        type: import_hwk_adapter_core3.UI_REQUEST.CLOSE_UI_WINDOW,
         payload: {}
       });
       return false;
@@ -1160,18 +1529,18 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Same register-then-emit ordering as the BTC high-index gate.
   async _waitForInstallAppConfirm(appName) {
     const waitPromise = this._uiRegistry.wait(
-      import_hwk_adapter_core2.UI_REQUEST.REQUEST_INSTALL_APP
+      import_hwk_adapter_core3.UI_REQUEST.REQUEST_INSTALL_APP
     );
-    this.emitter.emit(import_hwk_adapter_core2.UI_REQUEST.REQUEST_INSTALL_APP, {
-      type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_INSTALL_APP,
+    this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.REQUEST_INSTALL_APP, {
+      type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_INSTALL_APP,
       payload: { vendor: "ledger", appName }
     });
     try {
       const payload = await waitPromise;
       return !!payload?.confirmed;
     } catch (err) {
-      this.emitter.emit(import_hwk_adapter_core2.UI_REQUEST.CLOSE_UI_WINDOW, {
-        type: import_hwk_adapter_core2.UI_REQUEST.CLOSE_UI_WINDOW,
+      this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.CLOSE_UI_WINDOW, {
+        type: import_hwk_adapter_core3.UI_REQUEST.CLOSE_UI_WINDOW,
         payload: {}
       });
       return false;
@@ -1184,7 +1553,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     if (signal.aborted) _LedgerAdapter._throwIfAborted(signal);
     if (isLedgerBleConnectionType(this.connector.connectionType) && !connectId) {
       throw Object.assign(new Error("Ledger BLE connectId is required."), {
-        code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
       });
     }
     if (connectId && this._sessions.has(connectId)) return connectId;
@@ -1194,7 +1563,7 @@ var _LedgerAdapter = class _LedgerAdapter {
           new Error(
             "Ledger USB session invariant violated: more than one session is active. Please reconnect the device."
           ),
-          { code: import_hwk_adapter_core2.HardwareErrorCode.DeviceOneDeviceOnly }
+          { code: import_hwk_adapter_core3.HardwareErrorCode.DeviceOneDeviceOnly }
         );
       }
       return this._sessions.keys().next().value;
@@ -1236,14 +1605,14 @@ var _LedgerAdapter = class _LedgerAdapter {
     let confirms = 0;
     while (!internalSignal.aborted) {
       this.emitter.emit("ui-event", {
-        type: import_hwk_adapter_core2.EConnectorInteraction.Searching,
+        type: import_hwk_adapter_core3.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);
+            setTimeout(resolve, import_hwk_adapter_core3.DEVICE_CONNECT_RETRY_DELAY_MS);
           });
           devices = await this.searchDevices();
           if (devices.length > 0) break;
@@ -1274,7 +1643,7 @@ var _LedgerAdapter = class _LedgerAdapter {
           new Error(
             "Device not connected after multiple attempts. Please ensure your Ledger is awake, unlocked, and in range, then try again."
           ),
-          { code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound }
+          { code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound }
         );
       }
       await this._waitForDeviceConnect(internalSignal);
@@ -1298,7 +1667,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         return this._connectDeviceOrThrow(devices[0].connectId);
       }
       const err = Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
-        code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
       });
       if (isLedgerBleConnectionType(this.connector.connectionType)) {
         err._tag = ERROR_TAG.DeviceNotAdvertising;
@@ -1307,7 +1676,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
     if (isLedgerBleConnectionType(this.connector.connectionType)) {
       throw Object.assign(new Error("Ledger BLE connectId is required."), {
-        code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
       });
     }
     if (devices.length > 1) {
@@ -1315,7 +1684,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
     if (devices.length !== 1) {
       throw Object.assign(new Error("Ledger device not found."), {
-        code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound
       });
     }
     return this._connectDeviceOrThrow(devices[0].connectId);
@@ -1353,7 +1722,7 @@ var _LedgerAdapter = class _LedgerAdapter {
    */
   _unwrapConnectorResult(result) {
     if (result.success) return result.payload;
-    throw (0, import_hwk_adapter_core2.rehydrateConnectorError)(result.error);
+    throw (0, import_hwk_adapter_core3.rehydrateConnectorError)(result.error);
   }
   /**
    * `connector.call` + result unwrap, optionally raced against an abort
@@ -1366,26 +1735,43 @@ var _LedgerAdapter = class _LedgerAdapter {
     const result = signal ? await this._abortable(signal, promise) : await promise;
     return this._unwrapConnectorResult(result);
   }
-  async connectorCall(connectId, method, params, fingerprint, permissionDeviceId, commonParams) {
-    debugLog("[LedgerAdapter] connectorCall:", method, "connectId:", connectId || "(empty)");
+  async connectorCall(connectId, method, params, fingerprint, permissionDeviceId, commonParams, installContext) {
+    debugLog("[LedgerAdapter][REQ]", { method, connectId: connectId || "(empty)", params });
     const queueKey = connectId || "__ledger_default__";
-    return this._jobQueue.enqueue(
-      queueKey,
-      async (signal) => this._runConnectorCall(
-        connectId,
+    try {
+      const result = await this._jobQueue.enqueue(
+        queueKey,
+        async (signal) => this._runConnectorCall(
+          connectId,
+          method,
+          params,
+          signal,
+          fingerprint,
+          permissionDeviceId,
+          commonParams,
+          installContext
+        ),
+        {
+          label: method,
+          rejectIfBusy: true,
+          busyError: _LedgerAdapter._createDeviceBusyError(method)
+        }
+      );
+      debugLog("[LedgerAdapter][RES]", { method, success: true, payload: result });
+      return result;
+    } catch (err) {
+      const e = err;
+      debugLog("[LedgerAdapter][RES]", {
         method,
-        params,
-        signal,
-        fingerprint,
-        permissionDeviceId,
-        commonParams
-      ),
-      {
-        label: method,
-        rejectIfBusy: true,
-        busyError: _LedgerAdapter._createDeviceBusyError(method)
-      }
-    );
+        success: false,
+        error: {
+          message: e?.message,
+          _tag: e?._tag,
+          code: e?.code ?? e?.errorCode
+        }
+      });
+      throw err;
+    }
   }
   /**
    * Race a promise against an abort signal. On abort, rejects with
@@ -1420,7 +1806,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
   }
   /** Actual work done under the job queue — connection, fingerprint, call, and recovery. */
-  async _runConnectorCall(connectId, method, params, signal, fingerprint, permissionDeviceId, commonParams) {
+  async _runConnectorCall(connectId, method, params, signal, fingerprint, permissionDeviceId, commonParams, installContext) {
     _LedgerAdapter._throwIfAborted(signal);
     await this._ensureDevicePermission(
       connectId,
@@ -1434,7 +1820,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       if (gatedParams === null) {
         throw Object.assign(new Error("User cancelled BTC high-index confirmation"), {
           _tag: ERROR_TAG.UserAborted,
-          code: import_hwk_adapter_core2.HardwareErrorCode.UserAborted
+          code: import_hwk_adapter_core3.HardwareErrorCode.UserAborted
         });
       }
       effectiveParams = gatedParams;
@@ -1463,7 +1849,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         );
         if (!fp.success) {
           throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
-            code: import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch
+            code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch
           });
         }
       }
@@ -1482,22 +1868,62 @@ var _LedgerAdapter = class _LedgerAdapter {
         isStuckApp: isStuckAppStateError(err)
       });
       const autoInstallApp = commonParams?.autoInstallApp ?? this._defaultAutoInstallApp;
-      const isAppMissing = isAppNotInstalledError(err) || err?.code === import_hwk_adapter_core2.HardwareErrorCode.AppNotInstalled;
+      const isAppMissing = isAppNotInstalledError(err) || err?.code === import_hwk_adapter_core3.HardwareErrorCode.AppNotInstalled;
       if (autoInstallApp && isAppMissing) {
+        if (installContext?.deviceOutOfMemoryError) {
+          throw installContext.deviceOutOfMemoryError;
+        }
         const appName = err?.appName ?? mapLedgerError(err).appName;
         if (appName) {
+          if (installContext?.installAttemptedAppNames?.has(appName)) {
+            throw (0, import_hwk_adapter_core3.createHwkError)({
+              code: import_hwk_adapter_core3.HardwareErrorCode.AppNotInstalled,
+              message: `${appName} install reported success but the app is still missing on device`,
+              _tag: ERROR_TAG.AppInstallVerifyFailed,
+              appName
+            });
+          }
           const confirmed = await this._waitForInstallAppConfirm(appName);
-          if (!confirmed) throw err;
+          if (!confirmed) {
+            throw (0, import_hwk_adapter_core3.createHwkError)({
+              code: import_hwk_adapter_core3.HardwareErrorCode.UserAborted,
+              message: `User declined to install ${appName}`,
+              _tag: ERROR_TAG.UserAborted,
+              appName
+            });
+          }
           this.emitter.emit("ui-event", {
-            type: import_hwk_adapter_core2.EConnectorInteraction.AppInstallProgress,
+            type: import_hwk_adapter_core3.EConnectorInteraction.AppInstallProgress,
             payload: { connectId: resolvedConnectId, appName, progress: 0 }
           });
-          await this._callConnector(sessionId, "installApp", { appName }, signal);
-          this.emitter.emit(import_hwk_adapter_core2.UI_REQUEST.CLOSE_UI_WINDOW, {
-            type: import_hwk_adapter_core2.UI_REQUEST.CLOSE_UI_WINDOW,
+          try {
+            await this._callConnector(sessionId, "installApp", { appName }, signal);
+          } catch (installErr) {
+            if (mapLedgerError(installErr).code === import_hwk_adapter_core3.HardwareErrorCode.DeviceOutOfMemory) {
+              if (installContext) {
+                installContext.deviceOutOfMemoryError = installErr;
+              }
+            }
+            throw installErr;
+          }
+          if (installContext) {
+            installContext.installAttemptedAppNames = installContext.installAttemptedAppNames ?? /* @__PURE__ */ new Set();
+            installContext.installAttemptedAppNames.add(appName);
+          }
+          this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.CLOSE_UI_WINDOW, {
+            type: import_hwk_adapter_core3.UI_REQUEST.CLOSE_UI_WINDOW,
             payload: {}
           });
-          return await this._callConnector(sessionId, method, effectiveParams, signal);
+          return await this._runConnectorCall(
+            resolvedConnectId,
+            method,
+            effectiveParams,
+            signal,
+            fingerprint,
+            permissionDeviceId,
+            commonParams,
+            installContext
+          );
         }
       }
       if (isStuckAppStateError(err)) {
@@ -1572,7 +1998,7 @@ var _LedgerAdapter = class _LedgerAdapter {
               );
               if (!fp.success) {
                 throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
-                  code: import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch
+                  code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch
                 });
               }
             }
@@ -1607,7 +2033,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         this.connector.reset();
         const codeNum = err?.code;
         throw Object.assign(err, {
-          code: codeNum ?? import_hwk_adapter_core2.HardwareErrorCode.DeviceDisconnected
+          code: codeNum ?? import_hwk_adapter_core3.HardwareErrorCode.DeviceDisconnected
         });
       }
       throw err;
@@ -1641,7 +2067,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       );
       if (!fp.success) {
         throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
-          code: import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch
+          code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch
         });
       }
     }
@@ -1698,7 +2124,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         );
         if (!fp.success) {
           throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
-            code: import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch
+            code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch
           });
         }
       }
@@ -1739,7 +2165,7 @@ var _LedgerAdapter = class _LedgerAdapter {
         );
         if (!fp.success) {
           throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
-            code: import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch
+            code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch
           });
         }
       }
@@ -1764,16 +2190,16 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
     const transportType = this.activeTransport ?? "hid";
     const waitPromise = this._uiRegistry.wait(
-      import_hwk_adapter_core2.UI_REQUEST.REQUEST_DEVICE_PERMISSION,
+      import_hwk_adapter_core3.UI_REQUEST.REQUEST_DEVICE_PERMISSION,
       { timeoutMs: 6e4 }
     );
-    this.emitter.emit(import_hwk_adapter_core2.UI_REQUEST.REQUEST_DEVICE_PERMISSION, {
-      type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_DEVICE_PERMISSION,
+    this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.REQUEST_DEVICE_PERMISSION, {
+      type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_DEVICE_PERMISSION,
       payload: { transportType, connectId, deviceId }
     });
     let response;
     const onAbort = () => {
-      this._uiRegistry.cancel(import_hwk_adapter_core2.UI_REQUEST.REQUEST_DEVICE_PERMISSION);
+      this._uiRegistry.cancel(import_hwk_adapter_core3.UI_REQUEST.REQUEST_DEVICE_PERMISSION);
     };
     try {
       signal?.addEventListener("abort", onAbort, { once: true });
@@ -1782,14 +2208,14 @@ var _LedgerAdapter = class _LedgerAdapter {
       if (signal?.aborted) {
         _LedgerAdapter._throwIfAborted(signal);
       }
-      if (err?._tag === import_hwk_adapter_core2.UI_REQUEST_PREEMPTED_TAG) {
-        this.emitter.emit(import_hwk_adapter_core2.UI_REQUEST.CLOSE_UI_WINDOW, {
-          type: import_hwk_adapter_core2.UI_REQUEST.CLOSE_UI_WINDOW,
+      if (err?._tag === import_hwk_adapter_core3.UI_REQUEST_PREEMPTED_TAG) {
+        this.emitter.emit(import_hwk_adapter_core3.UI_REQUEST.CLOSE_UI_WINDOW, {
+          type: import_hwk_adapter_core3.UI_REQUEST.CLOSE_UI_WINDOW,
           payload: {}
         });
         throw Object.assign(new Error("Device permission request superseded"), {
           _tag: ERROR_TAG.UserAborted,
-          code: import_hwk_adapter_core2.HardwareErrorCode.UserAborted,
+          code: import_hwk_adapter_core3.HardwareErrorCode.UserAborted,
           cause: err
         });
       }
@@ -1800,7 +2226,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     const { granted, reason, message } = response;
     if (!granted) {
       throw Object.assign(new Error(message ?? "Device permission denied"), {
-        code: import_hwk_adapter_core2.HardwareErrorCode.DevicePermissionDenied,
+        code: import_hwk_adapter_core3.HardwareErrorCode.DevicePermissionDenied,
         reason
       });
     }
@@ -1814,7 +2240,7 @@ var _LedgerAdapter = class _LedgerAdapter {
     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;
-      const params = e.code === import_hwk_adapter_core2.HardwareErrorCode.DevicePermissionDenied && e.reason ? { permissionDeniedReason: e.reason } : e.params;
+      const params = e.code === import_hwk_adapter_core3.HardwareErrorCode.DevicePermissionDenied && e.reason ? { permissionDeniedReason: e.reason } : e.params;
       return ledgerFailure(e.code, e.message ?? "Unknown error", e.appName, tag, params);
     }
     const mapped = mapLedgerError(err);
@@ -1861,10 +2287,13 @@ _LedgerAdapter.STUCK_APP_RETRY_DELAY_MS = 500;
 // Confirm but device never shows up / never unlocks), throw DeviceNotFound
 // instead of looping forever.
 _LedgerAdapter.MAX_DOCONNECT_CONFIRMS = 3;
+// Throttle AppInstallProgress by progress delta — DMK streams much faster
+// than UIs need. Final frame (progress >= 1) always passes.
+_LedgerAdapter.APP_INSTALL_PROGRESS_MIN_DELTA = 0.05;
 var LedgerAdapter = _LedgerAdapter;
 
 // src/connector/LedgerConnectorBase.ts
-var import_hwk_adapter_core12 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core13 = require("@onekeyfe/hwk-adapter-core");
 
 // src/device/LedgerDeviceManager.ts
 var LedgerDeviceManager = class {
@@ -2137,7 +2566,7 @@ var import_device_signer_kit_ethereum = require("@ledgerhq/device-signer-kit-eth
 var import_context_module = require("@ledgerhq/context-module");
 
 // src/signer/SignerEth.ts
-var import_hwk_adapter_core3 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core4 = require("@onekeyfe/hwk-adapter-core");
 
 // src/signer/deviceActionToPromise.ts
 var import_device_management_kit = require("@ledgerhq/device-management-kit");
@@ -2350,7 +2779,7 @@ var SignerEth = class {
     );
   }
   async signTransaction(derivationPath, serializedTxHex) {
-    const action = this._sdk.signTransaction(derivationPath, (0, import_hwk_adapter_core3.hexToBytes)(serializedTxHex));
+    const action = this._sdk.signTransaction(derivationPath, (0, import_hwk_adapter_core4.hexToBytes)(serializedTxHex));
     return deviceActionToPromise(
       action,
       this.onInteraction,
@@ -2359,7 +2788,7 @@ var SignerEth = class {
     );
   }
   async signMessage(derivationPath, message) {
-    const action = this._sdk.signMessage(derivationPath, (0, import_hwk_adapter_core3.hexToBytes)(message));
+    const action = this._sdk.signMessage(derivationPath, (0, import_hwk_adapter_core4.hexToBytes)(message));
     return deviceActionToPromise(
       action,
       this.onInteraction,
@@ -2419,23 +2848,23 @@ var SignerManager = class _SignerManager {
 };
 
 // src/connector/chains/evm.ts
-var import_hwk_adapter_core5 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core6 = require("@onekeyfe/hwk-adapter-core");
 
 // src/connector/chains/utils.ts
-var import_hwk_adapter_core4 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core5 = require("@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 import_hwk_adapter_core4.EConnectorInteraction.ConfirmOpenApp;
+      return import_hwk_adapter_core5.EConnectorInteraction.ConfirmOpenApp;
     case "unlock-device":
-      return import_hwk_adapter_core4.EConnectorInteraction.UnlockDevice;
+      return import_hwk_adapter_core5.EConnectorInteraction.UnlockDevice;
     case "interaction-complete":
-      return import_hwk_adapter_core4.EConnectorInteraction.InteractionComplete;
+      return import_hwk_adapter_core5.EConnectorInteraction.InteractionComplete;
     default:
-      return import_hwk_adapter_core4.EConnectorInteraction.ConfirmOnDevice;
+      return import_hwk_adapter_core5.EConnectorInteraction.ConfirmOnDevice;
   }
 }
 
@@ -2461,7 +2890,7 @@ async function evmSignTransaction(ctx, sessionId, params) {
       new Error(
         "Ledger requires a pre-serialized transaction (serializedTx). Provide an RLP-encoded hex string."
       ),
-      { code: import_hwk_adapter_core5.HardwareErrorCode.InvalidParams }
+      { code: import_hwk_adapter_core6.HardwareErrorCode.InvalidParams }
     );
   }
   const signer = await _getEthSigner(ctx, sessionId);
@@ -2470,8 +2899,8 @@ async function evmSignTransaction(ctx, sessionId, params) {
     const result = await signer.signTransaction(path, params.serializedTx);
     return {
       v: `0x${result.v.toString(16)}`,
-      r: (0, import_hwk_adapter_core5.padHex64)(result.r),
-      s: (0, import_hwk_adapter_core5.padHex64)(result.s)
+      r: (0, import_hwk_adapter_core6.padHex64)(result.r),
+      s: (0, import_hwk_adapter_core6.padHex64)(result.s)
     };
   } catch (err) {
     ctx.invalidateSession(sessionId);
@@ -2485,8 +2914,8 @@ async function evmSignMessage(ctx, sessionId, params) {
   const path = normalizePath(params.path);
   try {
     const result = await signer.signMessage(path, params.message);
-    const rHex = (0, import_hwk_adapter_core5.stripHex)(result.r).padStart(64, "0");
-    const sHex = (0, import_hwk_adapter_core5.stripHex)(result.s).padStart(64, "0");
+    const rHex = (0, import_hwk_adapter_core6.stripHex)(result.r).padStart(64, "0");
+    const sHex = (0, import_hwk_adapter_core6.stripHex)(result.s).padStart(64, "0");
     const vHex = result.v.toString(16).padStart(2, "0");
     return { signature: `0x${rHex}${sHex}${vHex}` };
   } catch (err) {
@@ -2502,15 +2931,15 @@ async function evmSignTypedData(ctx, sessionId, params) {
       new Error(
         'Ledger does not support hash-only EIP-712 signing. Use mode "full" with the complete typed data structure.'
       ),
-      { code: import_hwk_adapter_core5.HardwareErrorCode.MethodNotSupported }
+      { code: import_hwk_adapter_core6.HardwareErrorCode.MethodNotSupported }
     );
   }
   const signer = await _getEthSigner(ctx, sessionId);
   const path = normalizePath(params.path);
   try {
     const result = await signer.signTypedData(path, params.data);
-    const rHex = (0, import_hwk_adapter_core5.stripHex)(result.r).padStart(64, "0");
-    const sHex = (0, import_hwk_adapter_core5.stripHex)(result.s).padStart(64, "0");
+    const rHex = (0, import_hwk_adapter_core6.stripHex)(result.r).padStart(64, "0");
+    const sHex = (0, import_hwk_adapter_core6.stripHex)(result.s).padStart(64, "0");
     const vHex = result.v.toString(16).padStart(2, "0");
     return { signature: `0x${rHex}${sHex}${vHex}` };
   } catch (err) {
@@ -2537,13 +2966,13 @@ async function _getEthSigner(ctx, sessionId) {
 }
 
 // src/connector/chains/btc.ts
-var import_hwk_adapter_core7 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core8 = require("@onekeyfe/hwk-adapter-core");
 var import_bitcoinjs_lib = require("bitcoinjs-lib");
 
 // src/signer/SignerBtc.ts
-var import_hwk_adapter_core6 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core7 = require("@onekeyfe/hwk-adapter-core");
 function hexToUtf8(hex) {
-  return new TextDecoder().decode((0, import_hwk_adapter_core6.hexToBytes)(hex));
+  return new TextDecoder().decode((0, import_hwk_adapter_core7.hexToBytes)(hex));
 }
 var INTERACTIVE_TIMEOUT_MS2 = 5 * 6e4;
 var SignerBtc = class {
@@ -2658,7 +3087,7 @@ function _purposeToTemplate(purpose, DDT) {
       return DDT.TAPROOT;
     default:
       throw Object.assign(new Error(`Unsupported BTC purpose: m/${purpose ?? "<undefined>"}'`), {
-        code: import_hwk_adapter_core7.HardwareErrorCode.InvalidParams
+        code: import_hwk_adapter_core8.HardwareErrorCode.InvalidParams
       });
   }
 }
@@ -2714,7 +3143,7 @@ async function btcSignTransaction(ctx, sessionId, params) {
   if (!params.psbt) {
     throw Object.assign(
       new Error("Ledger requires PSBT format for BTC transaction signing. Provide params.psbt."),
-      { code: import_hwk_adapter_core7.HardwareErrorCode.InvalidParams }
+      { code: import_hwk_adapter_core8.HardwareErrorCode.InvalidParams }
     );
   }
   const btcSigner = await _createBtcSigner(ctx, sessionId);
@@ -2728,7 +3157,7 @@ async function btcSignTransaction(ctx, sessionId, params) {
     debugLog("[LedgerConnector] btcSignTransaction wallet:", { path, purpose, template });
     const wallet = new DefaultWallet(path, template);
     const signedTxHex = await btcSigner.signTransaction(wallet, params.psbt);
-    return { serializedTx: (0, import_hwk_adapter_core7.stripHex)(signedTxHex) };
+    return { serializedTx: (0, import_hwk_adapter_core8.stripHex)(signedTxHex) };
   } catch (err) {
     ctx.invalidateSession(sessionId);
     throw ctx.wrapError(err);
@@ -2739,7 +3168,7 @@ async function btcSignTransaction(ctx, sessionId, params) {
 async function btcSignPsbt(ctx, sessionId, params) {
   if (!params.psbt) {
     throw Object.assign(new Error("btcSignPsbt requires params.psbt"), {
-      code: import_hwk_adapter_core7.HardwareErrorCode.InvalidParams
+      code: import_hwk_adapter_core8.HardwareErrorCode.InvalidParams
     });
   }
   const btcSigner = await _createBtcSigner(ctx, sessionId);
@@ -2769,8 +3198,8 @@ async function btcSignMessage(ctx, sessionId, params) {
   try {
     const result = await btcSigner.signMessage(path, params.message);
     const vHex = result.v.toString(16).padStart(2, "0");
-    const rHex = (0, import_hwk_adapter_core7.stripHex)(result.r).padStart(64, "0");
-    const sHex = (0, import_hwk_adapter_core7.stripHex)(result.s).padStart(64, "0");
+    const rHex = (0, import_hwk_adapter_core8.stripHex)(result.r).padStart(64, "0");
+    const sHex = (0, import_hwk_adapter_core8.stripHex)(result.s).padStart(64, "0");
     return { signature: `${vHex}${rHex}${sHex}` };
   } catch (err) {
     ctx.invalidateSession(sessionId);
@@ -2870,7 +3299,7 @@ function _applySignaturesToPsbt(psbtHex, signatures) {
 }
 
 // src/connector/chains/sol.ts
-var import_hwk_adapter_core8 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core9 = require("@onekeyfe/hwk-adapter-core");
 
 // src/signer/SignerSol.ts
 var SignerSol = class {
@@ -2938,10 +3367,10 @@ async function solGetAddress(ctx, sessionId, params) {
 async function solSignTransaction(ctx, sessionId, params) {
   const solSigner = await _createSolSigner(ctx, sessionId);
   const path = normalizePath(params.path);
-  const txBytes = (0, import_hwk_adapter_core8.hexToBytes)(params.serializedTx);
+  const txBytes = (0, import_hwk_adapter_core9.hexToBytes)(params.serializedTx);
   try {
     const result = await solSigner.signTransaction(path, txBytes);
-    return { signature: (0, import_hwk_adapter_core8.bytesToHex)(result) };
+    return { signature: (0, import_hwk_adapter_core9.bytesToHex)(result) };
   } catch (err) {
     ctx.invalidateSession(sessionId);
     throw ctx.wrapError(err);
@@ -2952,7 +3381,7 @@ async function solSignTransaction(ctx, sessionId, params) {
 async function solSignMessage(ctx, sessionId, params) {
   const solSigner = await _createSolSigner(ctx, sessionId);
   const path = normalizePath(params.path);
-  const messageBytes = (0, import_hwk_adapter_core8.hexToBytes)(params.message);
+  const messageBytes = (0, import_hwk_adapter_core9.hexToBytes)(params.message);
   try {
     const result = await solSigner.signMessage(path, messageBytes);
     return { signature: result.signature };
@@ -2984,15 +3413,15 @@ async function _createSolSigner(ctx, sessionId) {
 }
 
 // src/connector/chains/tron.ts
-var import_hwk_adapter_core11 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core12 = require("@onekeyfe/hwk-adapter-core");
 var import_hw_app_trx = __toESM(require("@ledgerhq/hw-app-trx"));
 
 // src/connector/chains/legacyChainCall.ts
-var import_hwk_adapter_core10 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core11 = require("@onekeyfe/hwk-adapter-core");
 
 // src/app/AppManager.ts
 var import_device_management_kit2 = require("@ledgerhq/device-management-kit");
-var import_hwk_adapter_core9 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core10 = require("@onekeyfe/hwk-adapter-core");
 var APP_NAME_MAP = {
   ETH: "Ethereum",
   BTC: "Bitcoin",
@@ -3096,15 +3525,30 @@ var AppManager = class {
       command: new import_device_management_kit2.OpenAppCommand({ appName })
     });
     if (!(0, import_device_management_kit2.isSuccessCommandResult)(result)) {
-      const { statusCode } = result;
-      const hasStatusCode2 = statusCode != null && statusCode !== "";
-      debugLog("[AppManager] openApp failed:", appName, "statusCode:", statusCode);
+      const dmkErr = result.error;
+      const errorCode = "errorCode" in dmkErr && dmkErr.errorCode != null ? String(dmkErr.errorCode) : "";
+      const message = "message" in dmkErr && typeof dmkErr.message === "string" ? dmkErr.message : "";
+      debugLog(
+        "[AppManager] openApp failed:",
+        appName,
+        "errorCode:",
+        errorCode,
+        "tag:",
+        dmkErr._tag
+      );
+      let code;
+      if (errorCode === "6807" || /unknown application/i.test(message)) {
+        code = import_hwk_adapter_core10.HardwareErrorCode.AppNotInstalled;
+      } else if (errorCode === "5501" || dmkErr._tag === "ActionRefusedError") {
+        code = import_hwk_adapter_core10.HardwareErrorCode.UserRejected;
+      }
       throw Object.assign(new Error(`Failed to open "${appName}"`), {
         _tag: ERROR_TAG.OpenAppCommand,
-        code: hasStatusCode2 ? void 0 : import_hwk_adapter_core9.HardwareErrorCode.AppNotInstalled,
-        errorCode: String(statusCode ?? ""),
-        statusCode,
-        appName
+        code,
+        errorCode,
+        statusCode: errorCode,
+        appName,
+        originalError: dmkErr
       });
     }
   }
@@ -3157,14 +3601,14 @@ async function withLegacyChainCall(ctx, sessionId, options, action) {
   const onAppOpenPrompt = () => {
     openAppPromptShown = true;
     ctx.emit("ui-event", {
-      type: import_hwk_adapter_core10.EConnectorInteraction.ConfirmOpenApp,
+      type: import_hwk_adapter_core11.EConnectorInteraction.ConfirmOpenApp,
       payload: { sessionId }
     });
   };
   const closeOpenAppUiIfShown = () => {
     if (openAppPromptShown) {
       ctx.emit("ui-event", {
-        type: import_hwk_adapter_core10.EConnectorInteraction.InteractionComplete,
+        type: import_hwk_adapter_core11.EConnectorInteraction.InteractionComplete,
         payload: { sessionId }
       });
       openAppPromptShown = false;
@@ -3185,7 +3629,7 @@ async function withLegacyChainCall(ctx, sessionId, options, action) {
     let confirmEmitted = false;
     if (needsConfirmation) {
       ctx.emit("ui-event", {
-        type: import_hwk_adapter_core10.EConnectorInteraction.ConfirmOnDevice,
+        type: import_hwk_adapter_core11.EConnectorInteraction.ConfirmOnDevice,
         payload: { sessionId }
       });
       confirmEmitted = true;
@@ -3195,7 +3639,7 @@ async function withLegacyChainCall(ctx, sessionId, options, action) {
     } finally {
       if (confirmEmitted || openAppPromptShown) {
         ctx.emit("ui-event", {
-          type: import_hwk_adapter_core10.EConnectorInteraction.InteractionComplete,
+          type: import_hwk_adapter_core11.EConnectorInteraction.InteractionComplete,
           payload: { sessionId }
         });
         openAppPromptShown = false;
@@ -3283,7 +3727,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: import_hwk_adapter_core11.HardwareErrorCode.InvalidParams }
+      { code: import_hwk_adapter_core12.HardwareErrorCode.InvalidParams }
     );
   }
   const path = normalizePath(params.path);
@@ -3444,6 +3888,22 @@ var DeviceApps = class {
     );
     return result.filter((a) => a !== null).map(applicationToMetadata);
   }
+  /** Installed app names via ListApps APDU. Offline (no manager-api), but still requires unlock + dashboard. */
+  async listInstalledNames(options) {
+    const action = this._dmk.executeDeviceAction({
+      sessionId: this._sessionId,
+      deviceAction: new this._ledgerKit.ListAppsDeviceAction({
+        input: { unlockTimeout: options?.unlockTimeout }
+      })
+    });
+    const result = await deviceActionToPromise(
+      action,
+      this.onInteraction,
+      void 0,
+      this.onRegisterCanceller
+    );
+    return result.map((entry) => entry?.appName).filter((name) => typeof name === "string" && name.length > 0);
+  }
   // Catalog lookup via custom device action — DMK has no typed wrapper for this.
   async listAvailable() {
     const customAction = new ListAvailableAppsDeviceAction({
@@ -3507,6 +3967,22 @@ var DeviceApps = class {
   async install(appName, onProgress, options) {
     if (!appName) throw new Error("DeviceApps.install: appName is required");
     debugLog("[DeviceApps] install:", appName);
+    const refreshAction = this._dmk.executeDeviceAction({
+      sessionId: this._sessionId,
+      deviceAction: new this._ledgerKit.GetDeviceMetadataDeviceAction({
+        input: {
+          useSecureChannel: true,
+          forceUpdate: true,
+          unlockTimeout: options?.unlockTimeout
+        }
+      })
+    });
+    await deviceActionToPromise(
+      refreshAction,
+      this.onInteraction,
+      INSTALL_TIMEOUT_MS,
+      this.onRegisterCanceller
+    );
     const action = this._dmk.executeDeviceAction({
       sessionId: this._sessionId,
       deviceAction: new this._ledgerKit.InstallOrUpdateAppsDeviceAction({
@@ -3584,7 +4060,7 @@ var METHOD_PREFIX_TO_APP_NAME = {
   tron: "Tron"
 };
 var HARDWARE_ERROR_CODE_VALUES = new Set(
-  Object.values(import_hwk_adapter_core12.HardwareErrorCode).filter((value) => typeof value === "number")
+  Object.values(import_hwk_adapter_core13.HardwareErrorCode).filter((value) => typeof value === "number")
 );
 var BLE_CONNECT_SCAN_TIMEOUT_MS = 1500;
 async function defaultLedgerKitImporter(pkg) {
@@ -3707,7 +4183,7 @@ var LedgerConnectorBase = class {
   async searchDevices() {
     const dm = await this._getDeviceManager();
     const descriptors = await this._discoverDescriptors(dm);
-    const resolvedDescriptors = descriptors.map((d) => ({
+    const resolvedDescriptors = descriptors.filter((d) => !(0, import_hwk_adapter_core13.isKnownNonTargetHardwareVendor)(d, "ledger")).map((d) => ({
       descriptor: d,
       connectId: this._resolveConnectId(d)
     }));
@@ -3755,7 +4231,7 @@ var LedgerConnectorBase = class {
             `Ledger BLE connect did not return within ${HANG_CEILING_MS / 6e4}min \u2014 DMK hang fallback.`
           );
           err._tag = ERROR_TAG.BlePairingTimeout;
-          err.code = import_hwk_adapter_core12.HardwareErrorCode.BlePairingTimeout;
+          err.code = import_hwk_adapter_core13.HardwareErrorCode.BlePairingTimeout;
           reject(err);
         }, HANG_CEILING_MS);
       });
@@ -3788,7 +4264,7 @@ var LedgerConnectorBase = class {
         "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 = import_hwk_adapter_core12.HardwareErrorCode.DeviceNotFound;
+      err.code = import_hwk_adapter_core13.HardwareErrorCode.DeviceNotFound;
       throw err;
     };
     const doConnect = async (path) => {
@@ -3852,7 +4328,7 @@ var LedgerConnectorBase = class {
           "Ledger Bluetooth pairing failed. Make sure the device is unlocked and nearby, then try again."
         );
         wrapped._tag = ERROR_TAG.BleGattBondingFailed;
-        wrapped.code = import_hwk_adapter_core12.HardwareErrorCode.BlePairingTimeout;
+        wrapped.code = import_hwk_adapter_core13.HardwareErrorCode.BlePairingTimeout;
         wrapped.originalError = err;
         throw wrapped;
       }
@@ -3930,7 +4406,7 @@ var LedgerConnectorBase = class {
     this._unwatchSessionState(sessionId);
     this._signerManager?.invalidate(sessionId);
     this._cancellers.get(sessionId)?.({
-      code: import_hwk_adapter_core12.HardwareErrorCode.DeviceDisconnected,
+      code: import_hwk_adapter_core13.HardwareErrorCode.DeviceDisconnected,
       tag: "DeviceDisconnected",
       message: "Device disconnected"
     });
@@ -3954,9 +4430,9 @@ var LedgerConnectorBase = class {
       if (isAppStuckByApdu(err)) {
         return {
           success: false,
-          error: (0, import_hwk_adapter_core12.serializeConnectorError)(
+          error: (0, import_hwk_adapter_core13.serializeConnectorError)(
             Object.assign(new Error("Ledger app is unresponsive"), {
-              code: import_hwk_adapter_core12.HardwareErrorCode.DeviceAppStuck,
+              code: import_hwk_adapter_core13.HardwareErrorCode.DeviceAppStuck,
               _tag: ERROR_TAG.DeviceAppStuck,
               originalError: err
             })
@@ -3966,16 +4442,16 @@ var LedgerConnectorBase = class {
       if (isTransportStuck(err)) {
         return {
           success: false,
-          error: (0, import_hwk_adapter_core12.serializeConnectorError)(
+          error: (0, import_hwk_adapter_core13.serializeConnectorError)(
             Object.assign(new Error("Device communication interrupted, please retry"), {
-              code: import_hwk_adapter_core12.HardwareErrorCode.TransportError,
+              code: import_hwk_adapter_core13.HardwareErrorCode.TransportError,
               _tag: ERROR_TAG.DeviceTransportStuck,
               originalError: err
             })
           )
         };
       }
-      return { success: false, error: (0, import_hwk_adapter_core12.serializeConnectorError)(err) };
+      return { success: false, error: (0, import_hwk_adapter_core13.serializeConnectorError)(err) };
     }
   }
   async _dispatch(sessionId, method, params) {
@@ -4038,7 +4514,7 @@ var LedgerConnectorBase = class {
         try {
           return await apps.install(p.appName, ({ progress }) => {
             ctx.emit("ui-event", {
-              type: import_hwk_adapter_core12.EConnectorInteraction.AppInstallProgress,
+              type: import_hwk_adapter_core13.EConnectorInteraction.AppInstallProgress,
               payload: {
                 sessionId,
                 appName: p.appName,
@@ -4064,6 +4540,17 @@ var LedgerConnectorBase = class {
           ctx.clearCanceller(sessionId);
         }
       }
+      case "listInstalledNames": {
+        const apps = await _getDeviceApps(ctx, sessionId);
+        try {
+          return await apps.listInstalledNames(params);
+        } catch (err) {
+          ctx.invalidateSession(sessionId);
+          throw ctx.wrapError(err);
+        } finally {
+          ctx.clearCanceller(sessionId);
+        }
+      }
       case "listAvailableApps": {
         const apps = await _getDeviceApps(ctx, sessionId);
         try {