@onekeyfe/hd-core 1.2.0-alpha.19 → 1.2.0-alpha.20

package/src/device/Device.ts

@@ -16,10 +16,11 @@ import {
   LoggerNames,
   getDeviceBLEFirmwareVersion,
   getDeviceBleName,
+  getDeviceBootloaderVersion,
   getDeviceFirmwareVersion,
   getDeviceLabel,
+  getDeviceSerialNo,
   getDeviceType,
-  getDeviceUUID,
   getFirmwareType,
   getLogger,
 } from '../utils';
@@ -42,6 +43,7 @@ import {
 } from './DeviceStateMapper';
 import { projectFeatures } from './DeviceStateProjector';
 import { DeviceStateStore, createPublicDeviceState } from './DeviceStateStore';
+import { cloneDeviceState } from './cloneDeviceState';
 import { deviceWalletSessionStore } from './DeviceWalletSessionStore';
 import {
   type DeviceFirmwareRange,
@@ -68,6 +70,8 @@ import {
   PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
+  type ProtocolV2RuntimeMode,
+  getProtocolV2RuntimeMode,
   requestProtocolV2DeviceInfo,
   requestProtocolV2DeviceStatus,
 } from '../protocols/protocol-v2/features';
@@ -97,7 +101,7 @@ export type InitOptions = {
   deriveCardano?: boolean;
   connectProtocol?: HardwareConnectProtocol;
   protocolV2DeviceInfoTimeoutMs?: number;
-  /** 设备发现内部使用：返回列表前刷新 Protocol V2 运行时状态。 */
+  /** Refresh Protocol V2 runtime state before returning discovery results. */
   refreshRuntimeState?: boolean;
 };
 
@@ -206,10 +210,10 @@ export class Device extends EventEmitter {
    */
   private deviceAcquired = false;
 
-  /** 唯一设备状态缓存。旧 Features 仅通过 getter/setter 做兼容投影。 */
+  /** Canonical device-state cache; legacy Features is a compatibility projection. */
   private stateStore = new DeviceStateStore();
 
-  /** 物理重连或重启后，下一次初始化必须重新读取 DeviceInfo。 */
+  /** Force the next initialization to reload DeviceInfo after reconnect or reboot. */
   private protocolV2StateNeedsReload = false;
 
   get state() {
@@ -217,13 +221,38 @@ export class Device extends EventEmitter {
   }
 
   get features(): Features | undefined {
-    return this.state ? projectFeatures(this.state) : undefined;
+    if (!this.state) return undefined;
+    const features = projectFeatures(this.state);
+    const sessionCacheDeviceKey =
+      this.state.identity.deviceId ||
+      (this.isProtocolV2()
+        ? this.originalDescriptor.path || this.originalDescriptor.id
+        : undefined);
+    const sessionId =
+      sessionCacheDeviceKey && this.passphraseState
+        ? deviceWalletSessionStore.get(sessionCacheDeviceKey, this.passphraseState)
+        : undefined;
+    return sessionId
+      ? {
+          ...features,
+          sessionId,
+          session_id: sessionId,
+          passphraseState: this.passphraseState,
+        }
+      : features;
   }
 
   set features(features: Features | undefined) {
     this.stateStore = new DeviceStateStore();
     if (features) {
       this.stateStore.update(mapFeaturesToState(features), 'compatibility');
+      const { passphraseState } = features;
+      const sessionId = features.sessionId ?? features.session_id;
+      const deviceKey = this.getSessionCacheDeviceKey(features.deviceId ?? undefined);
+      if (passphraseState && sessionId && deviceKey) {
+        this.passphraseState = passphraseState;
+        deviceWalletSessionStore.set(deviceKey, passphraseState, sessionId);
+      }
     }
   }
 
@@ -294,9 +323,11 @@ export class Device extends EventEmitter {
     const state = this.state ? createPublicDeviceState(this.state) : undefined;
 
     return {
-      /** Android uses Mac address, iOS uses uuid, USB uses uuid  */
+      /** Android uses a MAC address, while iOS and USB use transport-specific identifiers. */
       connectId: DataManager.isBleConnect(env) ? this.mainId || null : connectId,
-      /** Hardware ID, will not change at any time */
+      /** Stable physical-device identity. */
+      serialNo,
+      /** @deprecated Use serialNo instead. */
       uuid: serialNo,
       commType: this.originalDescriptor.commType,
       sdkInstanceId: this.sdkInstanceId,
@@ -308,12 +339,10 @@ export class Device extends EventEmitter {
       path: this.originalDescriptor?.path,
       bleName,
       name: bleName || label || `OneKey ${deviceType?.toUpperCase()}`,
-      displayName: label || bleName || `OneKey ${deviceType?.toUpperCase()}`,
       label: label || 'OneKey',
       mode: this.getMode(),
       features,
       state,
-      sessionId: this.features?.sessionId ?? null,
       firmwareVersion: this.getFirmwareVersion(),
       bleFirmwareVersion: this.getBLEFirmwareVersion(),
       unavailableCapabilities: this.unavailableCapabilities,
@@ -365,11 +394,10 @@ export class Device extends EventEmitter {
     try {
       let acquireResult: unknown;
       if (DataManager.isBleConnect(env)) {
-        // forceCleanRunPromise=true（自 e21b83c6 引入，修复 Pro2 BLE 重连）：
-        // acquire 意味着开启一个全新会话，transport 里残留的上一次 runPromise
-        // 必然属于已死亡的会话（如固件升级重启、探测中断），不清理会让新会话的
-        // 调用被旧 promise 卡死。无法在 Device 层面区分“重连恢复”与普通 acquire，
-        // 因此对 BLE acquire 恒清理是有意为之。
+        // acquire starts a new BLE session. Any previous runPromise belongs to a dead
+        // session, such as an interrupted probe or firmware-update reboot, and would
+        // otherwise block the new session. Device cannot distinguish recovery from a
+        // regular acquire, so BLE always clears it intentionally.
         acquireResult = await this.deviceConnector?.acquire(
           this.originalDescriptor.id,
           undefined,
@@ -510,12 +538,11 @@ export class Device extends EventEmitter {
   }
 
   /**
-   * 唯一协议判别器。
+   * Canonical protocol discriminator.
    *
-   * descriptor.protocolType 是协议探测后的结果；V2 features 由 DeviceInfoGet
-   * 映射产生。
-   * 全 SDK 的协议分支都必须走这里，不要直接读 originalDescriptor.protocolType
-   * 或从 features 反推。
+   * descriptor.protocolType is established by active probing; V2 features are mapped
+   * from DeviceInfoGet. All protocol branches must use this method instead of reading
+   * originalDescriptor.protocolType directly or inferring a protocol from features.
    */
   getProtocol(): 'V1' | 'V2' {
     return this.originalDescriptor.protocolType === 'V2' ? 'V2' : 'V1';
@@ -534,15 +561,15 @@ export class Device extends EventEmitter {
   }
 
   getCurrentSerialNo() {
-    return this.features ? getDeviceUUID(this.features) : '';
+    return getDeviceSerialNo(this.features);
   }
 
   getConnectId() {
     const serialNo = this.getCurrentSerialNo();
     if (serialNo) return serialNo;
 
-    // connectId 是 SDK 内部连接路由 key。这里兜底到 transport descriptor，
-    // 不改变 features.serialNo / deviceId 的业务语义。
+    // connectId is an internal routing key. Falling back to the transport descriptor
+    // does not change the business meaning of features.serialNo or deviceId.
     return this.originalDescriptor.path || this.originalDescriptor.id || '';
   }
 
@@ -571,6 +598,11 @@ export class Device extends EventEmitter {
     return getDeviceBLEFirmwareVersion(this.features).join('.');
   }
 
+  getCurrentBootloaderVersionString() {
+    if (!this.features) return undefined;
+    return getDeviceBootloaderVersion(this.features).join('.');
+  }
+
   getCurrentSafetyChecks() {
     return this.features?.safetyChecks;
   }
@@ -636,9 +668,8 @@ export class Device extends EventEmitter {
   }
 
   supportModifyHomescreen(): SupportFeatureType {
-    // Pro2 走独立 1.x 版本线，不能套用 Touch/Pro 的 3.4.0 门槛（恒 false 且未来会误判）。
-    // 依据：firmware-pro2 协议 schema（messages-protocol-v2.json）的 ApplySettings
-    // 包含 homescreen 字段，V2 固件从首个版本即支持修改主屏。
+    // Pro2 has an independent 1.x version line and must not use the Touch/Pro 3.4.0
+    // threshold. ApplySettings includes homescreen from the first V2 firmware version.
     if (this.isProtocolV2()) {
       return { support: true };
     }
@@ -665,12 +696,22 @@ export class Device extends EventEmitter {
     return undefined;
   }
 
+  private reconcileSessionCacheDeviceIdentity(previousDeviceId?: string) {
+    deviceWalletSessionStore.reconcileDeviceIdentity({
+      temporaryKey: this.isProtocolV2()
+        ? this.originalDescriptor.path || this.originalDescriptor.id
+        : undefined,
+      previousDeviceId,
+      nextDeviceId: this.getCurrentDeviceId(),
+    });
+  }
+
   getInternalState(_deviceId?: string) {
     Log.debug(
       'getInternalState session param: ',
       `device_id: ${_deviceId}`,
       `features.deviceId: ${this.features?.deviceId}`,
-      `passphraseState: ${this.passphraseState}`
+      `hasPassphraseState: ${Boolean(this.passphraseState)}`
     );
 
     const deviceId = this.getSessionCacheDeviceKey(_deviceId);
@@ -698,7 +739,7 @@ export class Device extends EventEmitter {
       'updateInternalState session param: ',
       `device_id: ${deviceId}`,
       `enablePassphrase: ${enablePassphrase}`,
-      `passphraseState: ${passphraseState}`,
+      `hasPassphraseState: ${Boolean(passphraseState)}`,
       `hasSessionId: ${Boolean(sessionId)}`,
       `hasFeaturesSessionId: ${Boolean(featuresSessionId)}`
     );
@@ -721,7 +762,7 @@ export class Device extends EventEmitter {
       `hasState: ${Boolean(state)}`,
       `initSession: ${initSession}`,
       `deviceId: ${this.features?.deviceId}`,
-      `passphraseState: ${this.passphraseState}`
+      `hasPassphraseState: ${Boolean(this.passphraseState)}`
     );
 
     if (!this.passphraseState && !initSession) return;
@@ -749,15 +790,15 @@ export class Device extends EventEmitter {
   }
 
   async initialize(options?: InitOptions) {
-    // Protocol V2 不支持传统 Initialize，直接使用协议专用初始化流程。
+    // Protocol V2 does not support legacy Initialize; use its dedicated flow.
     if (this.isProtocolV2()) {
       this.passphraseState = options?.passphraseState;
       if (this.state && !options?.initSession && !this.protocolV2StateNeedsReload) {
         if (this.features?.bootloaderMode) {
           return;
         }
-        // 普通业务调用复用缓存。动态状态由显式 getDeviceState refresh、
-        // 解锁流程和设备事件刷新，避免每个 SDK 方法都额外轮询 DeviceStatus。
+        // Normal calls reuse the cache. Explicit getDeviceState refreshes, unlock flow,
+        // and device events update dynamic state without polling on every SDK call.
         return;
       }
       await this._initializeProtocolV2(options);
@@ -811,23 +852,25 @@ export class Device extends EventEmitter {
   /**
    * Device initialization over Protocol V2.
    *
-   * Protocol V2 不走传统 Initialize/GetFeatures；直接用 DeviceInfoGet
-   * 生成唯一的 features 状态。
+   * Protocol V2 bypasses legacy Initialize/GetFeatures and builds its canonical
+   * features state directly from DeviceInfoGet.
    */
   private async _initializeProtocolV2(options?: InitOptions) {
     Log.debug('Initialize device via Protocol V2 features adapter');
 
     try {
-      // 超时由 requestProtocolV2DeviceInfo 内部的 typedCall timeoutMs（默认 10s）负责，
-      // 不再额外包一层 Promise.race：外层 race 的 timer 不会清理，
-      // 且 reject 后底层调用仍会残留。
+      // typedCall applies the request timeout. An outer Promise.race would leak its
+      // timer and leave the underlying call active after rejection.
       const deviceInfo = await requestProtocolV2DeviceInfo({
         commands: this.commands,
         timeoutMs: options?.protocolV2DeviceInfoTimeoutMs,
       });
-      // 默认请求不含 SE/hash 数据，scope 如实标注为 basic；
-      // 完整版本与校验数据由公共 getDeviceState({ scope: 'firmware' }) 显式获取。
-      const features = this.updateProtocolV2Features(deviceInfo, null);
+      // The default request excludes SE/hash data and therefore uses basic scope.
+      // Full version and verification data require getDeviceState({ scope: 'firmware' }).
+      const features = await this.probeProtocolV2RuntimeState(
+        deviceInfo,
+        options?.protocolV2DeviceInfoTimeoutMs
+      );
       Log.debug('Protocol V2 features:', features);
     } catch (error) {
       Log.error('Protocol V2 initialization failed:', error);
@@ -840,7 +883,7 @@ export class Device extends EventEmitter {
       const deviceInfo = await requestProtocolV2DeviceInfo({
         commands: this.commands,
       });
-      return this.updateProtocolV2Features(deviceInfo, null);
+      return this.probeProtocolV2RuntimeState(deviceInfo);
     }
 
     const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
@@ -856,6 +899,7 @@ export class Device extends EventEmitter {
       return PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST;
     };
     let initializedWithDeviceInfo = false;
+    let refreshedDeviceInfo: ProtocolV2DeviceInfo | undefined;
 
     if (!this.state) {
       if (this.isProtocolV2()) {
@@ -863,7 +907,8 @@ export class Device extends EventEmitter {
           commands: this.commands,
           request: getProtocolV2DeviceInfoRequest(),
         });
-        this.updateState(mapProtocolV2DeviceInfoToState(deviceInfo), 'device-info');
+        await this.probeProtocolV2RuntimeState(deviceInfo);
+        refreshedDeviceInfo = deviceInfo;
         initializedWithDeviceInfo = true;
       } else {
         await this.getFeatures();
@@ -885,15 +930,23 @@ export class Device extends EventEmitter {
           commands: this.commands,
           request: getProtocolV2DeviceInfoRequest(),
         });
-        this.updateState(
-          mapProtocolV2DeviceInfoToState(deviceInfo, this.state?.status.mode),
-          'device-info'
-        );
+        refreshedDeviceInfo = deviceInfo;
+        if (!refresh.has('status')) {
+          this.updateState(
+            mapProtocolV2DeviceInfoToState(deviceInfo, this.state?.status.mode),
+            'device-info'
+          );
+        }
       }
 
-      if (refresh.has('status') && this.state?.status.mode === 'normal') {
-        const status = await requestProtocolV2DeviceStatus({ commands: this.commands });
-        this.updateState(mapProtocolV2DeviceStatusToState(status), 'device-status');
+      if (refresh.has('status') && !initializedWithDeviceInfo) {
+        const deviceInfo =
+          refreshedDeviceInfo ??
+          (await requestProtocolV2DeviceInfo({
+            commands: this.commands,
+            request: getProtocolV2DeviceInfoRequest(),
+          }));
+        await this.probeProtocolV2RuntimeState(deviceInfo);
       }
 
       if (refresh.has('settings') && this.state?.status.mode === 'normal') {
@@ -909,11 +962,11 @@ export class Device extends EventEmitter {
     if (!this.state) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
     }
-    return params.includeRaw ? structuredClone(this.state) : createPublicDeviceState(this.state);
+    return params.includeRaw ? cloneDeviceState(this.state) : createPublicDeviceState(this.state);
   }
 
   _updateFeatures(protoFeatures: PROTO.Features | Features, initSession?: boolean) {
-    const previousCacheDeviceKey = this.getSessionCacheDeviceKey();
+    const previousDeviceId = this.getCurrentDeviceId();
     let feat =
       'protocol' in protoFeatures
         ? protoFeatures
@@ -928,10 +981,7 @@ export class Device extends EventEmitter {
     feat = fixFeaturesFirmwareVersion(feat);
 
     this.updateState(mapFeaturesToState(feat), 'initialize');
-    const nextCacheDeviceKey = this.getSessionCacheDeviceKey();
-    if (previousCacheDeviceKey && nextCacheDeviceKey) {
-      deviceWalletSessionStore.migrateDeviceKey(previousCacheDeviceKey, nextCacheDeviceKey);
-    }
+    this.reconcileSessionCacheDeviceIdentity(previousDeviceId);
     if (feat.deviceId && feat.sessionId) {
       this.setInternalState(feat.sessionId, initSession);
     }
@@ -959,14 +1009,6 @@ export class Device extends EventEmitter {
     return result.state;
   }
 
-  clearCachedSession(deviceId?: string, passphraseState?: string) {
-    const current = this.state;
-    if (!current?.session) return false;
-    if (deviceId && current.identity.deviceId !== deviceId) return false;
-    if (passphraseState && current.session.passphraseState !== passphraseState) return false;
-    return this.stateStore.clearSession('session-clear') !== undefined;
-  }
-
   updateFeaturesPatch(patch: Partial<Features>, source: DeviceStateUpdateSource) {
     const currentFeatures = this.features;
     if (!currentFeatures) return undefined;
@@ -979,21 +1021,45 @@ export class Device extends EventEmitter {
     return this.features;
   }
 
-  updateProtocolV2Features(deviceInfo?: ProtocolV2DeviceInfo, deviceStatus?: DeviceStatus | null) {
-    const previousCacheDeviceKey = this.getSessionCacheDeviceKey();
-    if (deviceStatus) {
-      this.updateState(mapProtocolV2DeviceStatusToState(deviceStatus), 'device-status');
+  async probeProtocolV2RuntimeState(deviceInfo: ProtocolV2DeviceInfo, timeoutMs?: number) {
+    let deviceStatus: DeviceStatus;
+    try {
+      deviceStatus = await requestProtocolV2DeviceStatus({
+        commands: this.commands,
+        timeoutMs,
+      });
+    } catch (error) {
+      const runtimeMode = getProtocolV2RuntimeMode({
+        deviceInfo,
+        deviceStatusAvailable: false,
+      });
+      Log.debug('Protocol V2 DeviceStatusGet unavailable; use temporary loader fallback', {
+        runtimeMode,
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return this.updateProtocolV2Features(deviceInfo, null, runtimeMode);
     }
+    return this.updateProtocolV2Features(deviceInfo, deviceStatus, 'normal');
+  }
+
+  updateProtocolV2Features(
+    deviceInfo?: ProtocolV2DeviceInfo,
+    deviceStatus?: DeviceStatus | null,
+    runtimeMode?: ProtocolV2RuntimeMode
+  ) {
+    const previousDeviceId = this.getCurrentDeviceId();
+    const resolvedMode =
+      runtimeMode ??
+      (deviceStatus
+        ? getProtocolV2RuntimeMode({ deviceInfo, deviceStatusAvailable: true })
+        : this.state?.status.mode);
     if (deviceInfo) {
-      this.updateState(
-        mapProtocolV2DeviceInfoToState(deviceInfo, this.state?.status.mode),
-        'device-info'
-      );
+      this.updateState(mapProtocolV2DeviceInfoToState(deviceInfo, resolvedMode), 'device-info');
     }
-    const nextCacheDeviceKey = this.getSessionCacheDeviceKey();
-    if (previousCacheDeviceKey && nextCacheDeviceKey) {
-      deviceWalletSessionStore.migrateDeviceKey(previousCacheDeviceKey, nextCacheDeviceKey);
+    if (deviceStatus) {
+      this.updateState(mapProtocolV2DeviceStatusToState(deviceStatus), 'device-status');
     }
+    this.reconcileSessionCacheDeviceIdentity(previousDeviceId);
     return this.features as Features;
   }
 
@@ -1010,7 +1076,6 @@ export class Device extends EventEmitter {
     if (!this.isProtocolV2()) return;
     this.protocolV2StateNeedsReload = true;
     this.clearPreInitialized();
-    this.clearCachedSession();
   }
 
   markProtocolV2Reboot(rebootType: DeviceRebootType) {
@@ -1042,7 +1107,6 @@ export class Device extends EventEmitter {
             attachToPinEnabled: null,
             unlockedAttachPin: null,
           },
-          session: null,
           raw: { protocolV2DeviceStatus: null },
         },
         'transport-reconnect'
@@ -1053,7 +1117,6 @@ export class Device extends EventEmitter {
     this.updateState(
       {
         status: { mode: 'normal', unlocked: null },
-        session: null,
         raw: { protocolV2DeviceStatus: null },
       },
       'transport-reconnect'
@@ -1078,8 +1141,7 @@ export class Device extends EventEmitter {
     }
 
     if (forceUpdate) {
-      // 枚举得到的 descriptor 可能不带 protocolType（如 WebUSB enumerate），
-      // 不能让覆盖丢掉已探测的协议结果。
+      // Enumerated descriptors may omit protocolType, so preserve an actively probed value.
       this.originalDescriptor = {
         ...descriptor,
         protocolType: descriptor.protocolType ?? this.originalDescriptor.protocolType,
@@ -1104,19 +1166,37 @@ export class Device extends EventEmitter {
 
     options = parseRunOptions(options);
 
-    this.runPromise = createDeferred(this._runInner.bind(this, fn, options));
-    return this.runPromise.promise;
+    const runPromise = createDeferred<void>();
+    this.runPromise = runPromise;
+    this._runInner(fn, options, runPromise).catch(error => {
+      if (this.runPromise === runPromise) {
+        this.runPromise = null;
+      }
+      runPromise.reject(error);
+    });
+    return runPromise.promise;
   }
 
-  async _runInner<T>(fn: (() => Promise<T>) | undefined, options: RunOptions) {
+  async _runInner<T>(
+    fn: (() => Promise<T>) | undefined,
+    options: RunOptions,
+    runPromise: Deferred<void>
+  ) {
+    const clearRunPromise = () => {
+      if (this.runPromise === runPromise) {
+        this.runPromise = null;
+      }
+    };
+
     if (!this.isUsedHere() || this.commands.disposed) {
       const env = DataManager.getSettings('env');
       if (env !== 'react-native') {
         try {
           await this.acquire(options.connectProtocol);
         } catch (error) {
-          this.runPromise = null;
-          return Promise.reject(error);
+          clearRunPromise();
+          runPromise.reject(error);
+          return;
         }
 
         try {
@@ -1127,16 +1207,18 @@ export class Device extends EventEmitter {
           }
         } catch (error) {
           await this.release();
-          this.runPromise = null;
+          clearRunPromise();
           if (error instanceof HardwareError) {
-            return Promise.reject(error);
+            runPromise.reject(error);
+            return;
           }
-          return Promise.reject(
+          runPromise.reject(
             ERRORS.TypedError(
               HardwareErrorCode.DeviceInitializeFailed,
               `Initialize failed: ${error.message as string}, code: ${error.code as string}`
             )
           );
+          return;
         }
       } else if (env === 'react-native') {
         // TODO: implement react-native acquire
@@ -1155,9 +1237,7 @@ export class Device extends EventEmitter {
       try {
         await fn();
       } catch (e) {
-        if (this.runPromise) {
-          this.runPromise.reject(e);
-        }
+        runPromise.reject(e);
 
         if (
           e instanceof HardwareError &&
@@ -1170,7 +1250,7 @@ export class Device extends EventEmitter {
           Log.debug(`error code ${e.errorCode} release device, mainId: ${this.mainId}`);
         }
 
-        this.runPromise = null;
+        clearRunPromise();
         return;
       }
     }
@@ -1184,11 +1264,8 @@ export class Device extends EventEmitter {
       Log.debug('release device, mainId: ', this.mainId);
     }
 
-    if (this.runPromise) {
-      this.runPromise.resolve();
-    }
-
-    this.runPromise = null;
+    runPromise.resolve();
+    clearRunPromise();
   }
 
   async interruptionFromOutside() {
@@ -1343,7 +1420,7 @@ export class Device extends EventEmitter {
   }
 
   supportUnlockVersionRange(): DeviceFirmwareRange {
-    // 仅适用于 Protocol V1 的 Pro 系列；Pro2 走独立的 Protocol V2 解锁流程。
+    // This range applies to Protocol V1 Pro devices; Pro2 has a dedicated unlock flow.
     return {
       pro: {
         min: '4.15.0',
@@ -1368,7 +1445,8 @@ export class Device extends EventEmitter {
         throw error;
       }
 
-      return this.updateFeaturesPatch({ unlocked: true }, 'unlock');
+      const status = await requestProtocolV2DeviceStatus({ commands: this.commands });
+      return this.updateProtocolV2Status(status);
     }
 
     const firmwareVersion = this.getCurrentFirmwareVersionString() ?? '0.0.0';
@@ -1433,21 +1511,27 @@ export class Device extends EventEmitter {
   ) {
     if (this.isUnacquired()) return false;
 
+    const expectedPassphraseState = useEmptyPassphrase ? undefined : passphraseState;
     const { passphraseState: newPassphraseState, unlockedAttachPin } =
       await getPassphraseStateWithRefreshDeviceInfo(this, {
-        expectPassphraseState: passphraseState,
+        expectPassphraseState: expectedPassphraseState,
         onlyMainPin: useEmptyPassphrase,
       });
 
     // Main wallet and unlock Attach Pin, throw safe error
     const mainWalletUseAttachPin = unlockedAttachPin && useEmptyPassphrase;
     const useErrorAttachPin =
-      unlockedAttachPin && passphraseState && passphraseState !== newPassphraseState;
-    const passphraseStateMismatch = !!passphraseState && passphraseState !== newPassphraseState;
+      unlockedAttachPin &&
+      expectedPassphraseState &&
+      expectedPassphraseState !== newPassphraseState;
+    const passphraseStateMismatch =
+      !!expectedPassphraseState && expectedPassphraseState !== newPassphraseState;
 
     Log.debug('Check passphrase state safety: ', {
-      passphraseState,
-      newPassphraseState,
+      hasExpectedPassphraseState: Boolean(expectedPassphraseState),
+      hasNewPassphraseState: Boolean(newPassphraseState),
+      passphraseStateMatches:
+        Boolean(expectedPassphraseState) && expectedPassphraseState === newPassphraseState,
       unlockedAttachPin,
       useEmptyPassphrase,
     });