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

package/dist/index.mjs

@@ -16,12 +16,6 @@ import {
 
 // src/errors.ts
 import { HardwareErrorCode, enrichErrorMessage } from "@onekeyfe/hwk-adapter-core";
-var MULTIPLE_USB_LEDGER_DEVICES_ERROR_MESSAGE = "Multiple Ledger USB devices are connected. Please connect only one Ledger device and try again.";
-function createMultipleUsbLedgerDevicesError() {
-  return Object.assign(new Error(MULTIPLE_USB_LEDGER_DEVICES_ERROR_MESSAGE), {
-    code: HardwareErrorCode.DeviceOneDeviceOnly
-  });
-}
 function ledgerFailure(code, error, appName, tag, params) {
   const payload = { error, code };
   if (appName !== void 0) payload.appName = appName;
@@ -453,7 +447,7 @@ function btcAccountIndexFromPath(path) {
   return Number.isFinite(accountIndex) ? accountIndex : null;
 }
 var _LedgerAdapter = class _LedgerAdapter {
-  constructor(connector) {
+  constructor(connector, options) {
     this.vendor = "ledger";
     this.emitter = new TypedEventEmitter();
     this._discoveredDevices = /* @__PURE__ */ new Map();
@@ -475,7 +469,7 @@ var _LedgerAdapter = class _LedgerAdapter {
      *
      * - If a session already exists for the given connectId, reuse it.
      * - If ANY session exists (Ledger IDs are ephemeral), reuse it.
-     * - Otherwise: search → exactly 1 USB device auto-connects; multiple or none throws.
+     * - Otherwise: search → 1 device: auto-connect, multiple: ask user, 0: throw.
      */
     // Mutex for ensureConnected — prevents concurrent calls from establishing duplicate connections
     this._connectingPromise = null;
@@ -506,6 +500,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       this.emitter.emit("ui-event", event);
     };
     this.connector = connector;
+    this._handleSelectDevice = options?.handleSelectDevice ?? false;
     this._jobQueue = new DeviceJobQueue();
     this.registerEventListeners();
   }
@@ -579,18 +574,6 @@ var _LedgerAdapter = class _LedgerAdapter {
     );
     return Array.from(this._discoveredDevices.values());
   }
-  // USB single-session invariant: evict all sessions, best-effort (see connectDevice).
-  async _evictAllSessions() {
-    if (this._sessions.size === 0) return;
-    const stale = [...this._sessions.values()];
-    this._sessions.clear();
-    for (const sid of stale) {
-      try {
-        await this.connector.disconnect(sid);
-      } catch {
-      }
-    }
-  }
   static _createDeviceBusyError(method) {
     return Object.assign(new Error(`Ledger device is busy while calling ${method}`), {
       code: HardwareErrorCode2.DeviceBusy
@@ -603,9 +586,6 @@ var _LedgerAdapter = class _LedgerAdapter {
           code: HardwareErrorCode2.DeviceNotFound
         });
       }
-      if (!isLedgerBleConnectionType(this.connector.connectionType)) {
-        await this._evictAllSessions();
-      }
       await this._ensureDevicePermission(connectId);
       const session = await this.connector.connect(connectId);
       this._sessions.set(connectId, session.sessionId);
@@ -933,15 +913,7 @@ var _LedgerAdapter = class _LedgerAdapter {
       });
     }
     if (connectId && this._sessions.has(connectId)) return connectId;
-    if (!connectId && this._sessions.size > 0) {
-      if (!isLedgerBleConnectionType(this.connector.connectionType) && this._sessions.size > 1) {
-        throw Object.assign(
-          new Error(
-            "Ledger USB session invariant violated: more than one session is active. Please reconnect the device."
-          ),
-          { code: HardwareErrorCode2.DeviceOneDeviceOnly }
-        );
-      }
+    if (this._sessions.size > 0) {
       return this._sessions.keys().next().value;
     }
     if (!this._connectingPromise) {
@@ -1029,37 +1001,24 @@ var _LedgerAdapter = class _LedgerAdapter {
       const target = devices.find(
         (d) => d.connectId === targetConnectId || d.deviceId === targetConnectId
       );
-      if (target) {
-        return this._connectDeviceOrThrow(target.connectId);
-      }
-      if (!isLedgerBleConnectionType(this.connector.connectionType) && devices.length === 1) {
-        debugLog(
-          `[LedgerAdapter] target ${targetConnectId} not in fresh enumeration; accepting sole USB device ${devices[0].connectId} (assumed ephemeral path change)`
-        );
-        return this._connectDeviceOrThrow(devices[0].connectId);
-      }
-      const err = Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
-        code: HardwareErrorCode2.DeviceNotFound
-      });
-      if (isLedgerBleConnectionType(this.connector.connectionType)) {
-        err._tag = ERROR_TAG.DeviceNotAdvertising;
+      if (!target) {
+        const err = Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
+          code: HardwareErrorCode2.DeviceNotFound
+        });
+        if (isLedgerBleConnectionType(this.connector.connectionType)) {
+          err._tag = ERROR_TAG.DeviceNotAdvertising;
+        }
+        throw err;
       }
-      throw err;
+      return this._connectDeviceOrThrow(target.connectId);
     }
     if (isLedgerBleConnectionType(this.connector.connectionType)) {
       throw Object.assign(new Error("Ledger BLE connectId is required."), {
         code: HardwareErrorCode2.DeviceNotFound
       });
     }
-    if (devices.length > 1) {
-      throw createMultipleUsbLedgerDevicesError();
-    }
-    if (devices.length !== 1) {
-      throw Object.assign(new Error("Ledger device not found."), {
-        code: HardwareErrorCode2.DeviceNotFound
-      });
-    }
-    return this._connectDeviceOrThrow(devices[0].connectId);
+    const chosenConnectId = devices.length === 1 ? devices[0].connectId : await this._chooseDeviceFromList(devices);
+    return this._connectDeviceOrThrow(chosenConnectId);
   }
   async _connectDeviceOrThrow(chosenConnectId) {
     const result = await this.connectDevice(chosenConnectId);
@@ -1075,6 +1034,46 @@ var _LedgerAdapter = class _LedgerAdapter {
     }
     return chosenConnectId;
   }
+  async _chooseDeviceFromList(devices) {
+    if (!this._handleSelectDevice) {
+      debugLog(
+        `[DMK] Multiple Ledger devices found (${devices.length}); handleSelectDevice=false, picking first (${devices[0].connectId}).`
+      );
+      return devices[0].connectId;
+    }
+    let response;
+    try {
+      const waitPromise = this._uiRegistry.wait(
+        UI_REQUEST.REQUEST_SELECT_DEVICE
+      );
+      this.emitter.emit(UI_REQUEST.REQUEST_SELECT_DEVICE, {
+        type: UI_REQUEST.REQUEST_SELECT_DEVICE,
+        payload: { devices }
+      });
+      response = await waitPromise;
+    } catch (err) {
+      if (err?._tag === UI_REQUEST_PREEMPTED_TAG) {
+        this.emitter.emit(UI_REQUEST.CLOSE_UI_WINDOW, {
+          type: UI_REQUEST.CLOSE_UI_WINDOW,
+          payload: {}
+        });
+        throw Object.assign(new Error("Device selection superseded"), {
+          _tag: ERROR_TAG.UserAborted,
+          code: HardwareErrorCode2.UserAborted,
+          cause: err
+        });
+      }
+      throw err;
+    }
+    const chosen = devices.find((d) => d.connectId === response?.sdkConnectId);
+    if (!chosen) {
+      throw Object.assign(
+        new Error(`Selected sdkConnectId '${response?.sdkConnectId}' not in discovered list`),
+        { _tag: ERROR_TAG.DeviceNotRecognized }
+      );
+    }
+    return chosen.connectId;
+  }
   /**
    * Call the connector with automatic session resolution and disconnect retry.
    *
@@ -1239,7 +1238,8 @@ var _LedgerAdapter = class _LedgerAdapter {
               } catch {
               }
             }
-            const reConnectId = await this.ensureConnected(resolvedConnectId, signal);
+            const retryConnectId = isLedgerBleConnectionType(this.connector.connectionType) ? resolvedConnectId : void 0;
+            const reConnectId = await this.ensureConnected(retryConnectId, signal);
             const reSessionId = this._sessions.get(reConnectId);
             if (!reSessionId) throw lastErr;
             if (fingerprint && !fingerprint.skipFingerprint && fingerprint.deviceId) {
@@ -1307,7 +1307,8 @@ var _LedgerAdapter = class _LedgerAdapter {
    */
   async _retryAfterStuckApp(resolvedConnectId, method, params, signal, originalErr, fingerprint) {
     await this._sleepAbortable(_LedgerAdapter.STUCK_APP_RETRY_DELAY_MS, signal);
-    const retryConnectId = await this.ensureConnected(resolvedConnectId, signal);
+    const 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) {
@@ -3051,12 +3052,6 @@ var LedgerConnectorBase = class {
   }
   // ---------------------------------------------------------------------------
   // IConnector -- Device discovery
-  //
-  // Discovery never throws on multiple USB devices — it returns the full list.
-  // The "connect exactly one device" rule is enforced upstream: an explicit
-  // connectId connects that device (or fails as not-found), and only the
-  // no-connectId USB path rejects when more than one device is present
-  // (see LedgerAdapter._connectFirstOrSelect).
   // ---------------------------------------------------------------------------
   async searchDevices() {
     const dm = await this._getDeviceManager();
@@ -3162,16 +3157,7 @@ var LedgerConnectorBase = class {
         }
         throw err;
       }
-      try {
-        this._watchSessionState(sessionId, externalConnectId);
-      } catch (subErr) {
-        debugLog("[DMK] state subscription failed during connect; disconnecting session:", subErr);
-        try {
-          await dm.disconnect(sessionId);
-        } catch {
-        }
-        throw subErr;
-      }
+      this._watchSessionState(sessionId, externalConnectId);
       const info = dm.getDiscoveredDeviceInfo(path);
       const session = {
         sessionId,
@@ -3237,7 +3223,8 @@ var LedgerConnectorBase = class {
    * `LedgerAdapter._sessions` map would hold a dead session entry until
    * the next call hit `DeviceSessionNotFound`.
    *
-   * Subscribe failure is fatal — see the inline note at the subscribe call.
+   * Best-effort: any error subscribing is swallowed so a flaky DMK
+   * doesn't break the connect path.
    */
   _watchSessionState(sessionId, externalConnectId) {
     const dmk = this._dmk;
@@ -3249,20 +3236,24 @@ var LedgerConnectorBase = class {
       } catch {
       }
     }
-    const sub = dmk.getDeviceSessionState({ sessionId }).subscribe({
-      next: (state) => {
-        if (state?.deviceStatus === "NOT CONNECTED") {
+    try {
+      const sub = dmk.getDeviceSessionState({ sessionId }).subscribe({
+        next: (state) => {
+          if (state?.deviceStatus === "NOT CONNECTED") {
+            this._handleAutonomousDisconnect(sessionId, externalConnectId);
+          }
+        },
+        error: () => {
+          this._handleAutonomousDisconnect(sessionId, externalConnectId);
+        },
+        complete: () => {
           this._handleAutonomousDisconnect(sessionId, externalConnectId);
         }
-      },
-      error: () => {
-        this._handleAutonomousDisconnect(sessionId, externalConnectId);
-      },
-      complete: () => {
-        this._handleAutonomousDisconnect(sessionId, externalConnectId);
-      }
-    });
-    this._sessionStateSubs.set(sessionId, sub);
+      });
+      this._sessionStateSubs.set(sessionId, sub);
+    } catch (err) {
+      debugLog("[DMK] _watchSessionState subscribe failed:", err);
+    }
   }
   _unwatchSessionState(sessionId) {
     const sub = this._sessionStateSubs.get(sessionId);