@onekeyfe/hd-core 1.2.0-alpha.98 → 1.2.0

package/src/device/Device.ts

@@ -9,6 +9,7 @@ import {
   ERROR_CODES_REQUIRE_RELEASE,
   HardwareError,
   HardwareErrorCode,
+  canonicalizePro2BleAdvertisementName,
   createDeferred,
   createDeviceNotSupportMethodError,
 } from '@onekeyfe/hd-shared';
@@ -61,6 +62,7 @@ import {
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
   type ProtocolV2RuntimeMode,
   getProtocolV2RuntimeMode,
+  isLegacyProtocolV2ProtocolInfo,
   requestProtocolV2DeviceInfo,
   requestProtocolV2DeviceStatus,
   requestProtocolV2ProtocolInfo,
@@ -234,6 +236,15 @@ export class Device extends EventEmitter {
    */
   private deviceAcquired = false;
 
+  /**
+   * Connection-attempt generation. interruptionFromUser() pins the current
+   * attempt so a late acquire cannot finish, while the next public connect
+   * increments this and is allowed to proceed.
+   */
+  private connectionAttempt = 0;
+
+  private interruptedAttempt: number | null = null;
+
   /** Canonical device-state cache; legacy Features is a compatibility projection. */
   private stateStore = new DeviceStateStore();
 
@@ -283,6 +294,9 @@ export class Device extends EventEmitter {
 
   runPromise?: Deferred<void> | null;
 
+  /** Resolves only after the active run has completed its release path. */
+  private runCleanupPromise?: Promise<void>;
+
   externalState: string[] = [];
 
   unavailableCapabilities: UnavailableCapabilities = {};
@@ -425,6 +439,8 @@ export class Device extends EventEmitter {
     expectedProtocol?: HardwareConnectProtocol,
     options?: { throwOnRunPromiseError?: boolean; forceProtocolDetection?: boolean }
   ) {
+    const attempt = this.connectionAttempt;
+    this.throwIfInterruptedByUser();
     const env = DataManager.getSettings('env');
     const mainIdKey = DataManager.isBleConnect(env) ? 'id' : 'session';
     const previousProtocol = this.originalDescriptor.protocolType;
@@ -445,7 +461,8 @@ export class Device extends EventEmitter {
           undefined,
           true,
           strictProtocol,
-          undefined
+          undefined,
+          options?.forceProtocolDetection
         );
         this.mainId = (acquireResult as any)?.uuid ?? '';
         Log.debug('Expected uuid:', this.mainId);
@@ -455,7 +472,8 @@ export class Device extends EventEmitter {
           this.originalDescriptor.session,
           undefined,
           strictProtocol,
-          undefined
+          undefined,
+          options?.forceProtocolDetection
         );
         this.mainId = acquireResult as string | undefined;
         Log.debug('Expected session id:', this.mainId);
@@ -477,6 +495,15 @@ export class Device extends EventEmitter {
       if (detectedProtocol) {
         this.originalDescriptor.protocolType = detectedProtocol;
       }
+      if (this.interruptedAttempt === attempt || this.connectionAttempt !== attempt) {
+        const session = this.mainId;
+        if (session && this.deviceConnector?.disconnect) {
+          await this.deviceConnector.disconnect(session).catch(disconnectError => {
+            Log.debug('Ignored disconnect after user cancel during acquire', disconnectError);
+          });
+        }
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+      }
       this.deviceAcquired = true;
       this.updateDescriptor({ [mainIdKey]: this.mainId } as unknown as DeviceDescriptor);
 
@@ -485,6 +512,10 @@ export class Device extends EventEmitter {
       }
 
       this.commands = new DeviceCommands(this, this.mainId ?? '');
+      // Protocol V2 runtime metadata belongs to one active transport link. A
+      // successful acquire creates a fresh link/session, so never carry cached
+      // ProtocolInfo or pre-initialize state across that boundary.
+      this.invalidateProtocolV2RuntimeState();
     } catch (error) {
       if (options?.forceProtocolDetection) {
         this.originalDescriptor.protocolType = previousProtocol;
@@ -642,7 +673,8 @@ export class Device extends EventEmitter {
   }
 
   getCurrentBleName() {
-    return this.state?.identity.bleName ?? null;
+    const bleName = this.state?.identity.bleName ?? null;
+    return bleName ? canonicalizePro2BleAdvertisementName(bleName) : null;
   }
 
   getCurrentLabel() {
@@ -893,6 +925,7 @@ export class Device extends EventEmitter {
   }
 
   async initialize(options?: InitOptions) {
+    this.throwIfInterruptedByUser();
     // Protocol V2 does not support legacy Initialize; use its dedicated flow.
     if (this.isProtocolV2()) {
       this.passphraseState = options?.passphraseState;
@@ -922,13 +955,18 @@ export class Device extends EventEmitter {
       };
 
       const expectedDeviceId = options?.deviceId;
-      if (expectedDeviceId) {
-        // 先只读校验物理设备身份；钱包上下文仍由下方携带完整参数的
-        // Initialize 选择，避免标准钱包请求复用此前的隐藏钱包上下文。
+
+      if (expectedDeviceId && !(this.features && this.checkDeviceId(expectedDeviceId))) {
+        // No locally-cached evidence that the device at this path is the
+        // expected one (first contact, or the cached features already disagree
+        // with the caller). Establish identity with a context-free Initialize
+        // BEFORE any wallet context (session_id / passphrase_state) goes on
+        // the wire. In normal flows features are always fresh — enumerate /
+        // getFeatures run first and every call response refreshes them — so
+        // this extra round trip is confined to the ambiguous cases where the
+        // disclosure risk actually lives.
         this.passphraseState = undefined;
-        const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
-        this._updateFeatures(message);
-        await TransportManager.reconfigure(this.features);
+        await callInitialize({ is_contains_attach: true });
         if (!this.checkDeviceId(expectedDeviceId)) {
           throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
         }
@@ -952,7 +990,46 @@ export class Device extends EventEmitter {
         payload.derive_cardano = true;
       }
 
-      await callInitialize(payload, options?.initSession);
+      if (this.features) {
+        // Re-sync the V1 message schema for THIS device before encoding
+        // Initialize: the process-global schema may still reflect another
+        // device (e.g. legacy-firmware Touch/Mini) on multi-device setups, and
+        // a stale legacy schema would silently strip passphrase_state /
+        // is_contains_attach from the wire message. Local operation, no wire
+        // I/O; a no-op when the schema is unchanged.
+        await TransportManager.reconfigure(this.features);
+      }
+
+      // Initialize's own Features response carries device_id, so the physical
+      // device identity is validated on the same round trip instead of via a
+      // separate read-only GetFeatures preflight (which doubled the wire cost
+      // of every deviceId-carrying call). The method fn has not run yet, so a
+      // mismatch still fails before any wallet data can be derived, with the
+      // same DeviceCheckDeviceIdError. Wallet-context selection is unchanged:
+      // it is decided by the Initialize payload above either way.
+      const assertExpectedDeviceIdentity = () => {
+        if (expectedDeviceId && !this.checkDeviceId(expectedDeviceId)) {
+          // The mismatched Initialize may have cached a session under the wrong
+          // device's identity; drop it so no wallet context survives from it.
+          // (This also evicts any session the wrong device legitimately cached
+          // under the same passphraseState — a deliberate conservative purge
+          // after a physical-swap event, consistent with
+          // reconcileDeviceIdentity purging the previous device's sessions.)
+          this.clearInternalState();
+          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
+        }
+      };
+
+      try {
+        await callInitialize(payload, options?.initSession);
+      } catch (error) {
+        // callInitialize can fail AFTER the wire call cached the session (e.g.
+        // TransportManager.reconfigure rejecting); the identity check must
+        // still run so a wrong-device session never survives the error path.
+        assertExpectedDeviceIdentity();
+        throw error;
+      }
+      assertExpectedDeviceIdentity();
     } catch (error) {
       Log.error('Initialization failed:', error);
       throw error;
@@ -977,11 +1054,7 @@ export class Device extends EventEmitter {
       });
       // The default request excludes SE/hash data and therefore uses basic scope.
       // Full version and verification data require getDeviceState({ scope: 'firmware' }).
-      const features = await this.probeProtocolV2RuntimeState(
-        deviceInfo,
-        options?.protocolV2DeviceInfoTimeoutMs
-      );
-      Log.debug('Protocol V2 features:', features);
+      await this.probeProtocolV2RuntimeState(deviceInfo, options?.protocolV2DeviceInfoTimeoutMs);
     } catch (error) {
       Log.error('Protocol V2 initialization failed:', error);
       throw error;
@@ -1053,7 +1126,13 @@ export class Device extends EventEmitter {
       }
 
       if (refresh.has('status') && !initializedWithDeviceInfo) {
-        await this.probeProtocolV2RuntimeState(refreshedDeviceInfo);
+        const cachedMode = this.state?.status.mode;
+        await this.probeProtocolV2RuntimeState(refreshedDeviceInfo, undefined, {
+          // Loader firmware does not support DeviceStatusGet. Renegotiate ProtocolInfo
+          // during an explicit refresh so a device rebooted into application firmware
+          // can leave the cached loader state.
+          forceRuntimeContextRefresh: cachedMode === 'bootloader' || cachedMode === 'romloader',
+        });
       }
 
       if (refresh.has('settings') && this.state?.status.mode === 'normal') {
@@ -1072,6 +1151,10 @@ export class Device extends EventEmitter {
     return params.includeRaw ? cloneDeviceState(this.state) : createPublicDeviceState(this.state);
   }
 
+  async refreshProtocolV2SettingsAfterMutation() {
+    return this.getDeviceState({ refreshSections: ['status', 'settings'] });
+  }
+
   _updateFeatures(protoFeatures: PROTO.Features | Features, initSession?: boolean) {
     const previousDeviceId = this.getCurrentDeviceId();
     let feat =
@@ -1101,9 +1184,10 @@ export class Device extends EventEmitter {
       source,
       changedKeys: result.changedKeys,
     };
-    Log.debug('Device state patch committed', {
+    Log.debug('Device state updated', {
       source,
-      keys: result.changedKeys,
+      revision: result.revision,
+      changedKeyCount: result.changedKeys.length,
     });
     this.emit(DEVICE.STATE, this, event);
     if (result.state.protocol === 'V1') {
@@ -1124,12 +1208,17 @@ export class Device extends EventEmitter {
     return this.features;
   }
 
-  async ensureProtocolV2RuntimeContext(timeoutMs?: number): Promise<ProtocolInfo> {
+  async ensureProtocolV2RuntimeContext(
+    timeoutMs?: number,
+    options?: { forceRefresh?: boolean }
+  ): Promise<ProtocolInfo> {
     const cachedProtocolInfo =
-      this.protocolV2RuntimeContext ??
-      (!this.protocolV2StateNeedsReload
-        ? this.state?.raw?.protocolV2ProtocolInfo ?? undefined
-        : undefined);
+      options?.forceRefresh === true
+        ? undefined
+        : this.protocolV2RuntimeContext ??
+          (!this.protocolV2StateNeedsReload
+            ? this.state?.raw?.protocolV2ProtocolInfo ?? undefined
+            : undefined);
     if (cachedProtocolInfo) {
       this.protocolV2RuntimeContext = cachedProtocolInfo;
       return cachedProtocolInfo;
@@ -1169,10 +1258,19 @@ export class Device extends EventEmitter {
     }
   }
 
-  async probeProtocolV2RuntimeState(deviceInfo?: ProtocolV2DeviceInfo, timeoutMs?: number) {
-    const protocolInfo = await this.ensureProtocolV2RuntimeContext(timeoutMs);
-    const runtimeMode = getProtocolV2RuntimeMode(protocolInfo);
+  async probeProtocolV2RuntimeState(
+    deviceInfo?: ProtocolV2DeviceInfo,
+    timeoutMs?: number,
+    options?: {
+      forceRuntimeContextRefresh?: boolean;
+    }
+  ) {
+    const protocolInfo = await this.ensureProtocolV2RuntimeContext(timeoutMs, {
+      forceRefresh: options?.forceRuntimeContextRefresh,
+    });
     const runtimeDeviceInfo = deviceInfo ?? this.state?.raw?.protocolV2DeviceInfo;
+    const runtimeMode = getProtocolV2RuntimeMode(protocolInfo, runtimeDeviceInfo);
+    const legacyProtocolInfo = isLegacyProtocolV2ProtocolInfo(protocolInfo);
     const protocolV2DeviceType = runtimeDeviceInfo
       ? resolveProtocolV2DeviceIdentity(runtimeDeviceInfo.hw?.Device_type).deviceType
       : this.getCurrentDeviceType();
@@ -1186,10 +1284,9 @@ export class Device extends EventEmitter {
         'Protocol V2 romloader mode is only supported for Pro2 and Neo.'
       );
     }
-    const deviceStatusSupported = supportsProtocolV2Message(
-      protocolInfo,
-      PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE
-    );
+    const deviceStatusSupported =
+      legacyProtocolInfo ||
+      supportsProtocolV2Message(protocolInfo, PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE);
 
     if (runtimeMode === 'bootloader' || runtimeMode === 'romloader') {
       return this.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
@@ -1250,8 +1347,7 @@ export class Device extends EventEmitter {
     });
   }
 
-  markTransportDisconnected() {
-    this.deviceAcquired = false;
+  private invalidateProtocolV2RuntimeState() {
     if (!this.isProtocolV2()) return;
     this.protocolV2StateNeedsReload = true;
     this.protocolV2RuntimeContext = undefined;
@@ -1260,6 +1356,11 @@ export class Device extends EventEmitter {
     this.clearPreInitialized();
   }
 
+  markTransportDisconnected() {
+    this.deviceAcquired = false;
+    this.invalidateProtocolV2RuntimeState();
+  }
+
   invalidateAfterWipe() {
     const deviceId = this.getCurrentDeviceId();
     if (deviceId) {
@@ -1269,10 +1370,7 @@ export class Device extends EventEmitter {
       if (this.originalDescriptor.path !== deviceId) {
         deviceWalletSessionStore.deleteDevice(this.originalDescriptor.path);
       }
-      this.protocolV2StateNeedsReload = true;
-      this.protocolV2RuntimeContext = undefined;
-      this.protocolV2RuntimeContextPromise = undefined;
-      this.protocolV2RuntimeContextRequestToken = undefined;
+      this.invalidateProtocolV2RuntimeState();
     }
 
     this.passphraseState = undefined;
@@ -1284,11 +1382,7 @@ export class Device extends EventEmitter {
   markProtocolV2Reboot(rebootType: DeviceRebootType) {
     if (!this.isProtocolV2()) return;
 
-    this.protocolV2StateNeedsReload = true;
-    this.protocolV2RuntimeContext = undefined;
-    this.protocolV2RuntimeContextPromise = undefined;
-    this.protocolV2RuntimeContextRequestToken = undefined;
-    this.clearPreInitialized();
+    this.invalidateProtocolV2RuntimeState();
     let loaderMode: 'bootloader' | 'romloader' | undefined;
     if (rebootType === DeviceRebootType.Bootloader) {
       loaderMode = 'bootloader';
@@ -1362,6 +1456,10 @@ export class Device extends EventEmitter {
     if (device.features) {
       this._updateFeatures(device.features);
     }
+    // Adopting another Device instance's command channel also crosses an active
+    // link boundary. Renegotiate runtime metadata on that channel instead of
+    // retaining ProtocolInfo from the previous instance/session.
+    this.invalidateProtocolV2RuntimeState();
   }
 
   async run(fn?: () => Promise<void>, options?: RunOptions) {
@@ -1370,16 +1468,25 @@ export class Device extends EventEmitter {
       Log.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
     }
 
+    this.beginConnectionAttempt();
     options = parseRunOptions(options);
 
     const runPromise = createDeferred<void>();
     this.runPromise = runPromise;
-    this._runInner(fn, options, runPromise).catch(error => {
+    const cleanupPromise = this._runInner(fn, options, runPromise).catch(error => {
       if (this.runPromise === runPromise) {
         this.runPromise = null;
       }
       runPromise.reject(error);
     });
+    this.runCleanupPromise = cleanupPromise;
+    cleanupPromise
+      .finally(() => {
+        if (this.runCleanupPromise === cleanupPromise) {
+          this.runCleanupPromise = undefined;
+        }
+      })
+      .catch(() => undefined);
     return runPromise.promise;
   }
 
@@ -1491,13 +1598,32 @@ export class Device extends EventEmitter {
 
   async interruptionFromUser() {
     const error = ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
-    await this.cancelableAction?.(error);
+    this.interruptedAttempt = this.connectionAttempt;
+    const cleanupPromise = this.runCleanupPromise;
+    const { cancelableAction } = this;
+    if (cancelableAction) {
+      await cancelableAction(error);
+    } else if (this.shouldSendFallbackProtocolCancel()) {
+      await this.commands?.cancelDevice?.().catch(cancelError => {
+        Log.debug('Protocol V2 fallback cancel error', cancelError);
+      });
+    } else if (!this.hasDeviceAcquire()) {
+      // Pairing / connect-native / probe: drop the physical link only.
+      // Never acquire or send protocol Cancel just to abort setup.
+      if (this.mainId && this.deviceConnector?.disconnect) {
+        await this.deviceConnector.disconnect(this.mainId).catch(disconnectError => {
+          Log.debug('Ignored disconnect during user cancel without acquire', disconnectError);
+        });
+      }
+      this.markTransportDisconnected();
+    }
     await this.commands?.cancel();
 
     if (this.runPromise) {
       this.runPromise.reject(error);
       this.runPromise = null;
     }
+    await cleanupPromise?.catch(() => undefined);
   }
 
   setCancelableAction(callback: (err?: Error) => Promise<unknown>) {
@@ -1553,6 +1679,44 @@ export class Device extends EventEmitter {
     return typeof this.originalDescriptor.session === 'string';
   }
 
+  beginConnectionAttempt() {
+    this.connectionAttempt += 1;
+    return this.connectionAttempt;
+  }
+
+  wasInterruptedByUser() {
+    return (
+      typeof this.interruptedAttempt === 'number' &&
+      this.interruptedAttempt === this.connectionAttempt
+    );
+  }
+
+  private throwIfInterruptedByUser() {
+    if (this.wasInterruptedByUser()) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+    }
+  }
+
+  /**
+   * Protocol Cancel is only for an acquired session that is already in a
+   * user-facing prompt. Connect, probe and initialize must not send Cancel
+   * and must not re-acquire just to deliver one.
+   */
+  private shouldSendFallbackProtocolCancel() {
+    if (!this.hasDeviceAcquire() || !this.isProtocolV2()) {
+      return false;
+    }
+    if (!this.hasOpenProtocolV2UiInteraction()) {
+      return false;
+    }
+    const env = DataManager.getSettings('env');
+    return (
+      DataManager.isBleConnect(env) ||
+      DataManager.isBrowserWebUsb(env) ||
+      DataManager.isDesktopWebUsb(env)
+    );
+  }
+
   hasDeviceAcquire() {
     const env = DataManager.getSettings('env');
     if (DataManager.isBleConnect(env)) {
@@ -1841,7 +2005,8 @@ export class Device extends EventEmitter {
     passphraseState?: string,
     useEmptyPassphrase?: boolean,
     skipPassphraseCheck?: boolean,
-    deriveCardano?: boolean
+    deriveCardano?: boolean,
+    mainPinSelected?: boolean
   ) {
     if (this.isUnacquired()) return false;
 
@@ -1852,6 +2017,7 @@ export class Device extends EventEmitter {
         onlyMainPin: useEmptyPassphrase,
         deriveCardano,
         rejectAttachPinForMainWallet: useEmptyPassphrase === true,
+        mainPinSelected,
       });
 
     // Main wallet and unlock Attach Pin, throw safe error

package/src/device/DeviceCommands.ts

@@ -7,6 +7,7 @@ import {
   type Transport,
   type TransportCallOptions,
   getSafeTransportLogPayload,
+  isProtocolV2LinkDisabledFailure,
 } from '@onekeyfe/hd-transport';
 
 import TransportManager from '../data-manager/TransportManager';
@@ -68,7 +69,7 @@ const DEVICE_CONTROL_CALLS = new Set([
 // Older Protocol V2 firmware may omit the cancellation subcode, so retain a
 // narrow message fallback for compatibility.
 const isProtocolV2ActionCancelledMessage = (message: string) =>
-  /^(?:cancel(?:led|ed)(?: on device)?|confirm dismissed|user cancel(?:led|ed)(?:\s+.*)?)$/i.test(
+  /^(?:cancel(?:led|ed)(?: on device)?|confirm dismissed|update cancel(?:led|ed)|user cancel(?:led|ed)(?:\s+.*)?)$/i.test(
     message
   );
 
@@ -263,6 +264,7 @@ export class DeviceCommands {
     }
     const activeCall = this.callPromise;
     let timer: ReturnType<typeof setTimeout> | undefined;
+    let timedOut = false;
     const cancellation = (async () => {
       await this.dispose(true);
       await activeCall?.catch(() => undefined);
@@ -272,11 +274,23 @@ export class DeviceCommands {
       await Promise.race([
         cancellation,
         new Promise<void>(resolve => {
-          timer = setTimeout(resolve, 10 * 1000);
+          timer = setTimeout(() => {
+            timedOut = true;
+            resolve();
+          }, 10 * 1000);
         }),
       ]);
     } finally {
       if (timer) clearTimeout(timer);
+      if (
+        timedOut &&
+        this.transport.name === 'ReactNativeBleTransport' &&
+        this.transport.disconnect
+      ) {
+        await this.transport.disconnect(this.mainId).catch(error => {
+          Log.debug('BLE cancellation timeout disconnect error (ignored)', error);
+        });
+      }
       if (this.callPromise === activeCall) {
         this.callPromise = undefined;
       }
@@ -304,13 +318,6 @@ export class DeviceCommands {
       const promise = this.transport.call(this.mainId, type, msg ?? {}, options) as any;
       this.callPromise = promise;
       const res = await promise;
-      if (!shouldReduceDebug) {
-        LogCore.debug(
-          '[DeviceCommands] [call] Received',
-          res.type,
-          getSafeTransportLogPayload(res.message, res.type)
-        );
-      }
       return res;
     } catch (error) {
       LogCore.debug('[DeviceCommands] [call] Received error', {
@@ -445,13 +452,10 @@ export class DeviceCommands {
       if (!shouldReduceDebugForCall(callType)) {
         Log.debug('_filterCommonTypes: ', {
           request: callType,
-          response:
-            callType === 'DeviceFirmwareUpdateStatusGet'
-              ? {
-                  type: res.type,
-                  message: getSafeTransportLogPayload(res.message, res.type),
-                }
-              : res.type,
+          response: {
+            type: res.type,
+            message: getSafeTransportLogPayload(res.message, res.type),
+          },
         });
       }
     } catch (error) {
@@ -491,7 +495,7 @@ export class DeviceCommands {
         if (message === 'Please confirm the BlindSign enabled') {
           error = ERRORS.TypedError(HardwareErrorCode.BlindSignDisabled);
         }
-        if (message === 'File already exists') {
+        if (message === 'File already exists' || message === 'NFT already exists') {
           error = ERRORS.TypedError(HardwareErrorCode.FileAlreadyExists);
         }
         if (message?.includes('bytes overflow')) {
@@ -505,7 +509,12 @@ export class DeviceCommands {
         }
       }
 
-      if (code === 'Failure_ProcessError') {
+      if (isProtocolV2LinkDisabledFailure(code, message)) {
+        error = ERRORS.TypedError(HardwareErrorCode.BleUnavailableWhileUsbConnected, undefined, {
+          failureCode: code,
+          firmwareMessage: message,
+        });
+      } else if (code === 'Failure_ProcessError') {
         const normalizedMessage = message?.trim() ?? '';
         const isProtocolV2ActionCancelledFailure =
           this.device.isProtocolV2() && isProtocolV2ActionCancelledMessage(normalizedMessage);

package/src/device/DeviceConnector.ts

@@ -1,3 +1,4 @@
+import { isProtocolV2LinkDisabledError } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { safeThrowError } from '../constants';
@@ -94,7 +95,9 @@ export default class DeviceConnector {
     session?: string | null,
     forceCleanRunPromise?: boolean,
     expectedProtocol?: HardwareConnectProtocol,
-    protocolHint?: HardwareConnectProtocol
+    protocolHint?: HardwareConnectProtocol,
+    forceProtocolDetection?: boolean,
+    skipProtocolProbe?: boolean
   ) {
     Log.debug('acquire', path, session, expectedProtocol, protocolHint);
     const env = DataManager.getSettings('env');
@@ -102,18 +105,23 @@ export default class DeviceConnector {
       const transport = this.getActiveTransport();
       let res;
       if (DataManager.isBleConnect(env)) {
-        res = await transport.acquire({
+        const acquireInput: Parameters<Transport['acquire']>[0] = {
           uuid: path,
           forceCleanRunPromise,
           expectedProtocol,
           protocolHint,
-        });
+          forceProtocolDetection,
+          skipProtocolProbe,
+        };
+        res = await transport.acquire(acquireInput);
       } else {
         res = await transport.acquire({
           path,
           previous: session ?? null,
           expectedProtocol,
           protocolHint,
+          forceProtocolDetection,
+          skipProtocolProbe,
         });
       }
       if (expectedProtocol) {
@@ -134,6 +142,12 @@ export default class DeviceConnector {
       return res;
     } catch (error) {
       Log.error('acquire error: ', error.message);
+      if (isProtocolV2LinkDisabledError(error)) {
+        throw ERRORS.TypedError(HardwareErrorCode.BleUnavailableWhileUsbConnected, undefined, {
+          failureCode: error.failureCode,
+          firmwareMessage: error.firmwareMessage,
+        });
+      }
       safeThrowError(error);
     }
   }

package/src/device/DevicePool.ts

@@ -172,6 +172,9 @@ export class DevicePool extends EventEmitter {
     const device = cachedDevice ?? Device.fromDescriptor(descriptor);
     if (isNewDevice || forceProtocolDetection) {
       device.deviceConnector = this.connector;
+      // Search/discovery acquires outside Device.run(). Start a new attempt so
+      // a previous user cancel does not hide this device from later searches.
+      device.beginConnectionAttempt?.();
       if (forceProtocolDetection && !isNewDevice) {
         await device.acquire(initOptions?.connectProtocol, { forceProtocolDetection: true });
       } else {
@@ -218,9 +221,13 @@ export class DevicePool extends EventEmitter {
    * Device.getDeviceState skips unsupported status/settings calls in loader mode.
    */
   static async _refreshProtocolV2DiscoveryState(device: Device) {
-    await device.getDeviceState({ refreshSections: ['status'] });
+    await device.getDeviceState({
+      refreshSections: ['status'],
+    });
     try {
-      await device.getDeviceState({ refreshSections: ['settings'] });
+      await device.getDeviceState({
+        refreshSections: ['settings'],
+      });
     } catch (error) {
       Log.debug('Unable to refresh Protocol V2 device label during discovery', error);
     }