@onekeyfe/hwk-ledger-adapter 1.1.26 → 1.1.27-alpha.31

package/dist/index.js

@@ -39,12 +39,13 @@ __export(index_exports, {
   SignerEth: () => SignerEth,
   SignerManager: () => SignerManager,
   SignerSol: () => SignerSol,
-  debugLog: () => debugLog,
   deviceActionToPromise: () => deviceActionToPromise,
+  extractBleHexId: () => extractBleHexId,
   isDeviceLockedError: () => isDeviceLockedError,
   isLedgerBleConnectionType: () => isLedgerBleConnectionType,
   isLedgerBleDescriptor: () => isLedgerBleDescriptor,
   isLedgerDmkBleTransport: () => isLedgerDmkBleTransport,
+  isValidLedgerBleConnectId: () => isValidLedgerBleConnectId,
   ledgerFailure: () => ledgerFailure,
   mapLedgerError: () => mapLedgerError,
   offSdkEvent: () => offSdkEvent,
@@ -68,7 +69,7 @@ var LOCKED_ERROR_CODES = /* @__PURE__ */ new Set(["5515", "21781", "6982", "2701
 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_BLIND_SIGN_FALLBACK = "signer.eth.steps.blindSignTransactionFallback";
 function getEthAppErrorCode(err) {
   if (!err || typeof err !== "object") return null;
   const e = err;
@@ -133,8 +134,13 @@ function mapBtcAppError(hex) {
       return null;
   }
 }
-function mapEthAppErrorCode(ethCode) {
+function mapEthAppError(ethCode, lastStep) {
   switch (ethCode) {
+    case "6a80":
+      if (lastStep === STEP_BLIND_SIGN_FALLBACK) {
+        return import_hwk_adapter_core.HardwareErrorCode.EvmBlindSigningRequired;
+      }
+      return null;
     case "6984":
       return import_hwk_adapter_core.HardwareErrorCode.EvmClearSignPluginMissing;
     case "6a84":
@@ -147,20 +153,10 @@ function mapEthAppErrorCode(ethCode) {
       return null;
   }
 }
-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 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",
@@ -243,25 +239,6 @@ var CONNECTION_LEVEL_TAGS = /* @__PURE__ */ new Set([
   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;
@@ -283,35 +260,6 @@ 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;
@@ -344,8 +292,8 @@ function isAppNotInstalledError(err) {
 function isDeviceDisconnectedError(err) {
   if (!err || typeof err !== "object") return false;
   const e = err;
-  const tag = e._tag;
-  if (typeof tag === "string" && DEVICE_DISCONNECTED_TAGS.has(tag)) return true;
+  if (e._tag === ERROR_TAG.DeviceNotRecognized || e._tag === ERROR_TAG.DeviceSessionNotFound)
+    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"))
@@ -391,10 +339,8 @@ function mapLedgerError(err, opts) {
   let code;
   if (isDeviceLockedError(err)) {
     code = import_hwk_adapter_core.HardwareErrorCode.DeviceLocked;
-  } else if (isDeviceNotAdvertisingError(err) || isDeviceNotFoundError(err)) {
+  } else if (isDeviceNotAdvertisingError(err)) {
     code = import_hwk_adapter_core.HardwareErrorCode.DeviceNotFound;
-  } else if (isDeviceBusyError(err)) {
-    code = import_hwk_adapter_core.HardwareErrorCode.DeviceBusy;
   } else if (isBlePairingFailureError(err)) {
     code = import_hwk_adapter_core.HardwareErrorCode.BlePairingTimeout;
   } else if (isUserRejectedError(err)) {
@@ -408,7 +354,9 @@ function mapLedgerError(err, opts) {
   } else if (isTimeoutError(err)) {
     code = import_hwk_adapter_core.HardwareErrorCode.OperationTimeout;
   } else {
-    const ethMapped = classifyEthAppError(err);
+    const ethCode = getEthAppErrorCode(err);
+    const lastStep = err && typeof err === "object" ? err._lastStep : void 0;
+    const ethMapped = ethCode ? mapEthAppError(ethCode, lastStep) : null;
     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;
@@ -429,6 +377,9 @@ function isLedgerBleConnectionType(connectionType) {
 function isLedgerBleDescriptor(connectionType, descriptor) {
   return isLedgerBleConnectionType(connectionType) || isLedgerDmkBleTransport(descriptor.transport);
 }
+function isValidLedgerBleConnectId(connectId) {
+  return /^[0-9A-Fa-f]{4}$/.test(connectId ?? "");
+}
 
 // src/utils/sdkEventBus.ts
 var listeners = /* @__PURE__ */ new Set();
@@ -589,15 +540,9 @@ 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;
-    }
+  async searchDevices() {
     await this._ensureDevicePermission();
+    debugLog(`[LedgerAdapter] searchDevices() entry, cacheBefore=${this._discoveredDevices.size}`);
     const devices = await this.connector.searchDevices();
     this._discoveredDevices.clear();
     for (const d of devices) {
@@ -628,6 +573,16 @@ var _LedgerAdapter = class _LedgerAdapter {
         });
       }
       await this._ensureDevicePermission(connectId);
+      if (isLedgerBleConnectionType(this.connector.connectionType)) {
+        const fresh = (await this.searchDevices()).some((d) => d.connectId === connectId);
+        if (!fresh) {
+          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;
+          throw err;
+        }
+      }
       const session = await this.connector.connect(connectId);
       this._sessions.set(connectId, session.sessionId);
       if (session.deviceInfo) {
@@ -777,11 +732,21 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Chain fingerprint
   // ---------------------------------------------------------------------------
   async getChainFingerprint(connectId, deviceId, chain) {
+    debugLog(
+      "[LedgerAdapter] getChainFingerprint called, chain:",
+      chain,
+      "connectId:",
+      connectId || "(empty)",
+      "sessions:",
+      this._sessions.size
+    );
+    debugLog("[LedgerAdapter] getChainFingerprint permission ok, computing fingerprint");
     try {
       const fingerprint = await this._computeChainFingerprint(
         chain,
         (method, params) => this.connectorCall(connectId, method, params, void 0, deviceId)
       );
+      debugLog("[LedgerAdapter] getChainFingerprint result:", fingerprint?.substring(0, 20));
       return (0, import_hwk_adapter_core2.success)(fingerprint);
     } catch (err) {
       debugError("[LedgerAdapter] getChainFingerprint error:", chain, err);
@@ -975,22 +940,6 @@ var _LedgerAdapter = class _LedgerAdapter {
   // 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", {
@@ -1043,13 +992,9 @@ var _LedgerAdapter = class _LedgerAdapter {
         (d) => d.connectId === targetConnectId || d.deviceId === targetConnectId
       );
       if (!target) {
-        const err = Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
+        throw Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
           code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound
         });
-        if (isLedgerBleConnectionType(this.connector.connectionType)) {
-          err._tag = ERROR_TAG.DeviceNotAdvertising;
-        }
-        throw err;
       }
       return this._connectDeviceOrThrow(target.connectId);
     }
@@ -1190,6 +1135,14 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
     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: ERROR_TAG.DeviceSessionNotFound
@@ -1232,39 +1185,7 @@ var _LedgerAdapter = class _LedgerAdapter {
           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;
-        }
+        throw err;
       }
       if (isDeviceLockedError(err) || isDeviceNotAdvertisingError(err) || isDeviceDisconnectedError(err)) {
         let lastErr = err;
@@ -1338,54 +1259,6 @@ var _LedgerAdapter = class _LedgerAdapter {
       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 retryTargetConnectId = isLedgerBleConnectionType(this.connector.connectionType) ? resolvedConnectId : void 0;
-    const retryConnectId = await this.ensureConnected(retryTargetConnectId, signal);
-    const retrySessionId = this._sessions.get(retryConnectId);
-    if (!retrySessionId) throw originalErr;
-    if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
-      const fp = await this._abortable(
-        signal,
-        this._verifyDeviceFingerprintWithSession(
-          retrySessionId,
-          fingerprint.deviceId,
-          fingerprint.chain
-        )
-      );
-      if (!fp.success) {
-        throw Object.assign(new Error(formatDeviceMismatchError(fp.expected, fp.actual)), {
-          code: import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch
-        });
-      }
-    }
-    return this._abortable(signal, this.connector.call(retrySessionId, method, params));
-  }
-  _sleepAbortable(ms, signal) {
-    return new Promise((resolve, reject) => {
-      if (signal.aborted) {
-        reject(signal.reason ?? new Error("Aborted"));
-        return;
-      }
-      const timer = setTimeout(() => {
-        signal.removeEventListener("abort", onAbort);
-        resolve();
-      }, ms);
-      const onAbort = () => {
-        clearTimeout(timer);
-        reject(signal.reason ?? new Error("Aborted"));
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
-    });
-  }
   /**
    * Clear stale session, reconnect, and retry the call.
    *
@@ -1547,18 +1420,15 @@ 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: this.connector.connectionType,
-      rssi: device.rssi,
-      isConnectable: device.isConnectable,
-      serialNumber: device.serialNumber,
+      connectionType: isBle ? "ble" : "usb",
       capabilities: device.capabilities
     };
   }
@@ -1566,10 +1436,6 @@ var _LedgerAdapter = class _LedgerAdapter {
 // 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.
@@ -1577,7 +1443,7 @@ _LedgerAdapter.MAX_DOCONNECT_CONFIRMS = 3;
 var LedgerAdapter = _LedgerAdapter;
 
 // src/connector/LedgerConnectorBase.ts
-var import_hwk_adapter_core12 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core11 = require("@onekeyfe/hwk-adapter-core");
 
 // src/device/LedgerDeviceManager.ts
 var LedgerDeviceManager = class {
@@ -1616,7 +1482,7 @@ var LedgerDeviceManager = class {
           resolved = true;
           this._discovered.clear();
           debugLog(
-            `[DMK] enumerate count=${devices.length} ids=[${devices.map((d) => d.id).join(",")}]`
+            `[DMK] enumerate raw count=${devices.length} ids=[${devices.map((d) => d.id).join(",")}]`
           );
           for (const d of devices) {
             this._discovered.set(d.id, d);
@@ -1627,7 +1493,6 @@ var LedgerDeviceManager = class {
               devices.map((d) => ({
                 path: d.id,
                 type: d.deviceModel.model,
-                modelName: d.deviceModel.name,
                 name: d.name,
                 transport: d.transport,
                 rssi: d.rssi
@@ -1651,7 +1516,6 @@ var LedgerDeviceManager = class {
           devices.map((d) => ({
             path: d.id,
             type: d.deviceModel.model,
-            modelName: d.deviceModel.name,
             name: d.name,
             transport: d.transport,
             rssi: d.rssi
@@ -1678,7 +1542,6 @@ var LedgerDeviceManager = class {
               descriptor: {
                 path: d.id,
                 type: d.deviceModel.model,
-                modelName: d.deviceModel.name,
                 name: d.name,
                 transport: d.transport,
                 rssi: d.rssi
@@ -1769,29 +1632,11 @@ var LedgerDeviceManager = class {
   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) {
-      const err = new Error(
-        `Device "${deviceId}" not found in discovery cache. Call enumerate() or listen() first.`
-      );
-      err._tag = ERROR_TAG.DeviceNotInDiscoveryCache;
-      throw err;
+      throw new Error(`Device "${deviceId}" not found. Call enumerate() or listen() first.`);
     }
     const sessionId = await this._dmk.connect({ device });
     this._sessions.set(deviceId, sessionId);
@@ -1859,7 +1704,6 @@ function deviceActionToPromise(action, onInteraction, timeoutMs = IDLE_WATCHDOG_
   return new Promise((resolve, reject) => {
     let settled = false;
     let lastStep;
-    const observedSteps = [];
     let sub;
     let timer = null;
     const cancelAction = () => {
@@ -1919,12 +1763,7 @@ function deviceActionToPromise(action, onInteraction, timeoutMs = IDLE_WATCHDOG_
         }
         armIdleWatchdog();
         const step = state?.intermediateValue?.step;
-        if (step) {
-          lastStep = step;
-          if (observedSteps[observedSteps.length - 1] !== step) {
-            observedSteps.push(step);
-          }
-        }
+        if (step) lastStep = step;
         if (state.status === import_device_management_kit.DeviceActionStatus.Completed) {
           settled = true;
           if (timer) clearTimeout(timer);
@@ -1936,7 +1775,7 @@ function deviceActionToPromise(action, onInteraction, timeoutMs = IDLE_WATCHDOG_
           if (timer) clearTimeout(timer);
           onInteraction?.("interaction-complete");
           sub?.unsubscribe();
-          rejectWithStepContext(state.error, lastStep, observedSteps, reject);
+          rejectWithLastStep(state.error, lastStep, reject);
         } else if (state.status === import_device_management_kit.DeviceActionStatus.Pending && onInteraction) {
           const interaction = state.intermediateValue?.requiredUserInteraction;
           if (interaction && interaction !== "none") {
@@ -1953,7 +1792,7 @@ function deviceActionToPromise(action, onInteraction, timeoutMs = IDLE_WATCHDOG_
           settled = true;
           if (timer) clearTimeout(timer);
           sub?.unsubscribe();
-          rejectWithStepContext(err, lastStep, observedSteps, reject);
+          rejectWithLastStep(err, lastStep, reject);
         }
       },
       complete: () => {
@@ -1966,25 +1805,15 @@ function deviceActionToPromise(action, onInteraction, timeoutMs = IDLE_WATCHDOG_
     });
   });
 }
-function rejectWithStepContext(err, lastStep, observedSteps, reject) {
-  if (err && typeof err === "object" && (lastStep || observedSteps.length > 0)) {
+function rejectWithLastStep(err, lastStep, reject) {
+  if (err && typeof err === "object" && lastStep) {
     try {
-      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
-        });
-      }
+      Object.defineProperty(err, "_lastStep", {
+        value: lastStep,
+        configurable: true,
+        enumerable: false,
+        writable: true
+      });
     } catch {
     }
   }
@@ -2050,8 +1879,7 @@ var SignerManager = class _SignerManager {
   async getOrCreate(sessionId) {
     debugLog("[DMK] SignerManager.getOrCreate:", { sessionId });
     const builder = await this._builderFn({ dmk: this._dmk, sessionId });
-    const builderWithContext = builder.withContextModule ? builder.withContextModule(_SignerManager._createContextModule()) : builder;
-    return new SignerEth(builderWithContext.build());
+    return new SignerEth(builder.build());
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
   invalidate(_sessionId) {
@@ -2060,24 +1888,10 @@ var SignerManager = class _SignerManager {
   clearAll() {
   }
   static _defaultBuilder() {
-    return (args) => new import_device_signer_kit_ethereum.SignerEthBuilder(args);
-  }
-  static _createContextModule() {
-    const contextModule = new import_context_module.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 (args) => {
+      const contextModule = new import_context_module.ContextModuleBuilder({}).removeDefaultLoaders().build();
+      return new import_device_signer_kit_ethereum.SignerEthBuilder(args).withContextModule(contextModule);
     };
-    return contextModule;
   }
 };
 
@@ -2647,15 +2461,14 @@ async function _createSolSigner(ctx, sessionId) {
 }
 
 // src/connector/chains/tron.ts
-var import_hwk_adapter_core11 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core10 = 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_core9 = 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 APP_NAME_MAP = {
   ETH: "Ethereum",
   BTC: "Bitcoin",
@@ -2760,11 +2573,9 @@ var AppManager = class {
     });
     if (!(0, import_device_management_kit2.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: ERROR_TAG.OpenAppCommand,
-        code: hasStatusCode2 ? void 0 : import_hwk_adapter_core9.HardwareErrorCode.AppNotInstalled,
         errorCode: String(statusCode ?? ""),
         statusCode,
         appName
@@ -2820,14 +2631,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_core9.EConnectorInteraction.ConfirmOpenApp,
       payload: { sessionId }
     });
   };
   const closeOpenAppUiIfShown = () => {
     if (openAppPromptShown) {
       ctx.emit("ui-event", {
-        type: import_hwk_adapter_core10.EConnectorInteraction.InteractionComplete,
+        type: import_hwk_adapter_core9.EConnectorInteraction.InteractionComplete,
         payload: { sessionId }
       });
       openAppPromptShown = false;
@@ -2848,7 +2659,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_core9.EConnectorInteraction.ConfirmOnDevice,
         payload: { sessionId }
       });
       confirmEmitted = true;
@@ -2858,7 +2669,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_core9.EConnectorInteraction.InteractionComplete,
           payload: { sessionId }
         });
         openAppPromptShown = false;
@@ -2946,7 +2757,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_core10.HardwareErrorCode.InvalidParams }
     );
   }
   const path = normalizePath(params.path);
@@ -2990,10 +2801,6 @@ var METHOD_PREFIX_TO_APP_NAME = {
   sol: "Solana",
   tron: "Tron"
 };
-var HARDWARE_ERROR_CODE_VALUES = new Set(
-  Object.values(import_hwk_adapter_core12.HardwareErrorCode).filter((value) => typeof value === "number")
-);
-var BLE_CONNECT_SCAN_TIMEOUT_MS = 1500;
 async function defaultLedgerKitImporter(pkg) {
   switch (pkg) {
     case "@ledgerhq/device-management-kit":
@@ -3017,6 +2824,16 @@ 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
@@ -3041,7 +2858,6 @@ var LedgerConnectorBase = class {
     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);
     }
@@ -3059,13 +2875,22 @@ var LedgerConnectorBase = class {
       importLedgerKit: this._importLedgerKit
     };
   }
+  // "D5:75:7D:4B:51:E8" -> "A58F"
+  /** 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 only when the public connectId differs from the transport path.
+   * Override in subclasses to extract stable identifiers (e.g. BLE hex ID).
    */
   _resolveConnectId(descriptor) {
     return descriptor.path;
@@ -3090,22 +2915,50 @@ var LedgerConnectorBase = class {
   // IConnector -- Device discovery
   // ---------------------------------------------------------------------------
   async searchDevices() {
+    debugLog("[DMK] connector.searchDevices() entry");
     const dm = await this._getDeviceManager();
     const descriptors = await this._discoverDescriptors(dm);
     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
-    }));
+    const bleConnectIdCounts = /* @__PURE__ */ new Map();
+    for (const item of resolvedDescriptors) {
+      if (isLedgerBleDescriptor(this.connectionType, item.descriptor)) {
+        if (!isValidLedgerBleConnectId(item.connectId)) {
+          debugLog(`[DMK] connector.searchDevices() invalid BLE connectId=${item.connectId}`);
+          throw Object.assign(
+            new Error("Ledger BLE connectId must be the 4-character BLE identifier"),
+            { code: import_hwk_adapter_core11.HardwareErrorCode.DeviceNotFound }
+          );
+        }
+        bleConnectIdCounts.set(item.connectId, (bleConnectIdCounts.get(item.connectId) ?? 0) + 1);
+      }
+    }
+    const duplicateBleConnectId = Array.from(bleConnectIdCounts.entries()).find(
+      ([, count]) => count > 1
+    )?.[0];
+    if (duplicateBleConnectId) {
+      debugLog(
+        `[DMK] connector.searchDevices() duplicate BLE connectId=${duplicateBleConnectId} counts=${JSON.stringify(
+          Array.from(bleConnectIdCounts.entries())
+        )}`
+      );
+      throw Object.assign(
+        new Error(`Duplicate Ledger BLE connectId detected: ${duplicateBleConnectId}`),
+        { code: import_hwk_adapter_core11.HardwareErrorCode.DeviceNotFound }
+      );
+    }
+    const result = resolvedDescriptors.map(({ descriptor: d, connectId }) => {
+      this._connectIdToPath.set(connectId, d.path);
+      this._pathToConnectId.set(d.path, connectId);
+      return {
+        connectId,
+        deviceId: d.path,
+        name: d.name || d.type || "Ledger",
+        model: d.type
+      };
+    });
     debugLog(
       `[DMK] connector.searchDevices() return count=${result.length} ids=[${result.map((r) => r.connectId).join(",")}] paths=[${result.map((r) => r.deviceId).join(",")}]`
     );
@@ -3115,8 +2968,7 @@ var LedgerConnectorBase = class {
   // IConnector -- Connection
   // ---------------------------------------------------------------------------
   async connect(deviceId) {
-    const callerSuppliedConnectId = Boolean(deviceId);
-    let targetPath = deviceId;
+    let targetPath = deviceId ? this._getPathForConnectId(deviceId) : void 0;
     if (!targetPath) {
       const discovered = await this.searchDevices();
       if (discovered.length === 0) {
@@ -3126,7 +2978,7 @@ var LedgerConnectorBase = class {
       }
       targetPath = discovered[0].deviceId;
     }
-    const externalConnectId = targetPath;
+    const externalConnectId = this._getConnectIdForPath(targetPath);
     const HANG_CEILING_MS = 5 * 6e4;
     const dmConnectWithObserve = async (dm, path) => {
       if (!isLedgerBleConnectionType(this.connectionType)) return dm.connect(path);
@@ -3140,7 +2992,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_core11.HardwareErrorCode.BlePairingTimeout;
           reject(err);
         }, HANG_CEILING_MS);
       });
@@ -3167,45 +3019,19 @@ var LedgerConnectorBase = class {
         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 = import_hwk_adapter_core12.HardwareErrorCode.DeviceNotFound;
-      throw err;
-    };
     const doConnect = async (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;
-      }
+      const sessionId = await dmConnectWithObserve(dm, path);
       this._watchSessionState(sessionId, externalConnectId);
-      const info = dm.getDiscoveredDeviceInfo(path);
       const session = {
         sessionId,
         deviceInfo: {
           vendor: "ledger",
-          model: info?.model ?? "unknown",
-          modelName: info?.modelName,
+          model: "unknown",
           firmwareVersion: "unknown",
           deviceId: path,
           connectId: externalConnectId,
           connectionType: this.connectionType,
-          rssi: info?.rssi,
           capabilities: { persistentDeviceIdentity: false }
         }
       };
@@ -3228,7 +3054,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_core11.HardwareErrorCode.BlePairingTimeout;
         wrapped.originalError = err;
         throw wrapped;
       }
@@ -3311,7 +3137,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_core11.HardwareErrorCode.DeviceDisconnected,
       tag: "DeviceDisconnected",
       message: "Device disconnected"
     });
@@ -3328,14 +3154,14 @@ var LedgerConnectorBase = class {
     } catch (err) {
       if (isAppStuckByApdu(err)) {
         throw Object.assign(new Error("Ledger app is unresponsive"), {
-          code: import_hwk_adapter_core12.HardwareErrorCode.DeviceAppStuck,
+          code: import_hwk_adapter_core11.HardwareErrorCode.DeviceAppStuck,
           _tag: ERROR_TAG.DeviceAppStuck,
           originalError: err
         });
       }
       if (isTransportStuck(err)) {
         throw Object.assign(new Error("Device communication interrupted, please retry"), {
-          code: import_hwk_adapter_core12.HardwareErrorCode.TransportError,
+          code: import_hwk_adapter_core11.HardwareErrorCode.TransportError,
           _tag: ERROR_TAG.DeviceTransportStuck,
           originalError: err
         });
@@ -3483,13 +3309,14 @@ var LedgerConnectorBase = class {
   }
   /**
    * Replace an old session with a new one after app switch.
-   * Emits device-connect so the adapter updates its _sessions Map.
+   * Updates the connectId→path mapping so subsequent calls() use the new session,
+   * and emits device-connect so the adapter updates its _sessions Map.
    */
   _replaceSession(oldSessionId, _newSessionId) {
     const dm = this._deviceManager;
     if (!dm) return;
     const oldDeviceId = dm.getDeviceId(oldSessionId);
-    const connectId = oldDeviceId;
+    const connectId = oldDeviceId ? this._pathToConnectId.get(oldDeviceId) : void 0;
     this._signerManager?.invalidate(oldSessionId);
     if (connectId) {
       this._emit("device-connect", {
@@ -3502,7 +3329,7 @@ var LedgerConnectorBase = class {
     }
   }
   /**
-   * Light reset: clear signer/session state but keep DMK alive.
+   * Light reset: clear signer/session state but keep DMK and ID mapping 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
@@ -3537,6 +3364,8 @@ var LedgerConnectorBase = class {
     this._deviceManager = null;
     this._signerManager = null;
     this._dmk = null;
+    this._connectIdToPath.clear();
+    this._pathToConnectId.clear();
   }
   // ---------------------------------------------------------------------------
   // Private -- Events
@@ -3570,21 +3399,15 @@ var LedgerConnectorBase = class {
     };
   }
   _wrapError(err, opts) {
+    const mapped = mapLedgerError(err, opts);
     const src = err && typeof err === "object" ? err : {};
-    const hasSerializedCode = typeof src.code === "number" && HARDWARE_ERROR_CODE_VALUES.has(src.code);
-    const mapped = hasSerializedCode ? {
-      code: src.code,
-      message: typeof src.message === "string" ? src.message : "Unknown Ledger error",
-      appName: typeof src.appName === "string" ? src.appName : opts?.defaultAppName
-    } : mapLedgerError(err, opts);
     const error = new Error(mapped.message);
     Object.assign(error, {
       code: mapped.code,
       appName: mapped.appName,
       _tag: src._tag,
       errorCode: src.errorCode,
-      _lastStep: src._lastStep,
-      _deviceActionSteps: src._deviceActionSteps
+      _lastStep: src._lastStep
     });
     Object.defineProperty(error, "originalError", {
       value: err,
@@ -3595,6 +3418,13 @@ 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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AppManager,
@@ -3606,12 +3436,13 @@ var LedgerConnectorBase = class {
   SignerEth,
   SignerManager,
   SignerSol,
-  debugLog,
   deviceActionToPromise,
+  extractBleHexId,
   isDeviceLockedError,
   isLedgerBleConnectionType,
   isLedgerBleDescriptor,
   isLedgerDmkBleTransport,
+  isValidLedgerBleConnectId,
   ledgerFailure,
   mapLedgerError,
   offSdkEvent,