@onekeyfe/hd-core 1.2.0-alpha.183 → 1.2.0-alpha.185

package/src/api/FirmwareUpdateV4.ts

@@ -1,4 +1,11 @@
-import { EDeviceType, ERRORS, HardwareError, HardwareErrorCode, wait } from '@onekeyfe/hd-shared';
+import {
+  EDeviceType,
+  ERRORS,
+  HardwareError,
+  HardwareErrorCode,
+  isBleStaleBondHardwareError,
+  wait,
+} from '@onekeyfe/hd-shared';
 import JSZip from 'jszip';
 import {
   DeviceRebootType,
@@ -44,6 +51,7 @@ import {
   getProtocolV2UnknownErrorText,
   isProtocolV2DeviceDisconnectedError,
 } from './protocol-v2/helpers';
+import { isProtocolV2ResponseTimeout } from './helpers/protocolV2FileWrite';
 import {
   openFirmwareByteSource,
   readFirmwareByteSourceFully,
@@ -55,6 +63,7 @@ import {
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
   validateFirmwareUpdatePreparedPlan,
 } from './firmware/FirmwareUpdatePreparedPlan';
+
 import type {
   FirmwareArtifactReference,
   FirmwareUpdateV4Params,
@@ -84,6 +93,7 @@ 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_RECONNECT_POLLS = 4;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
@@ -182,6 +192,11 @@ 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;
 };
@@ -360,11 +375,12 @@ const isProtocolV2FirmwareStatusEndpointUnavailable = (error: unknown) => {
 };
 
 const isProtocolV2TerminalInstallStatusError = (error: unknown) =>
-  error instanceof HardwareError &&
-  (error.errorCode === HardwareErrorCode.ActionCancelled ||
-    error.errorCode === HardwareErrorCode.FirmwareError ||
-    error.errorCode === HardwareErrorCode.FirmwareVerificationFailed ||
-    error.params?.firmwareUpdateCode === PROTOCOL_V2_INSTALL_STATUS_CONFLICT_CODE);
+  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));
 
 const isProtocolV2TargetStatusFinished = (status: ProtocolV2FirmwareUpdateStatusTarget['status']) =>
   normalizeProtocolV2TargetStatus(status) === PROTOCOL_V2_TARGET_STATUS_FINISHED;
@@ -401,6 +417,18 @@ 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) => {
@@ -458,6 +486,11 @@ 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
@@ -1812,6 +1845,9 @@ 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;
     }
@@ -1905,7 +1941,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 (this.isProtocolV2ReconnectIdentityError(error)) {
+        if (isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
           throw error;
         }
         shouldReconnect = true;
@@ -2187,6 +2223,9 @@ 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();
@@ -2296,6 +2335,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     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) &&
@@ -2359,16 +2399,54 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     if (expectedTargetIds.size > 0 && matchingTargets.length > 0) {
-      const hasInProgressTarget = matchingTargets.some(target =>
-        isProtocolV2TargetStatusInProgress(target.status)
-      );
+      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 completedProgress = Math.floor(
         (completedTargetIds.size / expectedTargetIds.size) * 100
       );
-      // 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');
+      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');
+      }
     }
 
     return false;
@@ -2444,9 +2522,14 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     // 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;
+    let installTransportReleaseObserved = shouldReconnect;
     this.protocolV2InstallNeedsReconnect = false;
     let deviceInfo: ProtocolV2DeviceInfo | undefined;
     let bleInstallLinkReady = false;
+    let installReconnectObserved = false;
+    let finishedStatusSnapshotKey: string | undefined;
+    let finishedStatusSnapshotPolls = 0;
+    let fastFinishedInstallProgressReported = false;
     let installEvidenceObserved = this.protocolV2InstallTerminalSuccessObserved;
     let currentInstallStatusObserved = false;
     const liveTargetIds = new Set<number>();
@@ -2463,6 +2546,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           deviceInfo = isBleInstallReconnect
             ? undefined
             : await this.verifyProtocolV2ReconnectIdentity();
+          if (installTransportReleaseObserved) {
+            installReconnectObserved = true;
+          }
           shouldReconnect = false;
         }
         let currentDeviceInfo = deviceInfo;
@@ -2473,6 +2559,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             {
               fields: {
                 status: true,
+                progress_percent: true,
+                phase_info: true,
                 payload_version: true,
                 path: true,
               },
@@ -2502,8 +2590,73 @@ 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) ||
+                target.path !== expectedPath ||
+                (expectedVersion !== undefined && payloadVersion !== expectedVersion)
+              ) {
+                return undefined;
+              }
+              matchingFinishedTargetIds.add(targetId);
+              return [targetId, target.path, payloadVersion ?? null] as const;
+            })
+            .filter((target): target is readonly [number, string, 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 coprocessor install may finish while BLE is disconnected, so the
+            // host never observes IN_PROGRESS. Enter the install UI while the matching
+            // FINISHED snapshot is stabilized; completion still requires all polls.
+            this.postProgressMessage(1, 'installingFirmware');
+            fastFinishedInstallProgressReported = true;
+          }
+          const finishedAfterReconnectObserved =
+            finishedStatusSnapshotPolls >= PROTOCOL_V2_INSTALL_FINISHED_AFTER_RECONNECT_POLLS;
           const hasCurrentInstallEvidence =
-            currentInstallStatusObserved || this.protocolV2InstallTerminalSuccessObserved;
+            currentInstallStatusObserved ||
+            this.protocolV2InstallTerminalSuccessObserved ||
+            finishedAfterReconnectObserved;
+          if (hasCurrentInstallEvidence) {
+            installEvidenceObserved = true;
+          }
           const shouldVerifyTargetCompletion =
             !requireCurrentInstallStatus || hasCurrentInstallEvidence;
           if (
@@ -2512,7 +2665,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               statusTargets,
               expectedTargetIds,
               expectedPaths,
-              requireCurrentInstallStatus && !this.protocolV2InstallTerminalSuccessObserved
+              requireCurrentInstallStatus &&
+                !this.protocolV2InstallTerminalSuccessObserved &&
+                !finishedAfterReconnectObserved
                 ? liveTargetIds
                 : undefined
             )
@@ -2628,6 +2783,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
               );
             }
           } else {
+            if (isProtocolV2DeviceDisconnectedError(error) || isProtocolV2ResponseTimeout(error)) {
+              installTransportReleaseObserved = true;
+              finishedStatusSnapshotKey = undefined;
+              finishedStatusSnapshotPolls = 0;
+            }
             shouldReconnect = true;
             deviceInfo = undefined;
             bleInstallLinkReady = false;
@@ -2683,6 +2843,9 @@ 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);
@@ -2774,7 +2937,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           'Protocol V2 device is still in bootloader mode'
         );
       } catch (error) {
-        if (this.isProtocolV2ReconnectIdentityError(error)) {
+        if (isBleStaleBondHardwareError(error) || this.isProtocolV2ReconnectIdentityError(error)) {
           throw error;
         }
         shouldReconnect = true;
@@ -3031,13 +3194,22 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   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,
-      });
+      const res = await typedCall(
+        'DeviceReboot',
+        'Success',
+        {
+          reboot_type: rebootType,
+        },
+        { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT }
+      );
       this.device.markProtocolV2Reboot(rebootType);
       return res.message;
     } catch (error) {
-      if (isProtocolV2DeviceDisconnectedError(error) || isProtocolV2ReconnectProbeError(error)) {
+      if (
+        isProtocolV2DeviceDisconnectedError(error) ||
+        isProtocolV2ReconnectProbeError(error) ||
+        isProtocolV2ResponseTimeout(error)
+      ) {
         this.device.markProtocolV2Reboot(rebootType);
         return { message: 'Device rebooted successfully' };
       }

package/src/api/OpenWalletSession.ts

@@ -29,6 +29,12 @@ const wasResumed = (session: unknown) =>
   'resumed' in session &&
   (session as { resumed?: unknown }).resumed === true;
 
+const wasWalletStatusRefreshed = (session: unknown) =>
+  !!session &&
+  typeof session === 'object' &&
+  'walletStatusRefreshed' in session &&
+  (session as { walletStatusRefreshed?: unknown }).walletStatusRefreshed === true;
+
 const requireHiddenWalletResponse = (session: { passphraseState?: string }) => {
   if (!session.passphraseState) {
     throw ERRORS.TypedError(
@@ -87,12 +93,20 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     this.unlockPolicy = 'unlock-before-run';
     this.skipForceUpdateCheck = true;
     this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
+    this.protocolV2PreUnlockPinType =
+      this.params.mode === OpenWalletSessionMode.SelectHidden
+        ? DeviceSessionPinType.Any
+        : DeviceSessionPinType.Main;
     this.payload.useEmptyPassphrase = this.params.mode === OpenWalletSessionMode.Standard;
   }
 
   async run(): Promise<OpenWalletSessionPayload> {
     const isProtocolV2 = this.device.isProtocolV2();
-    let state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    const reusePreflightStatus =
+      isProtocolV2 && this.protocolV2UnlockContext?.preflightStatusRefreshed === true;
+    let state = reusePreflightStatus
+      ? await this.device.getDeviceState()
+      : await this.device.getDeviceState({ refreshSections: ['status'] });
     let currentDeviceId = state.identity.deviceId;
     const hasAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) =>
       candidate.status.unlocked === true &&
@@ -115,14 +129,25 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       currentDeviceId = state.identity.deviceId;
       return state;
     };
+    const resolveProtocolV2DeviceStateAfterSession = async (session: unknown) => {
+      if (!wasWalletStatusRefreshed(session)) {
+        return refreshProtocolV2DeviceState();
+      }
+      state = await this.device.getDeviceState();
+      currentDeviceId = state.identity.deviceId;
+      return state;
+    };
     const ensureProtocolV2WalletStatus = async () => {
       if (isProtocolV2 && !hasAuthoritativeProtocolV2WalletStatus(state)) {
-        await this.device.unlockDevice(DeviceSessionPinType.Main, {
-          source: 'unlock-coordinator',
-          reason: 'device-locked',
-          deviceOnly: true,
-          method: 'openWalletSession',
-        });
+        await this.device.unlockDevice(
+          this.protocolV2PreUnlockPinType ?? DeviceSessionPinType.Main,
+          {
+            source: 'unlock-coordinator',
+            reason: 'device-locked',
+            deviceOnly: true,
+            method: 'openWalletSession',
+          }
+        );
         requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState());
       }
       return state;
@@ -139,13 +164,16 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
             selectMainWalletBeforeRestore:
               !hasAuthoritativeProtocolV2WalletStatus(state) ||
               state.status.unlockedAttachPin === true,
+            mainPinSelected: this.protocolV2UnlockContext?.preflightMainPinSelected,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             onlyMainPin: true,
             initSession: this.payload.initSession,
           });
       const refreshedState = isProtocolV2
-        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+        ? requireAuthoritativeProtocolV2WalletStatus(
+            await resolveProtocolV2DeviceStateAfterSession(session)
+          )
         : state;
       const deviceId = requireDeviceId();
       if (
@@ -233,7 +261,9 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
         })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
     const refreshedState = isProtocolV2
-      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+      ? requireAuthoritativeProtocolV2WalletStatus(
+          await resolveProtocolV2DeviceStateAfterSession(session)
+        )
       : state;
     const deviceId = requireDeviceId();
     if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -400,7 +400,8 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
               this.payload.passphraseState,
               useEmptyPassphrase,
               this.payload.skipPassphraseCheck,
-              deriveCardano
+              deriveCardano,
+              this.protocolV2UnlockContext?.preflightMainPinSelected
             );
             if (!passphraseStateSafety) {
               throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -41,9 +41,15 @@ const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
  */
 export const BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS = 5000;
 
-type FirmwareTransferMetrics = Pick<
+type FirmwareProgressMetadata = Pick<
   FirmwareProgress['payload'],
-  'transferredBytes' | 'totalBytes' | 'rateBytesPerSecond' | 'elapsedMs'
+  | 'transferredBytes'
+  | 'totalBytes'
+  | 'rateBytesPerSecond'
+  | 'elapsedMs'
+  | 'installTargetId'
+  | 'installPhase'
+  | 'installPhaseProgress'
 >;
 
 const isDeviceDisconnectedError = (error: unknown) => {
@@ -103,7 +109,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   postProgressMessage = (
     progress: number,
     progressType: IFirmwareUpdateProgressType,
-    metrics?: FirmwareTransferMetrics
+    metrics?: FirmwareProgressMetadata
   ) => {
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {

package/src/api/protocol-v2/DeviceGetFirmwareUpdateStatus.ts

@@ -4,7 +4,13 @@ import { invalidParameter } from '../helpers/filesystemValidation';
 import type { DeviceFirmwareUpdateStatusGetParams } from './helpers';
 import type { DeviceFirmwareUpdateRecordFields } from '@onekeyfe/hd-transport';
 
-const DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS = ['status', 'payload_version', 'path'] as const;
+const DEVICE_FIRMWARE_UPDATE_STATUS_FIELDS = [
+  'status',
+  'progress_percent',
+  'phase_info',
+  'payload_version',
+  'path',
+] as const;
 
 function normalizeStatusFields(
   fields: DeviceFirmwareUpdateStatusGetParams['fields']

package/src/core/index.ts

@@ -651,7 +651,8 @@ const onCallDevice = async (
                 method.payload?.passphraseState,
                 method.payload?.useEmptyPassphrase,
                 method.payload?.skipPassphraseCheck,
-                hasDeriveCardano(method)
+                hasDeriveCardano(method),
+                method.protocolV2UnlockContext?.preflightMainPinSelected
               );
 
               // Double check, handles the special case of Touch/Pro
@@ -957,6 +958,14 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
   );
 }
 
+export function isProtocolV2PeerRemovedPairingError(method: BaseMethod, error: unknown) {
+  return (
+    method.payload.connectProtocol === 'V2' &&
+    (error as { errorCode?: unknown })?.errorCode ===
+      HardwareErrorCode.BlePeerRemovedPairingInformation
+  );
+}
+
 /**
  * If the Bluetooth connection times out, retry up to 6 times
  * @param retryCount - Current retry count (default 0)
@@ -1258,7 +1267,8 @@ const ensureConnected = async (
             HardwareErrorCode.BridgeNeedsPermission,
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
-          ].includes(error.errorCode)
+          ].includes(error.errorCode) ||
+          isProtocolV2PeerRemovedPairingError(method, error)
         ) {
           reject(error);
           return;
@@ -1425,6 +1435,10 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
 const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
   if (!method.useDevicePassphraseState) return false;
 
+  if (device.isProtocolV2() && method.payload?.useEmptyPassphrase === true) {
+    return true;
+  }
+
   return device.hasUsePassphrase();
 };