@onekeyfe/hd-core 1.2.2-alpha.0 → 1.2.2-alpha.100

package/src/api/FirmwareUpdateV4.ts

@@ -1,11 +1,4 @@
-import {
-  EDeviceType,
-  ERRORS,
-  HardwareError,
-  HardwareErrorCode,
-  isBleStaleBondHardwareError,
-  wait,
-} from '@onekeyfe/hd-shared';
+import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
 import JSZip from 'jszip';
 import {
   DeviceRebootType,
@@ -51,7 +44,6 @@ import {
   getProtocolV2UnknownErrorText,
   isProtocolV2DeviceDisconnectedError,
 } from './protocol-v2/helpers';
-import { isProtocolV2ResponseTimeout } from './helpers/protocolV2FileWrite';
 import {
   openFirmwareByteSource,
   readFirmwareByteSourceFully,
@@ -63,7 +55,6 @@ import {
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
   validateFirmwareUpdatePreparedPlan,
 } from './firmware/FirmwareUpdatePreparedPlan';
-
 import type {
   FirmwareArtifactReference,
   FirmwareUpdateV4Params,
@@ -93,7 +84,6 @@ const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
 const PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
 const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
 const PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY = 1000;
-const PROTOCOL_V2_INSTALL_FINISHED_AFTER_DISCONNECT_POLLS = 4;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
@@ -192,11 +182,6 @@ const getProtocolV2DeviceTransferProgress = (
 type ProtocolV2FirmwareUpdateStatusTarget = {
   target_id: number | string;
   status?: number | string;
-  progress_percent?: number;
-  phase_info?: {
-    phase: number | string;
-    progress_percent: number;
-  };
   payload_version?: number;
   path?: string;
 };
@@ -375,12 +360,11 @@ const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
 };
 
 const isProtocolV2TerminalInstallStatusError = (error: unknown) =>
-  isBleStaleBondHardwareError(error) ||
-  (error instanceof HardwareError &&
-    (error.errorCode === HardwareErrorCode.ActionCancelled ||
-      error.errorCode === HardwareErrorCode.FirmwareError ||
-      error.errorCode === HardwareErrorCode.FirmwareVerificationFailed ||
-      error.params?.firmwareUpdateCode === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE));
+  error instanceof HardwareError &&
+  (error.errorCode === HardwareErrorCode.ActionCancelled ||
+    error.errorCode === HardwareErrorCode.FirmwareError ||
+    error.errorCode === HardwareErrorCode.FirmwareVerificationFailed ||
+    error.params?.firmwareUpdateCode === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE);
 
 const isProtocolV2TargetStatusFinished = (status: ProtocolV2FirmwareUpdateStatusTarget['status']) =>
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_FINISHED;
@@ -417,18 +401,6 @@ const normalizeProtocolV2TargetStatus = (
   return undefined;
 };
 
-const PROTOCOL_V2_INSTALL_PHASE_BY_DECODED_VALUE = new Map<
-  number | string,
-  'prepare' | 'install' | 'verify'
->([
-  [0, 'prepare'],
-  [1, 'install'],
-  [2, 'verify'],
-  ['FW_MGMT_UPDATER_PHASE_PREPARE', 'prepare'],
-  ['FW_MGMT_UPDATER_PHASE_INSTALL', 'install'],
-  ['FW_MGMT_UPDATER_PHASE_VERIFY', 'verify'],
-]);
-
 const normalizeProtocolV2Hex = (value?: string) => value?.replace(/^0x/i, '').toLowerCase();
 
 const versionArrayToNumber = (version?: IVersionArray) => {
@@ -486,11 +458,6 @@ const toProtocolV2FiniteNumber = (value: unknown) => {
   return undefined;
 };
 
-const normalizeProtocolV2ProgressPercent = (value: unknown) => {
-  const progress = toProtocolV2FiniteNumber(value);
-  return progress === undefined ? undefined : Math.min(100, Math.max(0, progress));
-};
-
 export const isProtocolV2FirmwareFingerprintValid = (
   binary: ArrayBuffer | Uint8Array,
   fingerprint: string | undefined
@@ -563,10 +530,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2InstallBaselineVersions = new Map<number, string>();
 
-  private protocolV2InstallNeedsReconnect = false;
-
-  private protocolV2InstallTerminalSuccessObserved = false;
-
   private protocolV2LastRuntimeProbeFeatures?: Features;
 
   private protocolV2LastTransferProgress?: number;
@@ -1845,9 +1808,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       if (!expectedHeaderHash || header.headerHash !== expectedHeaderHash) return false;
       return true;
     } catch (error) {
-      if (isBleStaleBondHardwareError(error)) {
-        throw error;
-      }
       Log.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
       return false;
     }
@@ -1941,7 +1901,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         }
         lastError = new Error('Protocol V2 device is reachable but is not in bootloader mode');
       } catch (error) {
-        if (isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
           throw error;
         }
         shouldReconnect = true;
@@ -2223,9 +2183,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         });
         return processedSize + source.size;
       } catch (error) {
-        if (isBleStaleBondHardwareError(error)) {
-          throw error;
-        }
         lastError = error;
         if (attempt < PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
           await this.recoverProtocolV2FileTransfer();
@@ -2255,41 +2212,19 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
   }
 
-  private collectProtocolV2LiveTargetIds(
-    statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
-    expectedTargetIds: Set<number>,
-    liveTargetIds: Set<number>
-  ) {
-    statusTargets.forEach(target => {
-      const targetId = normalizeProtocolV2TargetId(target.target_id);
-      if (
-        targetId !== undefined &&
-        expectedTargetIds.has(targetId) &&
-        isProtocolV2TargetStatusInProgress(target.status)
-      ) {
-        liveTargetIds.add(targetId);
-      }
-    });
-  }
-
   private assertProtocolV2TargetStatus(
     statusTargets: ProtocolV2FirmwareUpdateStatusTarget[],
     expectedTargetIds: Set<number>,
-    expectedPaths?: Map<number, string>,
-    liveTargetIds?: Set<number>
+    expectedPaths = new Map<number, string>()
   ) {
-    const resolvedExpectedPaths = expectedPaths ?? new Map<number, string>();
     Log.log(
       `[FirmwareUpdateV4] DeviceFirmwareUpdateStatus records=${JSON.stringify(statusTargets)}`
     );
-    const failedTarget = statusTargets.find(target => {
-      const targetId = normalizeProtocolV2TargetId(target.target_id) ?? -1;
-      return (
-        expectedTargetIds.has(targetId) &&
-        isProtocolV2TargetStatusFailed(target.status) &&
-        (!liveTargetIds || liveTargetIds.has(targetId))
-      );
-    });
+    const failedTarget = statusTargets.find(
+      target =>
+        expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1) &&
+        isProtocolV2TargetStatusFailed(target.status)
+    );
     if (failedTarget) {
       const failedTargetDetails = JSON.stringify({
         targetId: failedTarget.target_id,
@@ -2306,27 +2241,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         }
       );
     }
-    if (liveTargetIds) {
-      const staleFailedTargets = statusTargets.filter(target => {
-        const targetId = normalizeProtocolV2TargetId(target.target_id) ?? -1;
-        return (
-          expectedTargetIds.has(targetId) &&
-          isProtocolV2TargetStatusFailed(target.status) &&
-          !liveTargetIds.has(targetId)
-        );
-      });
-      if (staleFailedTargets.length > 0) {
-        Log.log(
-          `[FirmwareUpdateV4] ignoring stale failed firmware status until those targets start: ${JSON.stringify(
-            staleFailedTargets.map(target => ({
-              targetId: target.target_id,
-              status: target.status,
-              path: target.path,
-            }))
-          )}`
-        );
-      }
-    }
 
     const matchingTargets = statusTargets.filter(target =>
       expectedTargetIds.has(normalizeProtocolV2TargetId(target.target_id) ?? -1)
@@ -2334,16 +2248,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const seenTargetIds = new Set<number>();
     for (const target of matchingTargets) {
       const targetId = normalizeProtocolV2TargetId(target.target_id);
-      const pathConflictsWithCurrentInstall =
-        targetId !== undefined &&
-        Boolean(target.path) &&
-        Boolean(resolvedExpectedPaths.get(targetId)) &&
-        target.path !== resolvedExpectedPaths.get(targetId) &&
-        (!liveTargetIds || liveTargetIds.has(targetId));
       if (
         targetId === undefined ||
         seenTargetIds.has(targetId) ||
-        pathConflictsWithCurrentInstall
+        (target.path && expectedPaths.get(targetId) && target.path !== expectedPaths.get(targetId))
       ) {
         Log.error(`[FirmwareUpdateV4] install status conflicts with target=${target.target_id}`);
         throw ERRORS.TypedError(
@@ -2356,13 +2264,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       }
       seenTargetIds.add(targetId);
     }
-    const completedTargets = matchingTargets.filter(target => {
-      const targetId = normalizeProtocolV2TargetId(target.target_id);
-      return (
-        isProtocolV2TargetStatusFinished(target.status) &&
-        (!liveTargetIds || (targetId !== undefined && liveTargetIds.has(targetId)))
-      );
-    });
+    const completedTargets = matchingTargets.filter(target =>
+      isProtocolV2TargetStatusFinished(target.status)
+    );
     const completedTargetIds = new Set<number>();
     completedTargets.forEach(target => {
       const targetId = normalizeProtocolV2TargetId(target.target_id);
@@ -2399,54 +2303,16 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     if (expectedTargetIds.size > 0 && matchingTargets.length > 0) {
-      let detailedProgress = completedTargetIds.size * 100;
-      let installProgressMetadata:
-        | {
-            installTargetId: number;
-            installPhase: 'prepare' | 'install' | 'verify';
-            installPhaseProgress: number;
-          }
-        | undefined;
-      let hasInProgressTarget = false;
-      matchingTargets.forEach(target => {
-        const targetId = normalizeProtocolV2TargetId(target.target_id);
-        if (
-          targetId === undefined ||
-          completedTargetIds.has(targetId) ||
-          !isProtocolV2TargetStatusInProgress(target.status) ||
-          (liveTargetIds && !liveTargetIds.has(targetId))
-        ) {
-          return;
-        }
-        hasInProgressTarget = true;
-        detailedProgress += normalizeProtocolV2ProgressPercent(target.progress_percent) ?? 0;
-        const installPhase = target.phase_info
-          ? PROTOCOL_V2_INSTALL_PHASE_BY_DECODED_VALUE.get(target.phase_info.phase)
-          : undefined;
-        const installPhaseProgress = normalizeProtocolV2ProgressPercent(
-          target.phase_info?.progress_percent
-        );
-        if (installPhase && installPhaseProgress !== undefined && !installProgressMetadata) {
-          installProgressMetadata = {
-            installTargetId: targetId,
-            installPhase,
-            installPhaseProgress,
-          };
-        }
-      });
+      const hasInProgressTarget = matchingTargets.some(target =>
+        isProtocolV2TargetStatusInProgress(target.status)
+      );
       const completedProgress = Math.floor(
         (completedTargetIds.size / expectedTargetIds.size) * 100
       );
-      const reportedProgress = Math.floor(detailedProgress / expectedTargetIds.size);
-      const progress = Math.min(
-        99,
-        Math.max(completedProgress, reportedProgress, hasInProgressTarget ? 1 : 0)
-      );
-      if (installProgressMetadata) {
-        this.postProgressMessage(progress, 'installingFirmware', installProgressMetadata);
-      } else {
-        this.postProgressMessage(progress, 'installingFirmware');
-      }
+      // The protocol exposes no per-target percentage, so report coarse progress by
+      // completed targets and use 1% once work starts to keep the UI responsive.
+      const progress = Math.min(99, Math.max(completedProgress, hasInProgressTarget ? 1 : 0));
+      this.postProgressMessage(progress, 'installingFirmware');
     }
 
     return false;
@@ -2517,25 +2383,14 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   ) {
     const expectedTargetIds = new Set(targets.map(target => target.target_id));
     const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
-    const isBleCoprocessorInstall =
-      this.isBleReconnect() &&
-      expectedTargetIds.has(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR);
     const startTime = Date.now();
     let lastError: unknown;
-    // The loader may release either USB or BLE as installation starts. Recovery reconnects
-    // directly to status polling without generic Ping or DeviceInfo probes.
-    let shouldReconnect = this.protocolV2InstallNeedsReconnect;
-    this.protocolV2InstallNeedsReconnect = false;
+    // DeviceFirmwareUpdateRequest leaves the current loader link usable for status polling.
+    // Reconnecting here probes DeviceInfo, which loaders reject while installation is active.
+    let shouldReconnect = false;
     let deviceInfo: ProtocolV2DeviceInfo | undefined;
-    let bleInstallLinkReady = false;
-    let installStatusDisconnectObserved = false;
-    let installReconnectObserved = false;
-    let finishedStatusSnapshotKey: string | undefined;
-    let finishedStatusSnapshotPolls = 0;
-    let fastFinishedInstallProgressReported = false;
-    let installEvidenceObserved = this.protocolV2InstallTerminalSuccessObserved;
+    let installEvidenceObserved = false;
     let currentInstallStatusObserved = false;
-    const liveTargetIds = new Set<number>();
 
     while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
       // A transport release caused by an explicit workflow cancellation must not
@@ -2543,40 +2398,43 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       this.throwIfAborted();
       try {
         if (shouldReconnect) {
-          const isBleInstallReconnect = this.isBleReconnect();
-          await this.reconnectProtocolV2Device({ skipProtocolProbe: true });
-          bleInstallLinkReady = isBleInstallReconnect;
-          deviceInfo = isBleInstallReconnect
-            ? undefined
-            : await this.verifyProtocolV2ReconnectIdentity();
-          if (isBleInstallReconnect && installStatusDisconnectObserved) {
-            installReconnectObserved = true;
-          }
+          await this.reconnectProtocolV2Device();
+          deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
           shouldReconnect = false;
         }
-        let currentDeviceInfo = deviceInfo;
+        const currentDeviceInfo = deviceInfo;
         try {
           const statusResponse = await this.device.getCommands().typedCall(
             'DeviceFirmwareUpdateStatusGet',
-            'DeviceFirmwareUpdateStatus',
+            ['DeviceFirmwareUpdateStatus', 'Success'],
             {
               fields: {
                 status: true,
-                progress_percent: true,
-                phase_info: true,
                 payload_version: true,
                 path: true,
               },
             },
             { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT }
           );
-          if (this.protocolV2InstallTerminalSuccessObserved) {
+          if (statusResponse.type === 'Success') {
             installEvidenceObserved = true;
+            lastError = new Error(
+              'Protocol V2 firmware install acknowledged; waiting for target status'
+            );
           }
-          const statusTargets = (statusResponse.message.records ??
-            []) as ProtocolV2FirmwareUpdateStatusTarget[];
-          this.collectProtocolV2LiveTargetIds(statusTargets, expectedTargetIds, liveTargetIds);
-          if (liveTargetIds.size > 0) {
+          const statusTargets =
+            statusResponse.type === 'DeviceFirmwareUpdateStatus'
+              ? ((statusResponse.message.records ?? []) as ProtocolV2FirmwareUpdateStatusTarget[])
+              : [];
+          const hasInProgressTarget = statusTargets.some(target => {
+            const targetId = normalizeProtocolV2TargetId(target.target_id);
+            return (
+              targetId !== undefined &&
+              expectedTargetIds.has(targetId) &&
+              isProtocolV2TargetStatusInProgress(target.status)
+            );
+          });
+          if (hasInProgressTarget) {
             currentInstallStatusObserved = true;
           }
           const hasMatchingTargetStatus = statusTargets.some(target => {
@@ -2593,101 +2451,18 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             const targetId = normalizeProtocolV2TargetId(target.target_id);
             return targetId !== undefined && expectedTargetIds.has(targetId);
           });
-          const matchingFinishedTargetIds = new Set<number>();
-          const matchingFinishedStatus = matchingStatusTargets
-            .map(target => {
-              const targetId = normalizeProtocolV2TargetId(target.target_id);
-              const expectedPath = targetId === undefined ? undefined : expectedPaths.get(targetId);
-              const expectedVersion =
-                targetId === undefined
-                  ? undefined
-                  : this.getExpectedProtocolV2TargetVersion(targetId);
-              const payloadVersion = toProtocolV2FiniteNumber(target.payload_version);
-              if (
-                targetId === undefined ||
-                matchingFinishedTargetIds.has(targetId) ||
-                !isProtocolV2TargetStatusFinished(target.status) ||
-                (Boolean(target.path) && Boolean(expectedPath) && target.path !== expectedPath) ||
-                (expectedVersion !== undefined &&
-                  payloadVersion !== undefined &&
-                  payloadVersion !== expectedVersion)
-              ) {
-                return undefined;
-              }
-              matchingFinishedTargetIds.add(targetId);
-              return [targetId, target.path ?? null, payloadVersion ?? null] as const;
-            })
-            .filter((target): target is readonly [number, string | null, number | null] => !!target)
-            .sort(([leftTargetId], [rightTargetId]) => leftTargetId - rightTargetId);
-          const hasCompleteMatchingFinishedStatus =
-            matchingFinishedStatus.length === expectedTargetIds.size &&
-            matchingFinishedTargetIds.size === expectedTargetIds.size &&
-            expectedTargetIds.size > 0;
-          if (
-            requireCurrentInstallStatus &&
-            installReconnectObserved &&
-            hasCompleteMatchingFinishedStatus
-          ) {
-            const nextSnapshotKey = JSON.stringify(matchingFinishedStatus);
-            if (nextSnapshotKey === finishedStatusSnapshotKey) {
-              finishedStatusSnapshotPolls += 1;
-            } else {
-              finishedStatusSnapshotKey = nextSnapshotKey;
-              finishedStatusSnapshotPolls = 1;
-            }
-          } else {
-            finishedStatusSnapshotKey = undefined;
-            finishedStatusSnapshotPolls = 0;
-          }
-          if (
-            requireCurrentInstallStatus &&
-            installReconnectObserved &&
-            hasCompleteMatchingFinishedStatus &&
-            !currentInstallStatusObserved &&
-            !this.protocolV2InstallTerminalSuccessObserved &&
-            !fastFinishedInstallProgressReported
-          ) {
-            // A fast BLE install may finish while disconnected, so IN_PROGRESS can be hidden.
-            // A status response timeout alone is not evidence that the install was accepted.
-            this.postProgressMessage(1, 'installingFirmware');
-            fastFinishedInstallProgressReported = true;
-          }
-          const finishedAfterDisconnectObserved =
-            finishedStatusSnapshotPolls >= PROTOCOL_V2_INSTALL_FINISHED_AFTER_DISCONNECT_POLLS;
-          const hasCurrentInstallEvidence =
-            currentInstallStatusObserved ||
-            this.protocolV2InstallTerminalSuccessObserved ||
-            finishedAfterDisconnectObserved;
-          if (hasCurrentInstallEvidence) {
-            installEvidenceObserved = true;
-          }
           const shouldVerifyTargetCompletion =
-            !requireCurrentInstallStatus || hasCurrentInstallEvidence;
+            !requireCurrentInstallStatus || currentInstallStatusObserved;
           if (
             shouldVerifyTargetCompletion &&
-            this.assertProtocolV2TargetStatus(
-              statusTargets,
-              expectedTargetIds,
-              expectedPaths,
-              requireCurrentInstallStatus &&
-                !this.protocolV2InstallTerminalSuccessObserved &&
-                !finishedAfterDisconnectObserved
-                ? liveTargetIds
-                : undefined
-            )
+            this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths)
           ) {
             return;
           }
 
-          if (!hasCurrentInstallEvidence) {
-            // A successful status poll clears DeviceCommands' cancel action. Keep cancellation
-            // available while UpdateRequest is still waiting for confirmation on the device.
-            this.device.setCancelableAction(() => this.device.getCommands().cancelDevice());
-          }
-
           if (
             requireCurrentInstallStatus &&
-            !hasCurrentInstallEvidence &&
+            !currentInstallStatusObserved &&
             matchingStatusTargets.length > 0
           ) {
             lastError = new Error(
@@ -2695,18 +2470,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             );
           }
 
-          if (
-            statusTargets.length === 0 &&
-            !currentDeviceInfo &&
-            bleInstallLinkReady &&
-            installEvidenceObserved
-          ) {
-            // BLE install reconnect skips generic probes because loaders may not answer Ping.
-            // Restore the verified identity only after current-install evidence disappears.
-            currentDeviceInfo = await this.verifyProtocolV2ReconnectIdentity();
-            deviceInfo = currentDeviceInfo;
-          }
-
           if (statusTargets.length === 0 && currentDeviceInfo) {
             const isNormalMode = await this.probeProtocolV2NormalMode(currentDeviceInfo);
             if (
@@ -2724,9 +2487,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           }
 
           if (statusTargets.length === 0) {
-            lastError = new Error(
-              'Protocol V2 firmware update is waiting for user confirmation or target status'
-            );
+            if (statusResponse.type !== 'Success') {
+              lastError = new Error(
+                'Protocol V2 firmware update is waiting for user confirmation or target status'
+              );
+            }
           } else {
             const missingTargetIds = this.getProtocolV2MissingTargetIds(
               statusTargets,
@@ -2749,22 +2514,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           // missing endpoint as completion only after the runtime probe confirms App mode.
           if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
             if (!currentDeviceInfo) {
-              if (!bleInstallLinkReady) {
-                throw ERRORS.TypedError(
-                  HardwareErrorCode.RuntimeError,
-                  'Protocol V2 device identity is unavailable during install polling'
-                );
-              }
-              deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
-            }
-            const reconnectDeviceInfo = currentDeviceInfo ?? deviceInfo;
-            if (!reconnectDeviceInfo) {
               throw ERRORS.TypedError(
                 HardwareErrorCode.RuntimeError,
                 'Protocol V2 device identity is unavailable during install polling'
               );
             }
-            const isNormalMode = await this.probeProtocolV2NormalMode(reconnectDeviceInfo);
+            const isNormalMode = await this.probeProtocolV2NormalMode(currentDeviceInfo);
             if (
               isNormalMode &&
               (installEvidenceObserved ||
@@ -2787,18 +2542,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               );
             }
           } else {
-            if (
-              isBleCoprocessorInstall &&
-              isProtocolV2DeviceDisconnectedError(error) &&
-              !isProtocolV2ResponseTimeout(error)
-            ) {
-              installStatusDisconnectObserved = true;
-              finishedStatusSnapshotKey = undefined;
-              finishedStatusSnapshotPolls = 0;
-            }
             shouldReconnect = true;
             deviceInfo = undefined;
-            bleInstallLinkReady = false;
             lastError = error;
             Log.log(
               '[FirmwareUpdateV4] DeviceFirmwareUpdateStatusGet unavailable during install: ',
@@ -2822,7 +2567,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         }
         shouldReconnect = true;
         deviceInfo = undefined;
-        bleInstallLinkReady = false;
         Log.log('Protocol V2 firmware install device readiness probe failed: ', error);
       }
       await wait(1000);
@@ -2851,9 +2595,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         return;
       }
     } catch (error) {
-      if (isBleStaleBondHardwareError(error)) {
-        throw error;
-      }
       Log.log('[FirmwareUpdateV4] unable to confirm App mode before Normal reboot: ', error);
     }
     await this.protocolV2Reboot(DeviceRebootType.Normal);
@@ -2945,7 +2686,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           'Protocol V2 device is still in bootloader mode'
         );
       } catch (error) {
-        if (isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
+        if (this.isProtocolV2ReconnectIdentityError(error)) {
           throw error;
         }
         shouldReconnect = true;
@@ -2963,53 +2704,19 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     );
   }
 
-  private async reconnectProtocolV2Device(options?: { skipProtocolProbe?: boolean }) {
+  private async reconnectProtocolV2Device() {
     if (this.isBleReconnect()) {
-      await this.acquireProtocolV2BleDevice(options?.skipProtocolProbe);
+      await this.acquireProtocolV2BleDevice();
       return;
     }
 
     const deviceDiff = await this.device.deviceConnector?.enumerate();
     const devicesDescriptor = deviceDiff?.descriptors ?? [];
-    const env = DataManager.getSettings('env');
-    const isWebUsb = DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env);
-
-    if (isWebUsb && options?.skipProtocolProbe) {
-      const expectedSerialNumber = this.protocolV2ExpectedSerialNumber?.trim();
-      const expectedPath = this.protocolV2ExpectedPath?.trim();
-      const reconnectDescriptor = devicesDescriptor.find(descriptor => {
-        const descriptorPath = descriptor.path?.trim();
-        return (
-          (!!expectedSerialNumber && descriptorPath === expectedSerialNumber) ||
-          (!!expectedPath && descriptorPath === expectedPath)
-        );
-      });
-      if (!reconnectDescriptor?.path) {
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
-      }
-      this.device.updateDescriptor(
-        {
-          ...reconnectDescriptor,
-          protocolType: PROTOCOL_V2_CONNECT_PROTOCOL,
-        },
-        true
-      );
-      const mainId = await this.device.deviceConnector?.acquire(
-        reconnectDescriptor.path,
-        null,
-        undefined,
-        PROTOCOL_V2_CONNECT_PROTOCOL,
-        undefined,
-        undefined,
-        true
-      );
-      this.device.mainId = typeof mainId === 'string' ? mainId : reconnectDescriptor.path;
-      this.device.commands.disposed = false;
-      this.device.getCommands().mainId = this.device.mainId;
-      return;
-    }
 
-    if (isWebUsb && devicesDescriptor.length === 1) {
+    if (
+      DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
+      devicesDescriptor.length === 1
+    ) {
       const descriptor = devicesDescriptor[0];
       if (!this.protocolV2ExpectedSerialNumber && descriptor.path !== this.protocolV2ExpectedPath) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
@@ -3127,24 +2834,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     await wait(2000);
   }
 
-  private async acquireProtocolV2BleDevice(skipProtocolProbe = false) {
-    const connector = this.device.deviceConnector;
-    const expectedId = this.device.originalDescriptor.id;
-    if (!skipProtocolProbe) {
-      await connector?.acquire(expectedId, null, true, PROTOCOL_V2_CONNECT_PROTOCOL);
-      return;
-    }
-    await connector?.acquire(
-      expectedId,
+  private async acquireProtocolV2BleDevice() {
+    await this.device.deviceConnector?.acquire(
+      this.device.originalDescriptor.id,
       null,
       true,
-      PROTOCOL_V2_CONNECT_PROTOCOL,
-      undefined,
-      undefined,
-      skipProtocolProbe
+      PROTOCOL_V2_CONNECT_PROTOCOL
     );
-    this.device.commands.disposed = false;
-    this.device.getCommands().mainId = expectedId;
   }
 
   private async protocolV2StartFirmwareUpdate({
@@ -3153,11 +2849,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     targets: Array<{ target_id: number; path: string }>;
   }) {
     this.protocolV2LastRuntimeProbeFeatures = undefined;
-    this.protocolV2InstallNeedsReconnect = false;
-    this.protocolV2InstallTerminalSuccessObserved = false;
     const commands = this.device.getCommands();
     await commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
-    this.device.setCancelableAction(() => this.device.getCommands().cancelDevice());
+    this.device.setCancelableAction(() => commands.cancelDevice());
     const interaction = this.device.createProtocolV2UiPhaseMetadata('button', 'start');
     this.postMessage(
       createUiMessage(UI_REQUEST.REQUEST_BUTTON, {
@@ -3170,54 +2864,19 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         ...(interaction ? { interaction } : {}),
       })
     );
-
-    try {
-      await commands.call(
-        'DeviceFirmwareUpdateRequest',
-        {},
-        {
-          returnAfterWrite: true,
-          expectedTypes: ['Success'],
-          onResponseAfterWrite: response => {
-            if (response.type !== 'Success') return;
-            this.protocolV2InstallTerminalSuccessObserved = true;
-            this.device.clearCancelableAction();
-            Log.log('[FirmwareUpdateV4] firmware install completed by device response');
-          },
-        }
-      );
-      Log.log('[FirmwareUpdateV4] firmware install request written; continue with status polling');
-    } catch (error) {
-      this.throwIfAborted();
-      if (!isProtocolV2DeviceDisconnectedError(error)) {
-        throw error;
-      }
-      Log.log(
-        '[FirmwareUpdateV4] transport released while writing install request; continue status polling'
-      );
-      this.protocolV2InstallNeedsReconnect = true;
-    }
+    await commands.call('DeviceFirmwareUpdateRequest', {}, { returnAfterWrite: true });
   }
 
   private async protocolV2Reboot(rebootType: DeviceRebootType) {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
     try {
-      const res = await typedCall(
-        'DeviceReboot',
-        'Success',
-        {
-          reboot_type: rebootType,
-        },
-        { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT }
-      );
+      const res = await typedCall('DeviceReboot', 'Success', {
+        reboot_type: rebootType,
+      });
       this.device.markProtocolV2Reboot(rebootType);
       return res.message;
     } catch (error) {
-      if (
-        isProtocolV2DeviceDisconnectedError(error) ||
-        isProtocolV2ReconnectProbeError(error) ||
-        isProtocolV2ResponseTimeout(error)
-      ) {
+      if (isProtocolV2DeviceDisconnectedError(error) || isProtocolV2ReconnectProbeError(error)) {
         this.device.markProtocolV2Reboot(rebootType);
         return { message: 'Device rebooted successfully' };
       }