@onekeyfe/hd-core 1.2.0-alpha.13 → 1.2.0-alpha.131

package/src/api/FirmwareUpdateV3.ts

@@ -9,20 +9,33 @@ import {
   getDeviceBLEFirmwareVersion,
   getDeviceBootloaderVersion,
   getDeviceFirmwareVersion,
-  getDeviceType,
-  getFirmwareType,
+  getDeviceUUID,
   getLogger,
 } from '../utils';
 import { getBinary, getSysResourceBinary } from './firmware/getBinary';
+import { normalizeFirmwarePreparationError } from './firmware/FirmwarePreparationError';
 import { DataManager } from '../data-manager';
 import { FirmwareUpdateBaseMethod } from './firmware/FirmwareUpdateBaseMethod';
 import { DevicePool } from '../device/DevicePool';
 import { DEVICE } from '../events';
 import { buildProtocolV1FeaturesPayload } from '../deviceProfile';
-
-import type { FirmwareUpdateV3Params } from '../types/api/firmwareUpdate';
+import { openFirmwareByteSource } from './firmware/FirmwareArtifactSource';
+import { resolveFirmwareUpdateHostBinding } from './firmware/FirmwareHostBinding';
+import { readVerifiedPreparedResourceArchive } from './firmware/FirmwarePreparedResourceArchive';
+import {
+  assertFirmwareUpdatePreparedPlanBinding,
+  assertFirmwareUpdatePreparedPlanDeviceIdentity,
+  getFirmwareUpdatePreparedRawArtifact,
+  validateFirmwareUpdatePreparedPlan,
+} from './firmware/FirmwareUpdatePreparedPlan';
+
+import type {
+  FirmwareArtifactReference,
+  FirmwareUpdateV3Params,
+} from '../types/api/firmwareUpdate';
 import type { Deferred, EFirmwareType } from '@onekeyfe/hd-shared';
 import type { TypedResponseMessage } from '../device/DeviceCommands';
+import type { FirmwareByteSource } from './firmware/FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 
@@ -44,6 +57,8 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private isSwitchFirmware = false;
 
+  private artifactSources: FirmwareByteSource[] = [];
+
   init() {
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
     this.requireDeviceMode = [];
@@ -64,8 +79,97 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'firmwareType', type: 'string' },
       { name: 'platform', type: 'string' },
     ]);
+    const hasPreparedPlan = payload.preparedPlan !== undefined;
+    if (!hasPreparedPlan && payload.artifacts !== undefined) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Firmware artifacts require a prepared plan'
+      );
+    }
+    const preparedPlan = hasPreparedPlan
+      ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
+      : undefined;
+    const hasLegacyInputs = [
+      payload.bleVersion,
+      payload.bleBinary,
+      payload.firmwareVersion,
+      payload.firmwareBinary,
+      payload.resourceBinary,
+      payload.bootloaderVersion,
+      payload.bootloaderBinary,
+    ].some(input => input !== undefined);
+    if (preparedPlan && hasLegacyInputs) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Prepared firmware plans cannot be combined with legacy firmware inputs'
+      );
+    }
+    const artifactReader = preparedPlan
+      ? resolveFirmwareUpdateHostBinding(
+          payload.hostBindingGeneration,
+          preparedPlan.preparedPlanDigest
+        ).artifactReader
+      : payload.artifactReader;
+    const preparedArtifacts: NonNullable<FirmwareUpdateV3Params['artifacts']> = {};
+    if (preparedPlan) {
+      const componentTargets = ['bootloader', 'firmware', 'ble'] as const;
+      const supportedTargets = new Set<string>([...componentTargets, 'resource']);
+      const unsupportedTarget = preparedPlan.targetsToUpdate.find(
+        target => !supportedTargets.has(target)
+      );
+      if (unsupportedTarget) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Firmware prepared plan target ${unsupportedTarget} is not supported by V3`,
+          { firmwareUpdateCode: 'FirmwarePreparedPlanInvalid' }
+        );
+      }
+      for (const target of componentTargets) {
+        if (preparedPlan.targetsToUpdate.includes(target)) {
+          preparedArtifacts[target] = getFirmwareUpdatePreparedRawArtifact({
+            preparedPlan,
+            target,
+            role: target,
+          }).artifact;
+        }
+      }
+      const resourceBindings = (payload.artifacts?.resourceEntries ?? []).map(
+        (entry: { entryName: string; artifact: FirmwareArtifactReference }) => ({
+          target: 'resource' as const,
+          entryName: entry.entryName,
+          artifact: entry.artifact,
+        })
+      );
+      assertFirmwareUpdatePreparedPlanBinding({
+        preparedPlan,
+        executor: 'v3',
+        platform: payload.platform,
+        scopeTargets: [
+          'bootloader',
+          'firmware',
+          'ble',
+          ...(resourceBindings.length ? (['resource'] as const) : []),
+        ],
+        bindings: [
+          ...componentTargets.flatMap(target => {
+            const plannedArtifact = preparedArtifacts[target];
+            const suppliedArtifact = payload.artifacts?.[target];
+            return plannedArtifact || suppliedArtifact
+              ? [
+                  {
+                    target,
+                    artifact: suppliedArtifact ?? (plannedArtifact as FirmwareArtifactReference),
+                  },
+                ]
+              : [];
+          }),
+          ...resourceBindings,
+        ],
+      });
+    }
 
     this.params = {
+      preparedPlan,
       bleBinary: payload.bleBinary,
       firmwareBinary: payload.firmwareBinary,
       forcedUpdateRes: payload.forcedUpdateRes,
@@ -74,18 +178,14 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       bootloaderBinary: payload.bootloaderBinary,
       firmwareVersion: payload.firmwareVersion,
       resourceBinary: payload.resourceBinary,
-      firmwareType: payload.firmwareType,
+      firmwareType: preparedPlan?.firmwareType ?? payload.firmwareType,
       platform: payload.platform,
+      artifactReader,
+      artifacts: preparedPlan ? preparedArtifacts : undefined,
     };
   }
 
   async run() {
-    if (this.device.isProtocolV2()) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Protocol V2 firmware update must use firmwareUpdateV4'
-      );
-    }
     Log.debug('FirmwareUpdateV3 strategy: Protocol V1');
     return this.runProtocolV1();
   }
@@ -97,47 +197,61 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     const { device } = this;
     const { features } = device;
 
-    const deviceType = getDeviceType(features);
-    const bootloaderCurrVersion = getDeviceBootloaderVersion(features).join('.');
+    const deviceType = device.getCurrentDeviceType();
+    const bootloaderCurrVersion = device.getCurrentBootloaderVersionString() ?? '0.0.0';
 
     this.validateDeviceAndVersion(deviceType, bootloaderCurrVersion);
 
     if (!features) {
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device features not available');
     }
+    if (this.params.preparedPlan) {
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan: this.params.preparedPlan,
+        deviceIdentity: getDeviceUUID(features) || undefined,
+      });
+    }
 
-    const deviceFirmwareType = getFirmwareType(features);
+    const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = this.params.firmwareType ?? deviceFirmwareType;
     this.isSwitchFirmware = firmwareType !== deviceFirmwareType;
 
     let resourceBinary: ArrayBuffer | null = null;
-    let fwBinaryMap: { fileName: string; binary: ArrayBuffer }[] = [];
-    let bootloaderBinary: ArrayBuffer | null = null;
+    let resourceEntries: Array<{ entryName: string; source: FirmwareByteSource }> = [];
+    let fwSources: Array<{ fileName: string; source: FirmwareByteSource }> = [];
+    let bootloaderSource: FirmwareByteSource | null = null;
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
-      resourceBinary = await this.prepareResourceBinary(firmwareType);
-      fwBinaryMap = await this.prepareFirmwareAndBleBinary(firmwareType);
-      bootloaderBinary = await this.prepareBootloaderBinary(firmwareType);
+      const resourceInput = await this.prepareResourceInput(firmwareType);
+      resourceBinary = resourceInput.resourceBinary;
+      resourceEntries = resourceInput.resourceEntries;
+      fwSources = await this.prepareFirmwareAndBleSources(firmwareType);
+      bootloaderSource = await this.prepareBootloaderSource(firmwareType);
       this.postTipMessage(FirmwareUpdateTipMessage.FinishDownloadFirmware);
     } catch (err) {
-      throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, err.message ?? err);
+      await this.closeArtifactSources();
+      throw normalizeFirmwarePreparationError(err);
     }
 
-    if (!bootloaderBinary && fwBinaryMap.length === 0) {
+    if (!bootloaderSource && fwSources.length === 0) {
+      await this.closeArtifactSources();
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareUpdateDownloadFailed,
         'No firmware to update'
       );
     }
 
-    await this.enterBootloaderMode();
-
-    const updateResult = await this.executeUpdate({
-      resourceBinary,
-      fwBinaryMap,
-      bootloaderBinary,
-    });
-    return updateResult;
+    try {
+      await this.enterBootloaderMode();
+      return await this.executeUpdate({
+        resourceBinary,
+        resourceEntries,
+        fwSources,
+        bootloaderSource,
+      });
+    } finally {
+      await this.closeArtifactSources();
+    }
   }
 
   private validateDeviceAndVersion(deviceType: EDeviceType, bootloaderVersion: string) {
@@ -157,12 +271,81 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
-  private async prepareResourceBinary(firmwareType: EFirmwareType) {
+  private async openArtifactSource(
+    binary: ArrayBuffer | undefined,
+    artifact: FirmwareArtifactReference | undefined
+  ) {
+    const source = await openFirmwareByteSource({
+      binary,
+      artifact,
+      reader: this.params.artifactReader,
+    });
+    if (source) {
+      this.artifactSources.push(source);
+    }
+    return source;
+  }
+
+  private async closeArtifactSources() {
+    const sources = this.artifactSources.splice(0);
+    await Promise.all(sources.map(source => source.close().catch(() => undefined)));
+  }
+
+  private assertSdkDownloadAllowed(artifactName: string) {
+    if (
+      this.params.artifactReader ||
+      DataManager.getSettings('firmwareManifestMode') === 'external-only'
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `${artifactName} must be prepared by the external firmware host`,
+        {
+          firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+          artifactName,
+        }
+      );
+    }
+  }
+
+  private async prepareResourceInput(firmwareType: EFirmwareType) {
+    if (this.params.preparedPlan?.targetsToUpdate.includes('resource')) {
+      const verifiedEntries = await readVerifiedPreparedResourceArchive({
+        preparedPlan: this.params.preparedPlan,
+        reader: this.params.artifactReader,
+      });
+      const resourceEntries: Array<{ entryName: string; source: FirmwareByteSource }> = [];
+      for (const entry of verifiedEntries) {
+        const source = await this.openArtifactSource(entry.binary, undefined);
+        if (!source) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            `Firmware resource entry ${entry.entryName} is empty`,
+            {
+              firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+              artifactName: 'resource',
+            }
+          );
+        }
+        resourceEntries.push({ entryName: entry.entryName, source });
+      }
+      return {
+        resourceBinary: null,
+        resourceEntries,
+      };
+    }
     if (this.params.resourceBinary) {
-      return this.params.resourceBinary;
+      return {
+        resourceBinary: this.params.resourceBinary,
+        resourceEntries: [],
+      };
     }
     const { features } = this.device;
-    if (!features) return null;
+    if (!features) {
+      return {
+        resourceBinary: null,
+        resourceEntries: [],
+      };
+    }
     const resourceUrl = DataManager.getSysResourcesLatestRelease({
       features,
       forcedUpdateRes: this.params.forcedUpdateRes,
@@ -170,16 +353,27 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     });
 
     if (resourceUrl) {
-      const resource = (await getSysResourceBinary(resourceUrl)).binary;
-      return resource;
+      this.assertSdkDownloadAllowed('resource');
+      return {
+        resourceBinary: (await getSysResourceBinary(resourceUrl)).binary,
+        resourceEntries: [],
+      };
     }
     Log.warn('No resource url found');
-    return null;
+    return {
+      resourceBinary: null,
+      resourceEntries: [],
+    };
   }
 
-  private async prepareBootloaderBinary(firmwareType: EFirmwareType): Promise<ArrayBuffer | null> {
-    if (this.params.bootloaderBinary) {
-      return this.params.bootloaderBinary;
+  private async prepareBootloaderSource(
+    firmwareType: EFirmwareType
+  ): Promise<FirmwareByteSource | null> {
+    if (this.params.bootloaderBinary || this.params.artifacts?.bootloader) {
+      return this.openArtifactSource(
+        this.params.bootloaderBinary,
+        this.params.artifacts?.bootloader
+      );
     }
     const { features } = this.device;
     if (!features) return null;
@@ -187,23 +381,35 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     if (this.params.bootloaderVersion) {
       const bootResourceUrl = DataManager.getBootloaderResource(features, firmwareType);
       if (bootResourceUrl) {
+        this.assertSdkDownloadAllowed('bootloader');
         const bootBinary = (await getSysResourceBinary(bootResourceUrl)).binary;
-        return bootBinary;
+        return this.openArtifactSource(bootBinary, undefined);
       }
     }
     return null;
   }
 
-  private async prepareFirmwareAndBleBinary(firmwareType: EFirmwareType) {
-    const fwBinaryMap: { fileName: string; binary: ArrayBuffer }[] = [];
-    if (this.params.firmwareBinary) {
-      fwBinaryMap.push({
+  private async prepareFirmwareAndBleSources(firmwareType: EFirmwareType) {
+    const fwSources: Array<{ fileName: string; source: FirmwareByteSource }> = [];
+    if (this.params.firmwareBinary || this.params.artifacts?.firmware) {
+      const source = await this.openArtifactSource(
+        this.params.firmwareBinary,
+        this.params.artifacts?.firmware
+      );
+      if (!source) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Firmware artifact is not prepared'
+        );
+      }
+      fwSources.push({
         fileName: 'firmware.bin',
-        binary: this.params.firmwareBinary,
+        source,
       });
     } else if (this.params.firmwareVersion) {
       const { features } = this.device;
       if (features) {
+        this.assertSdkDownloadAllowed('firmware');
         const firmwareBinary = (
           await getBinary({
             features,
@@ -213,44 +419,65 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
             firmwareType,
           })
         ).binary;
-        fwBinaryMap.push({
+        const source = await this.openArtifactSource(firmwareBinary, undefined);
+        if (!source) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            'Firmware binary is not prepared'
+          );
+        }
+        fwSources.push({
           fileName: 'firmware.bin',
-          binary: firmwareBinary,
+          source,
         });
       }
     }
 
-    if (this.params.bleBinary) {
-      fwBinaryMap.push({
+    if (this.params.bleBinary || this.params.artifacts?.ble) {
+      const source = await this.openArtifactSource(
+        this.params.bleBinary,
+        this.params.artifacts?.ble
+      );
+      if (!source) {
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'BLE artifact is not prepared');
+      }
+      fwSources.push({
         fileName: 'ble-firmware.bin',
-        binary: this.params.bleBinary,
+        source,
       });
     } else if (this.params.bleVersion) {
       const { features } = this.device;
       if (features) {
+        this.assertSdkDownloadAllowed('ble');
         const bleBinary = await getBinary({
           features,
           version: this.params.bleVersion,
           updateType: 'ble',
           firmwareType,
         });
-        fwBinaryMap.push({
+        const source = await this.openArtifactSource(bleBinary.binary, undefined);
+        if (!source) {
+          throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'BLE binary is not prepared');
+        }
+        fwSources.push({
           fileName: 'ble-firmware.bin',
-          binary: bleBinary.binary,
+          source,
         });
       }
     }
-    return fwBinaryMap;
+    return fwSources;
   }
 
   private async executeUpdate({
     resourceBinary,
-    fwBinaryMap,
-    bootloaderBinary,
+    resourceEntries,
+    fwSources,
+    bootloaderSource,
   }: {
     resourceBinary: ArrayBuffer | null;
-    fwBinaryMap: { fileName: string; binary: ArrayBuffer }[];
-    bootloaderBinary: ArrayBuffer | null;
+    resourceEntries: Array<{ entryName: string; source: FirmwareByteSource }>;
+    fwSources: Array<{ fileName: string; source: FirmwareByteSource }>;
+    bootloaderSource: FirmwareByteSource | null;
   }) {
     let totalSize = 0;
     let processedSize = 0;
@@ -258,11 +485,14 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     if (resourceBinary) {
       totalSize += resourceBinary.byteLength;
     }
-    for (const fwbinary of fwBinaryMap) {
-      totalSize += fwbinary.binary.byteLength;
+    for (const entry of resourceEntries) {
+      totalSize += entry.source.size;
     }
-    if (bootloaderBinary) {
-      totalSize += bootloaderBinary.byteLength;
+    for (const firmware of fwSources) {
+      totalSize += firmware.source.size;
+    }
+    if (bootloaderSource) {
+      totalSize += bootloaderSource.size;
     }
 
     this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
@@ -285,9 +515,18 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       }
     }
 
-    if (bootloaderBinary) {
-      processedSize = await this.emmcCommonUpdateProcess({
-        payload: bootloaderBinary,
+    for (const entry of resourceEntries) {
+      processedSize = await this.emmcCommonUpdateProcessFromSource({
+        source: entry.source,
+        filePath: `0:res/${entry.entryName}`,
+        processedSize,
+        totalSize,
+      });
+    }
+
+    if (bootloaderSource) {
+      processedSize = await this.emmcCommonUpdateProcessFromSource({
+        source: bootloaderSource,
         filePath: `0:boot/bootloader.bin`,
         processedSize,
         totalSize,
@@ -296,11 +535,11 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
 
     await this.createUpdatesFolderIfNotExists(`0:updates/`);
 
-    for (const fwbinary of fwBinaryMap) {
-      if (fwbinary) {
-        processedSize = await this.emmcCommonUpdateProcess({
-          payload: fwbinary.binary,
-          filePath: `0:updates/${fwbinary.fileName}`,
+    for (const firmware of fwSources) {
+      if (firmware) {
+        processedSize = await this.emmcCommonUpdateProcessFromSource({
+          source: firmware.source,
+          filePath: `0:updates/${firmware.fileName}`,
           processedSize,
           totalSize,
         });
@@ -370,29 +609,40 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       try {
         const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
         const timeoutMs = 3000;
-        const featuresRes = await Promise.race<TypedResponseMessage<'Features'>>([
-          typedCall('GetFeatures', 'Features', {}),
-          new Promise<never>((_, reject) => {
-            setTimeout(
-              () =>
-                reject(
-                  ERRORS.TypedError(
-                    HardwareErrorCode.CallMethodNotResponse,
-                    'GetFeatures timeout',
-                    { method: 'GetFeatures', timeoutMs }
-                  )
-                ),
-              timeoutMs
-            );
-          }),
-        ]);
+        const isBrowserWebUsb = DataManager.isBrowserWebUsb(DataManager.getSettings('env'));
+        const getFeaturesPromise = isBrowserWebUsb
+          ? typedCall('GetFeatures', 'Features', {}, { timeoutMs })
+          : typedCall('GetFeatures', 'Features', {});
+        // WebUSB owns timeout cleanup so a reboot cannot leave a pending transfer blocking reconnect.
+        const featuresRes = isBrowserWebUsb
+          ? await getFeaturesPromise
+          : await Promise.race<TypedResponseMessage<'Features'>>([
+              getFeaturesPromise,
+              new Promise<never>((_, reject) => {
+                setTimeout(
+                  () =>
+                    reject(
+                      ERRORS.TypedError(
+                        HardwareErrorCode.CallMethodNotResponse,
+                        'GetFeatures timeout',
+                        { method: 'GetFeatures', timeoutMs }
+                      )
+                    ),
+                  timeoutMs
+                );
+              }),
+            ]);
         getFeaturesTimeoutCount = 0;
         const features = buildProtocolV1FeaturesPayload(featuresRes.message, this.device.features);
         const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
         const bleVersion = getDeviceBLEFirmwareVersion(features).join('.');
         const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
-        // Treat update as complete once firmware version becomes non-zero
-        if (firmwareVersion !== '0.0.0') {
+        // Browser WebUSB may read updater Features before the final reboot. Do not let cached
+        // pre-update versions promote a current 0.0.0 response to install completion.
+        const completionFirmwareVersion = isBrowserWebUsb
+          ? getDeviceFirmwareVersion(featuresRes.message).join('.')
+          : firmwareVersion;
+        if (completionFirmwareVersion !== '0.0.0') {
           this.postTipMessage(FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
           DevicePool.resetState();
           return {
@@ -401,7 +651,6 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
             firmwareVersion,
           };
         }
-        // Still in update mode; continue polling (e.g., iOS may return firmwareVersion 0.0.0 during switches)
         await wait(1000);
       } catch (error) {
         Log.log('getFeatures error', error);
@@ -431,7 +680,8 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
            * 2. While including bootloader upgrade
            */
           const reconnectTimeout =
-            this.isBleReconnect() && (this.params.bleBinary || this.params.bleVersion)
+            this.isBleReconnect() &&
+            (this.params.bleBinary || this.params.bleVersion || this.params.artifacts?.ble)
               ? 3 * 60 * 1000 // 3 minutes for BLE reconnect
               : 60 * 1000; // 1 minute for normal reconnect
 
@@ -511,7 +761,8 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
             await this.device.deviceConnector?.acquire(
               this.device.originalDescriptor.id,
               null,
-              true
+              true,
+              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
             );
             const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
             await Promise.race([
@@ -548,11 +799,18 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
             webUsbCheckCount = 0;
           }
 
-          const { deviceList } = await DevicePool.getDevices(devicesDescriptor, this.connectId);
+          const { deviceList } = await DevicePool.getDevices(devicesDescriptor, this.connectId, {
+            connectProtocol:
+              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType,
+          });
 
           if (deviceList.length === 1) {
             this.device.updateFromCache(deviceList[0]);
-            await this.device.acquire();
+            // Reconnect failures are expected while installation still owns USB.
+            // Keep them in this polling loop instead of rejecting the active firmware run.
+            await this.device.acquire(undefined, {
+              throwOnRunPromiseError: true,
+            });
             this.device.commands.disposed = false;
             this.device.getCommands().mainId = this.device.mainId ?? '';
             return;