@onekeyfe/hwk-ledger-adapter 1.1.26-alpha.13 → 1.1.26-alpha.14

package/dist/index.js

@@ -39,13 +39,12 @@ __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,
@@ -160,6 +159,8 @@ var ERROR_TAG = {
   // SDK-mint
   DeviceNotAdvertising: "DeviceNotAdvertisingError",
   // BLE scan miss
+  DeviceNotInDiscoveryCache: "DeviceNotInDiscoveryCacheError",
+  // dm.connect() before enumerate
   BlePairingTimeout: "BlePairingTimeoutError",
   // SMP 30s timeout
   BleGattBondingFailed: "BleGattBondingFailedError",
@@ -425,9 +426,6 @@ 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();
@@ -588,21 +586,16 @@ var _LedgerAdapter = class _LedgerAdapter {
   // ---------------------------------------------------------------------------
   // Device management
   // ---------------------------------------------------------------------------
-  async searchDevices() {
+  async searchDevices(options) {
+    if (options?.resetSession) {
+      this._doConnectAbortController?.abort();
+      this._sessions.clear();
+      this._connectingPromise = null;
+      this._doConnectAbortController = null;
+      this._btcHighIndexConfirmedThisSession = false;
+    }
     await this._ensureDevicePermission();
-    debugLog(`[LedgerAdapter] searchDevices() entry, cacheBefore=${this._discoveredDevices.size}`);
     const devices = await this.connector.searchDevices();
-    debugLog(
-      "[DMK] adapter.searchDevices raw:",
-      devices.map((device) => ({
-        id: device?.deviceId,
-        deviceId: device?.deviceId,
-        connectId: device?.connectId,
-        deviceName: device?.name,
-        "device.name": device?.name,
-        model: device?.model
-      }))
-    );
     this._discoveredDevices.clear();
     for (const d of devices) {
       if (d.connectId) {
@@ -632,16 +625,6 @@ 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) {
@@ -791,21 +774,11 @@ 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);
@@ -999,6 +972,22 @@ 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", {
@@ -1051,9 +1040,13 @@ var _LedgerAdapter = class _LedgerAdapter {
         (d) => d.connectId === targetConnectId || d.deviceId === targetConnectId
       );
       if (!target) {
-        throw Object.assign(new Error(`Target Ledger unavailable: ${targetConnectId}`), {
+        const err = 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);
     }
@@ -1194,14 +1187,6 @@ 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
@@ -1559,15 +1544,18 @@ var _LedgerAdapter = class _LedgerAdapter {
   // Device info mapping
   // ---------------------------------------------------------------------------
   connectorDeviceToDeviceInfo(device) {
-    const isBle = device.connectId && /^[0-9A-Fa-f]{4}$/.test(device.connectId);
     return {
       vendor: "ledger",
       model: device.model ?? "unknown",
+      modelName: device.modelName,
       firmwareVersion: "",
       deviceId: device.deviceId,
       connectId: device.connectId,
       label: device.name,
-      connectionType: isBle ? "ble" : "usb",
+      connectionType: this.connector.connectionType,
+      rssi: device.rssi,
+      isConnectable: device.isConnectable,
+      serialNumber: device.serialNumber,
       capabilities: device.capabilities
     };
   }
@@ -1625,7 +1613,7 @@ var LedgerDeviceManager = class {
           resolved = true;
           this._discovered.clear();
           debugLog(
-            `[DMK] enumerate raw count=${devices.length} ids=[${devices.map((d) => d.id).join(",")}]`
+            `[DMK] enumerate count=${devices.length} ids=[${devices.map((d) => d.id).join(",")}]`
           );
           for (const d of devices) {
             this._discovered.set(d.id, d);
@@ -1636,6 +1624,7 @@ 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
@@ -1659,6 +1648,7 @@ 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
@@ -1685,6 +1675,7 @@ var LedgerDeviceManager = class {
               descriptor: {
                 path: d.id,
                 type: d.deviceModel.model,
+                modelName: d.deviceModel.name,
                 name: d.name,
                 transport: d.transport,
                 rssi: d.rssi
@@ -1775,11 +1766,29 @@ 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) {
-      throw new Error(`Device "${deviceId}" not found. Call enumerate() or listen() first.`);
+      const err = new Error(
+        `Device "${deviceId}" not found in discovery cache. Call enumerate() or listen() first.`
+      );
+      err._tag = ERROR_TAG.DeviceNotInDiscoveryCache;
+      throw err;
     }
     const sessionId = await this._dmk.connect({ device });
     this._sessions.set(deviceId, sessionId);
@@ -2981,6 +2990,7 @@ var METHOD_PREFIX_TO_APP_NAME = {
 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":
@@ -3004,16 +3014,6 @@ var LedgerConnectorBase = class {
     this._dmk = null;
     this._eventHandlers = /* @__PURE__ */ new Map();
     // ---------------------------------------------------------------------------
-    // ConnectId <-> DMK path mapping
-    //
-    // DMK uses internal paths (BLE MAC, USB UUID) that may change across sessions.
-    // _resolveConnectId() maps these to stable external IDs (BLE: "A58F", USB: same).
-    // This bidirectional map is the SINGLE SOURCE OF TRUTH for all connectId usage.
-    // ---------------------------------------------------------------------------
-    this._connectIdToPath = /* @__PURE__ */ new Map();
-    // "A58F" -> "D5:75:7D:4B:51:E8"
-    this._pathToConnectId = /* @__PURE__ */ new Map();
-    // ---------------------------------------------------------------------------
     // Per-session DeviceAction cancellers
     //
     // Each chain handler registers its active DeviceAction's canceller via
@@ -3038,6 +3038,7 @@ 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);
     }
@@ -3055,22 +3056,13 @@ 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 to extract stable identifiers (e.g. BLE hex ID).
+   * Override in subclasses only when the public connectId differs from the transport path.
    */
   _resolveConnectId(descriptor) {
     return descriptor.path;
@@ -3095,65 +3087,22 @@ 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)
     }));
-    debugLog(
-      "[DMK] connector.searchDevices() raw descriptors:",
-      resolvedDescriptors.map(({ descriptor: d, connectId }) => ({
-        id: d?.path,
-        path: d?.path,
-        connectId,
-        deviceName: d?.name,
-        "device.name": d?.bleName,
-        localName: d?.localName,
-        bleName: d?.bleName,
-        model: d?.type,
-        transport: d?.transport,
-        rssi: d?.rssi
-      }))
-    );
-    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_core12.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_core12.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
-      };
-    });
+    const result = resolvedDescriptors.map(({ descriptor: d, connectId }) => ({
+      connectId,
+      deviceId: d.path,
+      name: d.name || d.type || "Ledger",
+      model: d.type,
+      modelName: d.modelName,
+      rssi: d.rssi,
+      isConnectable: d.isConnectable,
+      serialNumber: d.serialNumber
+    }));
     debugLog(
       `[DMK] connector.searchDevices() return count=${result.length} ids=[${result.map((r) => r.connectId).join(",")}] paths=[${result.map((r) => r.deviceId).join(",")}]`
     );
@@ -3163,7 +3112,8 @@ var LedgerConnectorBase = class {
   // IConnector -- Connection
   // ---------------------------------------------------------------------------
   async connect(deviceId) {
-    let targetPath = deviceId ? this._getPathForConnectId(deviceId) : void 0;
+    const callerSuppliedConnectId = Boolean(deviceId);
+    let targetPath = deviceId;
     if (!targetPath) {
       const discovered = await this.searchDevices();
       if (discovered.length === 0) {
@@ -3173,7 +3123,7 @@ var LedgerConnectorBase = class {
       }
       targetPath = discovered[0].deviceId;
     }
-    const externalConnectId = this._getConnectIdForPath(targetPath);
+    const externalConnectId = targetPath;
     const HANG_CEILING_MS = 5 * 6e4;
     const dmConnectWithObserve = async (dm, path) => {
       if (!isLedgerBleConnectionType(this.connectionType)) return dm.connect(path);
@@ -3214,19 +3164,45 @@ 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();
-      const sessionId = await dmConnectWithObserve(dm, path);
+      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;
+      }
       this._watchSessionState(sessionId, externalConnectId);
+      const info = dm.getDiscoveredDeviceInfo(path);
       const session = {
         sessionId,
         deviceInfo: {
           vendor: "ledger",
-          model: "unknown",
+          model: info?.model ?? "unknown",
+          modelName: info?.modelName,
           firmwareVersion: "unknown",
           deviceId: path,
           connectId: externalConnectId,
           connectionType: this.connectionType,
+          rssi: info?.rssi,
           capabilities: { persistentDeviceIdentity: false }
         }
       };
@@ -3504,14 +3480,13 @@ var LedgerConnectorBase = class {
   }
   /**
    * Replace an old session with a new one after app switch.
-   * Updates the connectId→path mapping so subsequent calls() use the new session,
-   * and emits device-connect so the adapter updates its _sessions Map.
+   * Emits device-connect so the adapter updates its _sessions Map.
    */
   _replaceSession(oldSessionId, _newSessionId) {
     const dm = this._deviceManager;
     if (!dm) return;
     const oldDeviceId = dm.getDeviceId(oldSessionId);
-    const connectId = oldDeviceId ? this._pathToConnectId.get(oldDeviceId) : void 0;
+    const connectId = oldDeviceId;
     this._signerManager?.invalidate(oldSessionId);
     if (connectId) {
       this._emit("device-connect", {
@@ -3524,7 +3499,7 @@ var LedgerConnectorBase = class {
     }
   }
   /**
-   * Light reset: clear signer/session state but keep DMK and ID mapping alive.
+   * Light reset: clear signer/session state but keep DMK alive.
    * Used by connect() retry — we want to re-discover with the same transport.
    *
    * Note: drops the device manager but tears down its RxJS subs first via
@@ -3559,8 +3534,6 @@ var LedgerConnectorBase = class {
     this._deviceManager = null;
     this._signerManager = null;
     this._dmk = null;
-    this._connectIdToPath.clear();
-    this._pathToConnectId.clear();
   }
   // ---------------------------------------------------------------------------
   // Private -- Events
@@ -3619,13 +3592,6 @@ var LedgerConnectorBase = class {
     return error;
   }
 };
-
-// src/utils/bleIdentity.ts
-function extractBleHexId(name) {
-  if (!name) return void 0;
-  const match = name.match(/\b([0-9A-Fa-f]{4})$/);
-  return match ? match[1].toUpperCase() : void 0;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AppManager,
@@ -3637,13 +3603,12 @@ function extractBleHexId(name) {
   SignerEth,
   SignerManager,
   SignerSol,
+  debugLog,
   deviceActionToPromise,
-  extractBleHexId,
   isDeviceLockedError,
   isLedgerBleConnectionType,
   isLedgerBleDescriptor,
   isLedgerDmkBleTransport,
-  isValidLedgerBleConnectId,
   ledgerFailure,
   mapLedgerError,
   offSdkEvent,