@onekeyfe/hd-core 1.2.0-alpha.67 → 1.2.0-alpha.68

package/src/api/GetPassphraseState.ts

@@ -1,4 +1,5 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { refreshProtocolV2DeviceStatus } from '../protocols/protocol-v2/walletSession';
@@ -24,7 +25,12 @@ export default class GetPassphraseState extends BaseMethod {
     if (isProtocolV2 && this.payload.useEmptyPassphrase !== true) {
       const features = await refreshProtocolV2DeviceStatus(this.device);
       if (features.unlocked === false) {
-        await this.device.unlockDevice();
+        await this.device.unlockDevice(DeviceSessionPinType.Main, {
+          source: 'unlock-coordinator',
+          reason: 'device-locked',
+          deviceOnly: true,
+          method: 'getPassphraseState',
+        });
       }
     }
     const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(

package/src/api/OpenWalletSession.ts

@@ -1,4 +1,5 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
 import { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSession';
@@ -83,6 +84,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
   init() {
     this.useDevicePassphraseState = false;
+    this.unlockPolicy = 'unlock-before-run';
     this.skipForceUpdateCheck = true;
     this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
     this.payload.useEmptyPassphrase = this.params.mode === OpenWalletSessionMode.Standard;
@@ -90,23 +92,40 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
   async run(): Promise<OpenWalletSessionPayload> {
     const isProtocolV2 = this.device.isProtocolV2();
-    const state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    let state = await this.device.getDeviceState({ refreshSections: ['status'] });
     let currentDeviceId = state.identity.deviceId;
+    const hasAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) =>
+      candidate.status.unlocked === true &&
+      typeof candidate.status.passphraseProtection === 'boolean' &&
+      typeof candidate.status.unlockedAttachPin === 'boolean';
+    const requireAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) => {
+      if (!hasAuthoritativeProtocolV2WalletStatus(candidate)) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+      }
+      return candidate;
+    };
     const requireDeviceId = () => {
       if (!currentDeviceId) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
       }
       return currentDeviceId;
     };
-    const refreshProtocolV2DeviceId = async () => {
-      const refreshedState = await this.device.getDeviceState({ refreshSections: ['status'] });
-      currentDeviceId = refreshedState.identity.deviceId;
-      return requireDeviceId();
+    const refreshProtocolV2DeviceState = async () => {
+      state = await this.device.getDeviceState({ refreshSections: ['status'] });
+      currentDeviceId = state.identity.deviceId;
+      return state;
     };
-    const unlockProtocolV2IfLocked = async () => {
-      if (isProtocolV2 && state.status.unlocked === false) {
-        await this.device.unlockDevice();
+    const ensureProtocolV2WalletStatus = async () => {
+      if (isProtocolV2 && !hasAuthoritativeProtocolV2WalletStatus(state)) {
+        await this.device.unlockDevice(DeviceSessionPinType.Main, {
+          source: 'unlock-coordinator',
+          reason: 'device-locked',
+          deviceOnly: true,
+          method: 'openWalletSession',
+        });
+        requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState());
       }
+      return state;
     };
 
     const protocol = isProtocolV2 ? 'V2' : 'V1';
@@ -114,13 +133,25 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     if (this.params.mode === OpenWalletSessionMode.Standard) {
       this.device.passphraseState = undefined;
       const session = isProtocolV2
-        ? await getProtocolV2WalletSession(this.device, { onlyMainPin: true })
+        ? await getProtocolV2WalletSession(this.device, {
+            onlyMainPin: true,
+            deriveCardano: this.payload.deriveCardano,
+            selectMainWalletBeforeRestore:
+              !hasAuthoritativeProtocolV2WalletStatus(state) ||
+              state.status.unlockedAttachPin === true,
+          })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             onlyMainPin: true,
             initSession: this.payload.initSession,
           });
-      const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
-      if (session.unlockedAttachPin) {
+      const refreshedState = isProtocolV2
+        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+        : state;
+      const deviceId = requireDeviceId();
+      if (
+        session.unlockedAttachPin ||
+        (isProtocolV2 && refreshedState.status.unlockedAttachPin === true)
+      ) {
         try {
           await this.device.lockDevice();
         } catch {
@@ -140,8 +171,8 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
     if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
       if (isProtocolV2) {
-        await unlockProtocolV2IfLocked();
-        const refreshedDeviceId = await refreshProtocolV2DeviceId();
+        await ensureProtocolV2WalletStatus();
+        const refreshedDeviceId = requireDeviceId();
         if (refreshedDeviceId !== this.params.deviceId) {
           deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
           throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
@@ -166,6 +197,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, {
             expectedPassphraseState: this.params.passphraseState,
+            deriveCardano: this.payload.deriveCardano,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             expectPassphraseState: this.params.passphraseState,
@@ -185,15 +217,37 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     }
 
     this.device.passphraseState = undefined;
-    await unlockProtocolV2IfLocked();
+    const walletStatus = await ensureProtocolV2WalletStatus();
+    if (isProtocolV2 && walletStatus.status.passphraseProtection !== true) {
+      this.device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
+    }
+    const readCurrentAttachPinSession =
+      isProtocolV2 && walletStatus.status.unlockedAttachPin === true;
     const session = isProtocolV2
-      ? await getProtocolV2WalletSession(this.device, { forceWalletSelection: true })
+      ? await getProtocolV2WalletSession(this.device, {
+          ...(readCurrentAttachPinSession
+            ? { readCurrentAttachPinSession: true }
+            : { forceWalletSelection: true }),
+          deriveCardano: this.payload.deriveCardano,
+        })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
-    const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
-    if (isProtocolV2 && this.device.getCurrentPassphraseProtection() !== true) {
+    const refreshedState = isProtocolV2
+      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+      : state;
+    const deviceId = requireDeviceId();
+    if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {
       this.device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
     }
+    if (
+      isProtocolV2 &&
+      readCurrentAttachPinSession &&
+      refreshedState.status.unlockedAttachPin !== true
+    ) {
+      this.device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
+    }
     const responseBase = {
       protocol,
       deviceId,

package/src/api/SearchDevices.ts

@@ -59,7 +59,9 @@ export default class SearchDevices extends BaseMethod {
         // Discovery is best effort. Browsers may retain WebUSB grants for devices that
         // are offline, busy, or not ready, so one descriptor must not abort the scan.
         const result = await DevicePool.getDevices([descriptor], descriptor.path, {
-          connectProtocol: this.payload.connectProtocol,
+          // Discovery must actively identify the protocol instead of trusting a caller hint.
+          connectProtocol: undefined,
+          forceProtocolDetection: true,
           refreshRuntimeState: true,
         });
         deviceList.push(...result.deviceList);

package/src/api/allnetwork/AllNetworkGetAddress.ts

@@ -24,24 +24,28 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
     const resultMap: Record<string, AllNetworkAddress> = {};
     const { bundle } = this.payload as AllNetworkGetAddressParams;
 
-    const methodGroups = bundle
-      .map((param, index) =>
-        this.generateMethodName({
-          network: param.network,
-          payload: param,
-          originalIndex: index,
-        })
-      )
-      .reduce((acc, cur) => {
-        if (!acc[cur.methodName]) {
-          acc[cur.methodName] = [];
-        }
-        acc[cur.methodName].push(cur);
-        return acc;
-      }, {} as Record<keyof CoreApi, MethodParams[]>);
+    const methodParams = bundle.map((param, index) =>
+      this.generateMethodName({
+        network: param.network,
+        payload: param,
+        originalIndex: index,
+      })
+    );
+    const groupedMethodParams = methodParams.reduce((groups, param) => {
+      const group = groups.get(param.methodName) ?? [];
+      group.push(param);
+      groups.set(param.methodName, group);
+      return groups;
+    }, new Map<keyof CoreApi, MethodParams[]>());
+    const requiresProtocolV2WalletHandoff =
+      this.device.isProtocolV2() &&
+      (this.payload.useEmptyPassphrase === true || !!this.payload.passphraseState);
+    const methodGroups: [keyof CoreApi, MethodParams[]][] = requiresProtocolV2WalletHandoff
+      ? methodParams.map(param => [param.methodName, [param]])
+      : Array.from(groupedMethodParams.entries());
 
     let i = 0;
-    for (const [methodName, params] of Object.entries(methodGroups)) {
+    for (const [methodName, params] of methodGroups) {
       const methodParams = {
         bundle: params.map(param => ({
           ...param.params,
@@ -52,11 +56,7 @@ export default class AllNetworkGetAddress extends AllNetworkGetAddressBase {
         throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);
       }
       // call method
-      const response = await this.callMethod(
-        methodName as keyof CoreApi,
-        methodParams,
-        rootFingerprint
-      );
+      const response = await this.callMethod(methodName, methodParams, rootFingerprint);
 
       if (this.abortController?.signal.aborted) {
         throw new Error(HardwareErrorCodeMessage[HardwareErrorCode.RepeatUnlocking]);

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -14,6 +14,7 @@ import { findMethod } from '../utils';
 import { DEVICE, IFRAME, createUiMessage } from '../../events';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { onDeviceButtonHandler } from '../../core';
+import { runMethodWithUnlockPolicy } from '../../protocols/protocol-v2/unlockPolicyRunner';
 import {
   completeRequestContext,
   createRequestContext,
@@ -375,16 +376,38 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       this.device.on(DEVICE.PASSPHRASE, onSignalAbort);
 
       preCheckDeviceSupport(this.device, method);
-      if (this.temporarySafetyCheckPrompted) {
-        method.temporarySafetyCheckPrompted = true;
-      } else {
-        const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
-        if (appliedTemporarySafetyCheck) {
-          this.temporarySafetyCheckPrompted = true;
-        }
-      }
-
-      const response = await method.run();
+      const response = await runMethodWithUnlockPolicy<any[]>(method, this.device, {
+        context: this.protocolV2UnlockContext,
+        prepare: async () => {
+          if (this.temporarySafetyCheckPrompted) {
+            method.temporarySafetyCheckPrompted = true;
+          } else {
+            const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
+            if (appliedTemporarySafetyCheck) {
+              this.temporarySafetyCheckPrompted = true;
+            }
+          }
+
+          // Protocol V2 hands a wallet session to exactly one blockchain request.
+          // The parent all-network call consumes its first handoff while fetching
+          // the root fingerprint, so each nested chain method must resume the
+          // requested standard or hidden wallet before sending its device command.
+          const useEmptyPassphrase = this.payload.useEmptyPassphrase === true;
+          const deriveCardano = method.name.startsWith('cardano');
+          const shouldResumeWalletSession = useEmptyPassphrase || !!this.payload.passphraseState;
+          if (this.device.isProtocolV2() && shouldResumeWalletSession) {
+            const passphraseStateSafety = await this.device.checkPassphraseStateSafety(
+              this.payload.passphraseState,
+              useEmptyPassphrase,
+              this.payload.skipPassphraseCheck,
+              deriveCardano
+            );
+            if (!passphraseStateSafety) {
+              throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+            }
+          }
+        },
+      });
 
       if (!Array.isArray(response) || response.length === 0) {
         throw new Error('No response');
@@ -439,7 +462,9 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       show_display: false,
     });
 
-    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+    if (!this.device.isProtocolV2()) {
+      this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+    }
 
     if (res.message.root_fingerprint == null) {
       throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);

package/src/api/device/DeviceSettings.ts

@@ -7,7 +7,6 @@ import { validateParams } from '../helpers/paramsValidator';
 import {
   mapApplySettingsToState,
   mapCommonSettingsToProtocolV2,
-  mapDeviceSettingsToState,
 } from '../../device/DeviceStateMapper';
 import { getProtocolV2SettingsBehavior } from '../../protocols/protocol-v2/settingsUnlockPolicy';
 import {
@@ -163,6 +162,8 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
   async run() {
     try {
       if (this.device.isProtocolV2()) {
+        const refreshStatusAndSettings = () =>
+          this.device.getDeviceState({ refreshSections: ['status', 'settings'] });
         assertSettingsSupported(this.payload, DEVICE_SETTINGS_V1_ONLY_FIELDS, 'Protocol V2');
         const capabilities = getDeviceSettingsCapabilities(
           this.device.getCurrentDeviceType(),
@@ -194,7 +195,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DevicePassphrase,
           });
-          const updated = await this.device.getDeviceState({ refreshSections: ['status'] });
+          const updated = await refreshStatusAndSettings();
           const lockedAfterDisabling =
             requestedPassphrase === false &&
             current.status.unlocked === true &&
@@ -219,7 +220,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
           const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
             page: DeviceSettingsPage.DeviceAirgap,
           });
-          const updated = await this.device.getDeviceState({ refreshSections: ['settings'] });
+          const updated = await refreshStatusAndSettings();
           if (updated.settings.airgapMode !== requestedAirgap) {
             throw TypedError(
               HardwareErrorCode.RuntimeError,
@@ -235,7 +236,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
         const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
           settings,
         });
-        this.device.updateState(mapDeviceSettingsToState(settings), 'settings-write');
+        await refreshStatusAndSettings();
         return res.message;
       }
 

package/src/api/device/DeviceUnlock.ts

@@ -1,13 +1,18 @@
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+
 import { BaseMethod } from '../BaseMethod';
 
-import type { LockDevice } from '@onekeyfe/hd-transport';
+import type { DeviceUnlockParams } from '../../types/api/deviceUnlock';
 
-export default class DeviceUnlock extends BaseMethod<LockDevice> {
+export default class DeviceUnlock extends BaseMethod<DeviceUnlockParams> {
   getSupportedProtocols() {
     return ['V1', 'V2'] as const;
   }
 
   init() {
+    this.params = {
+      pinType: this.payload.pinType ?? DeviceSessionPinType.Main,
+    };
     this.useDevicePassphraseState = false;
     this.unlockPolicy = 'none';
     this.protocolV2UiInteraction = {
@@ -21,6 +26,6 @@ export default class DeviceUnlock extends BaseMethod<LockDevice> {
   }
 
   async run() {
-    return this.device.unlockDevice();
+    return this.device.unlockDevice(this.params.pinType, { emitUiEvent: false });
   }
 }

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -13,10 +13,10 @@ import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
-import { createFirmwareProgressThrottle } from './progressThrottle';
 import { writeFirmwareByteSource } from './FirmwareArtifactSource';
 
 import type {
+  FirmwareProgress,
   IFirmwareUpdateProgressType,
   IFirmwareUpdateTipMessage,
 } from '../../events/ui-request';
@@ -41,6 +41,11 @@ const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
  */
 export const BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS = 5000;
 
+type FirmwareTransferMetrics = Pick<
+  FirmwareProgress['payload'],
+  'transferredBytes' | 'totalBytes' | 'rateBytesPerSecond' | 'elapsedMs'
+>;
+
 const isDeviceDisconnectedError = (error: unknown) => {
   const message = error instanceof Error ? error.message : String(error ?? '');
   return (
@@ -53,8 +58,6 @@ const isDeviceDisconnectedError = (error: unknown) => {
 export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   checkPromise: Deferred<any> | null = null;
 
-  private shouldPostFirmwareProgress = createFirmwareProgressThrottle();
-
   init(): void {}
 
   run(): Promise<any> {
@@ -97,16 +100,17 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
    * @description Post the progress message
    * @param progress Post the percentage of the progress
    */
-  postProgressMessage = (progress: number, progressType: IFirmwareUpdateProgressType) => {
-    if (!this.shouldPostFirmwareProgress(progress, progressType)) {
-      return;
-    }
-
+  postProgressMessage = (
+    progress: number,
+    progressType: IFirmwareUpdateProgressType,
+    metrics?: FirmwareTransferMetrics
+  ) => {
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
         device: this.device.toMessageObject() as KnownDevice,
         progress,
         progressType,
+        ...metrics,
       })
     );
   };
@@ -216,7 +220,8 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
             await this.device.deviceConnector?.acquire(
               this.device.originalDescriptor.id,
               null,
-              true
+              true,
+              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
             );
             // Bound each probe so a request the rebooting device never received
             // frees the slot for the next tick instead of hanging into the
@@ -255,7 +260,9 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   ) {
     const deviceDiff = await this.device.deviceConnector?.enumerate();
     const devicesDescriptor = deviceDiff?.descriptors ?? [];
-    const { deviceList } = await DevicePool.getDevices(devicesDescriptor, connectId);
+    const { deviceList } = await DevicePool.getDevices(devicesDescriptor, connectId, {
+      connectProtocol: this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType,
+    });
 
     if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
       // should update current device from cache
@@ -512,7 +519,12 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
         const env = DataManager.getSettings('env');
         if (DataManager.isBleConnect(env)) {
           await wait(3000);
-          await this.device.deviceConnector?.acquire(this.device.originalDescriptor.id, null, true);
+          await this.device.deviceConnector?.acquire(
+            this.device.originalDescriptor.id,
+            null,
+            true,
+            this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
+          );
           await this.device.initialize();
         } else if (
           error?.message?.indexOf(SESSION_ERROR) > -1 ||
@@ -520,7 +532,10 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
         ) {
           const deviceDiff = await this.device.deviceConnector?.enumerate();
           const devicesDescriptor = deviceDiff?.descriptors ?? [];
-          const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined);
+          const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
+            connectProtocol:
+              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType,
+          });
           if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
             this.device.updateFromCache(deviceList[0]);
             await this.device.acquire();

package/src/api/firmware/uploadFirmware.ts

@@ -362,7 +362,12 @@ const newTouchUpdateProcess = async (
       try {
         if (isBleReconnect) {
           try {
-            await device.deviceConnector?.acquire(device.originalDescriptor.id, null, true);
+            await device.deviceConnector?.acquire(
+              device.originalDescriptor.id,
+              null,
+              true,
+              device.originalDescriptor.protocolType
+            );
             const typedCall = device.getCommands().typedCall.bind(device.getCommands());
             await Promise.race([
               typedCall('Initialize', 'Features', {}),
@@ -381,7 +386,8 @@ const newTouchUpdateProcess = async (
           const devicesDescriptor = deviceDiff?.descriptors ?? [];
           const { deviceList } = await DevicePool.getDevices(
             devicesDescriptor,
-            device.originalDescriptor.id
+            device.originalDescriptor.id,
+            { connectProtocol: device.originalDescriptor.protocolType }
           );
           if (deviceList.length === 1) {
             device.updateFromCache(deviceList[0]);
@@ -456,7 +462,12 @@ const emmcFileWriteWithRetry = async (
       const env = DataManager.getSettings('env');
       if (DataManager.isBleConnect(env)) {
         await wait(3000);
-        await device.deviceConnector?.acquire(device.originalDescriptor.id, null, true);
+        await device.deviceConnector?.acquire(
+          device.originalDescriptor.id,
+          null,
+          true,
+          device.originalDescriptor.protocolType
+        );
         await device.initialize();
       } else if (
         error?.message?.indexOf(SESSION_ERROR) > -1 ||
@@ -464,7 +475,9 @@ const emmcFileWriteWithRetry = async (
       ) {
         const deviceDiff = await device.deviceConnector?.enumerate();
         const devicesDescriptor = deviceDiff?.descriptors ?? [];
-        const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined);
+        const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
+          connectProtocol: device.originalDescriptor.protocolType,
+        });
         if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
           device.updateFromCache(deviceList[0]);
           await device.acquire();