@onekeyfe/hd-core 1.2.0-alpha.34 → 1.2.0-alpha.35

package/src/device/Device.ts

@@ -55,6 +55,7 @@ import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
 import { toHardened } from '../api/helpers/pathUtils';
 import {
+  PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE,
   PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
@@ -62,8 +63,11 @@ import {
   getProtocolV2RuntimeMode,
   requestProtocolV2DeviceInfo,
   requestProtocolV2DeviceStatus,
+  requestProtocolV2ProtocolInfo,
+  supportsProtocolV2Message,
 } from '../protocols/protocol-v2/features';
 import { buildProtocolV1FeaturesPayload } from '../deviceProfile';
+import { resolveProtocolV2DeviceIdentity } from '../deviceProfile/protocolV2DeviceIdentity';
 
 import type { PROTO } from '../constants';
 import type { DeviceStateReadOptions } from '../types/api/getDeviceState';
@@ -77,6 +81,7 @@ import type { Deferred, HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 import type {
   OneKeyDeviceInfo as DeviceDescriptor,
   DeviceStatus,
+  ProtocolInfo,
   ProtocolV2DeviceInfo,
   Success,
 } from '@onekeyfe/hd-transport';
@@ -835,8 +840,8 @@ export class Device extends EventEmitter {
 
       const expectedDeviceId = options?.deviceId;
       if (expectedDeviceId) {
-        // Verify the physical device with a read-only Features request. An
-        // empty-context Initialize would invalidate a cached V1 hidden-wallet session.
+        // 先只读校验物理设备身份；钱包上下文仍由下方携带完整参数的
+        // Initialize 选择，避免标准钱包请求复用此前的隐藏钱包上下文。
         this.passphraseState = undefined;
         const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
         this._updateFeatures(message);
@@ -864,15 +869,7 @@ export class Device extends EventEmitter {
         payload.derive_cardano = true;
       }
 
-      const requiresWalletInitialize =
-        !expectedDeviceId ||
-        Boolean(internalState) ||
-        Boolean(options?.passphraseState) ||
-        options?.deriveCardano === true ||
-        options?.initSession === true;
-      if (requiresWalletInitialize) {
-        await callInitialize(payload, options?.initSession);
-      }
+      await callInitialize(payload, options?.initSession);
     } catch (error) {
       Log.error('Initialization failed:', error);
       throw error;
@@ -1048,40 +1045,60 @@ export class Device extends EventEmitter {
   }
 
   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);
+    const protocolInfo = await requestProtocolV2ProtocolInfo({
+      commands: this.commands,
+      timeoutMs,
+    });
+    const runtimeMode = getProtocolV2RuntimeMode(protocolInfo);
+    const protocolV2DeviceType = resolveProtocolV2DeviceIdentity(
+      deviceInfo.hw?.Device_type
+    ).deviceType;
+    if (runtimeMode === 'romloader' && protocolV2DeviceType !== EDeviceType.Pro2) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceInitializeFailed,
+        'Protocol V2 romloader mode is only supported for Pro2.'
+      );
+    }
+    const deviceStatusSupported = supportsProtocolV2Message(
+      protocolInfo,
+      PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE
+    );
+
+    if (runtimeMode === 'bootloader' || runtimeMode === 'romloader') {
+      return this.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
+    }
+
+    if (!deviceStatusSupported) {
+      if (runtimeMode === 'normal') {
+        return this.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
+      }
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceInitializeFailed,
+        `Unknown Protocol V2 build fingerprint without DeviceStatusGet capability: ${protocolInfo.build_fingerprint}`
+      );
     }
-    return this.updateProtocolV2Features(deviceInfo, deviceStatus, 'normal');
+
+    const deviceStatus = await requestProtocolV2DeviceStatus({
+      commands: this.commands,
+      timeoutMs,
+    });
+    return this.updateProtocolV2Features(deviceInfo, deviceStatus, 'normal', protocolInfo);
   }
 
   updateProtocolV2Features(
     deviceInfo?: ProtocolV2DeviceInfo,
     deviceStatus?: DeviceStatus | null,
-    runtimeMode?: ProtocolV2RuntimeMode
+    runtimeMode?: ProtocolV2RuntimeMode,
+    protocolInfo?: ProtocolInfo
   ) {
     const previousDeviceId = this.getCurrentDeviceId();
-    const resolvedMode =
-      runtimeMode ??
-      (deviceStatus
-        ? getProtocolV2RuntimeMode({ deviceInfo, deviceStatusAvailable: true })
-        : this.state?.status.mode);
+    const resolvedMode = runtimeMode ?? (deviceStatus ? 'normal' : this.state?.status.mode);
     if (deviceInfo) {
       this.updateState(mapProtocolV2DeviceInfoToState(deviceInfo, resolvedMode), 'device-info');
     }
+    if (protocolInfo) {
+      this.updateState({ raw: { protocolV2ProtocolInfo: protocolInfo } }, 'device-info');
+    }
     if (deviceStatus) {
       this.updateState(mapProtocolV2DeviceStatusToState(deviceStatus), 'device-status');
     }
@@ -1150,7 +1167,7 @@ export class Device extends EventEmitter {
             attachToPinEnabled: null,
             unlockedAttachPin: null,
           },
-          raw: { protocolV2DeviceStatus: null },
+          raw: { protocolV2ProtocolInfo: null, protocolV2DeviceStatus: null },
         },
         'transport-reconnect'
       );
@@ -1160,7 +1177,7 @@ export class Device extends EventEmitter {
     this.updateState(
       {
         status: { mode: 'normal', unlocked: null },
-        raw: { protocolV2DeviceStatus: null },
+        raw: { protocolV2ProtocolInfo: null, protocolV2DeviceStatus: null },
       },
       'transport-reconnect'
     );
@@ -1406,7 +1423,16 @@ export class Device extends EventEmitter {
 
   isBootloader() {
     if (!this.state) return undefined;
-    return this.state.status.mode === 'bootloader' || this.state.status.mode === 'romloader';
+    return this.state.status.mode === 'bootloader';
+  }
+
+  isRomloader() {
+    if (!this.state) return undefined;
+    return (
+      this.isProtocolV2() &&
+      this.getCurrentDeviceType() === EDeviceType.Pro2 &&
+      this.state.status.mode === 'romloader'
+    );
   }
 
   isInitialized() {

package/src/device/DeviceCommands.ts

@@ -6,6 +6,7 @@ import {
   type Messages,
   type Transport,
   type TransportCallOptions,
+  getSafeTransportLogPayload,
 } from '@onekeyfe/hd-transport';
 
 import TransportManager from '../data-manager/TransportManager';
@@ -282,7 +283,11 @@ export class DeviceCommands {
   ): Promise<DefaultMessageResponse> {
     const shouldReduceDebug = shouldReduceDebugForCall(type);
     if (!shouldReduceDebug) {
-      Log.debug('[DeviceCommands] [call] Sending', type);
+      Log.debug(
+        '[DeviceCommands] [call] Sending',
+        type,
+        getSafeTransportLogPayload(msg ?? {}, type)
+      );
     }
 
     try {
@@ -290,13 +295,18 @@ export class DeviceCommands {
       this.callPromise = promise;
       const res = await promise;
       if (!shouldReduceDebug) {
-        LogCore.debug('[DeviceCommands] [call] Received', res.type);
+        LogCore.debug(
+          '[DeviceCommands] [call] Received',
+          res.type,
+          getSafeTransportLogPayload(res.message, res.type)
+        );
       }
       return res;
     } catch (error) {
       LogCore.debug('[DeviceCommands] [call] Received error', {
         request: type,
         errorCode: error?.errorCode,
+        response: getSafeTransportLogPayload(error?.response?.data, type),
       });
       if (error.errorCode === HardwareErrorCode.BleDeviceBondError) {
         return {

package/src/device/DeviceWalletSessionStore.ts

@@ -1,6 +1,4 @@
 export class DeviceWalletSessionStore {
-  private static readonly MAX_SESSIONS_PER_DEVICE = 3;
-
   private readonly walletSessions = new Map<string, Map<string, string>>();
 
   private readonly standardWalletSessions = new Map<
@@ -22,18 +20,6 @@ export class DeviceWalletSessionStore {
       deviceSessions = new Map<string, string>();
       this.walletSessions.set(deviceKey, deviceSessions);
     }
-    if (
-      !deviceSessions.has(passphraseState) &&
-      deviceSessions.size >= DeviceWalletSessionStore.MAX_SESSIONS_PER_DEVICE
-    ) {
-      const oldestPassphraseState = deviceSessions.keys().next().value as string | undefined;
-      if (oldestPassphraseState) {
-        deviceSessions.delete(oldestPassphraseState);
-        if (this.standardWalletSessions.get(deviceKey)?.passphraseState === oldestPassphraseState) {
-          this.standardWalletSessions.delete(deviceKey);
-        }
-      }
-    }
     deviceSessions.set(passphraseState, sessionId);
   }
 

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -260,7 +260,7 @@ export const buildProtocolV2FeaturesPayload = ({
   const attachToPinEnabled = status?.attach_to_pin_enabled ?? cached?.attachToPinEnabled ?? null;
   const unlockedAttachPin =
     status?.unlocked_by_attach_to_pin ?? cached?.unlockedAttachPin ?? undefined;
-  const bootloaderMode = runtimeMode === 'bootloader';
+  const bootloaderMode = runtimeMode === 'bootloader' || runtimeMode === 'romloader';
   let mode: DeviceFeaturesMode = 'unknown';
   if (runtimeMode) {
     mode = runtimeMode;

package/src/protocols/protocol-v2/features.ts

@@ -4,6 +4,7 @@ import type {
   DeviceInfoGet,
   DeviceSEInfo,
   DeviceStatus,
+  ProtocolInfo,
   ProtocolV2DeviceInfo,
 } from '@onekeyfe/hd-transport';
 import type { DeviceCommands } from '../../device/DeviceCommands';
@@ -53,27 +54,54 @@ export const getProtocolV2SeState = (se?: DeviceSEInfo): ProtocolV2SeStateLabel
 export const getProtocolV2SeType = (se?: DeviceSEInfo): string | null =>
   normalizeEnumValue(DeviceSeType, se?.type);
 
-export type ProtocolV2RuntimeMode = 'normal' | 'bootloader';
+export type ProtocolV2RuntimeMode = 'normal' | 'bootloader' | 'romloader';
 
 /**
- * TODO: Once firmware-pro2 exposes ProtocolInfo.build_fingerprint, parse the running
- * binary name and remove the temporary DeviceStatusGet-failure heuristic. romloader
- * is a separate recovery flow and is excluded until its contract is defined.
- *
- * The temporary contract has two states: DeviceStatusGet success means normal and
- * failure means bootloader. Do not infer mode from application/SE/romloader fields.
+ * Protocol V2 fingerprints use:
+ * <binary>__<version>__<commit>__<PROD|DEV>__<DEBUG|RELEASE>
  */
-export const getProtocolV2RuntimeMode = ({
-  deviceInfo: _deviceInfo,
-  deviceStatusAvailable,
-}: {
-  deviceInfo?: ProtocolV2DeviceInfo | null;
-  deviceStatusAvailable: boolean;
-}): ProtocolV2RuntimeMode => {
-  if (deviceStatusAvailable) return 'normal';
-  return 'bootloader';
+export type ProtocolV2BuildFingerprint = {
+  binary: 'application' | 'bootloader' | 'romloader';
+  version: string;
+  commit: string;
+  environment: 'PROD' | 'DEV';
+  buildType: 'DEBUG' | 'RELEASE';
 };
 
+export const parseProtocolV2BuildFingerprint = (
+  buildFingerprint: string | null | undefined
+): ProtocolV2BuildFingerprint | null => {
+  if (!buildFingerprint) return null;
+  const [binary, version, commit, environment, buildType, ...extra] = buildFingerprint.split('__');
+  if (
+    extra.length > 0 ||
+    (binary !== 'application' && binary !== 'bootloader' && binary !== 'romloader') ||
+    !version ||
+    !commit ||
+    (environment !== 'PROD' && environment !== 'DEV') ||
+    (buildType !== 'DEBUG' && buildType !== 'RELEASE')
+  ) {
+    return null;
+  }
+  return { binary, version, commit, environment, buildType };
+};
+
+export const getProtocolV2RuntimeMode = (
+  protocolInfo: ProtocolInfo
+): ProtocolV2RuntimeMode | undefined => {
+  const binary = parseProtocolV2BuildFingerprint(protocolInfo.build_fingerprint)?.binary;
+  if (binary === 'application') return 'normal';
+  return binary;
+};
+
+// MessageType_DeviceStatusGet in the Protocol V2 protobuf registry.
+export const PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE = 60602;
+
+export const supportsProtocolV2Message = (
+  protocolInfo: ProtocolInfo,
+  messageType: number
+): boolean => protocolInfo.supported_messages.includes(messageType);
+
 export const PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST = {
   targets: {
     hw: true,
@@ -131,6 +159,20 @@ export const PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST = {
 export const PROTOCOL_V2_DEVICE_INFO_REQUEST = PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST;
 export const PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS = 10 * 1000;
 
+export async function requestProtocolV2ProtocolInfo({
+  commands,
+  timeoutMs,
+}: {
+  commands: DeviceCommands;
+  timeoutMs?: number;
+}): Promise<ProtocolInfo> {
+  const response =
+    timeoutMs === undefined
+      ? await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {})
+      : await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {}, { timeoutMs });
+  return response.message;
+}
+
 export async function requestProtocolV2DeviceInfo({
   commands,
   timeoutMs = PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,

package/src/protocols/protocol-v2/index.ts

@@ -1,13 +1,18 @@
 export {
   PROTOCOL_V2_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
+  PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE,
   PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
   getProtocolV2RuntimeMode,
   getProtocolV2SeState,
   getProtocolV2SeType,
+  parseProtocolV2BuildFingerprint,
+  requestProtocolV2ProtocolInfo,
+  supportsProtocolV2Message,
 } from './features';
 export type {
+  ProtocolV2BuildFingerprint,
   ProtocolV2DeviceInfo,
   ProtocolV2FirmwareImageInfo,
   ProtocolV2SEInfo,

package/src/protocols/protocol-v2/settingsUnlockPolicy.ts

@@ -2,14 +2,19 @@ import type { DeviceSettings, DeviceSettingsPage } from '@onekeyfe/hd-transport'
 import type { UnlockPolicy } from '../../api/BaseMethod';
 import type { ProtocolV2InteractionDescriptor } from './uiInteraction';
 
-const LOCK_FREE_DEVICE_SETTINGS = new Set<keyof DeviceSettings>([
+export const PROTOCOL_V2_LOCK_FREE_DEVICE_SETTINGS = [
   'language',
   'brightness',
+  'animation_enable',
+  'tap_to_wake',
   'haptic_feedback',
-]);
+  'device_name_display_enabled',
+] as const satisfies readonly (keyof DeviceSettings)[];
+
+const lockFreeDeviceSettings = new Set<keyof DeviceSettings>(PROTOCOL_V2_LOCK_FREE_DEVICE_SETTINGS);
 
 export const getProtocolV2SettingsUnlockPolicy = (settings: DeviceSettings): UnlockPolicy =>
-  Object.keys(settings).every(key => LOCK_FREE_DEVICE_SETTINGS.has(key as keyof DeviceSettings))
+  Object.keys(settings).every(key => lockFreeDeviceSettings.has(key as keyof DeviceSettings))
     ? 'none'
     : 'unlock-before-run';
 

package/src/protocols/protocol-v2/unlockRetry.ts

@@ -1,7 +1,7 @@
 import { LoggerNames, getLogger } from '../../utils';
 import { isDeviceLockedError } from './lockedError';
 import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
-import { restoreProtocolV2WalletSession } from './walletSession';
+import { refreshProtocolV2DeviceStatus, restoreProtocolV2WalletSession } from './walletSession';
 
 import type { BaseMethod } from '../../api/BaseMethod';
 import type { Device } from '../../device/Device';
@@ -46,8 +46,23 @@ export async function runMethodWithUnlockRetry(
   uiCoordinator?: UiInteractionCoordinator
 ) {
   const shouldEmitUi = isProtocolV2UiEnabled(method);
+  const isProtocolV2 = device.isProtocolV2();
+  const requiresFreshStatus =
+    isProtocolV2 &&
+    method.unlockPolicy === 'unlock-before-run' &&
+    !device.isBootloader?.() &&
+    !device.isRomloader?.();
+
+  if (requiresFreshStatus) {
+    await refreshProtocolV2DeviceStatus(device);
+  }
+
   const shouldUnlockBeforeRun =
-    device.isProtocolV2() && method.unlockPolicy !== 'none' && device.features?.unlocked === false;
+    isProtocolV2 &&
+    method.unlockPolicy !== 'none' &&
+    !device.isBootloader?.() &&
+    !device.isRomloader?.() &&
+    device.features?.unlocked === false;
 
   if (shouldUnlockBeforeRun) {
     if (shouldEmitUi) {
@@ -68,11 +83,7 @@ export async function runMethodWithUnlockRetry(
   try {
     return await method.run();
   } catch (error) {
-    if (
-      !device.isProtocolV2() ||
-      method.unlockPolicy !== 'retry-on-locked' ||
-      !isDeviceLockedError(error)
-    ) {
+    if (!isProtocolV2 || method.unlockPolicy !== 'retry-on-locked' || !isDeviceLockedError(error)) {
       throw error;
     }
 

package/src/protocols/protocol-v2/walletSession.ts

@@ -3,13 +3,18 @@ import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { DEVICE } from '../../events';
 import { assertCompleteDeviceSession } from './deviceSession';
-import { isDeviceLockedError } from './lockedError';
 
-import type { DeviceSessionGet } from '@onekeyfe/hd-transport';
+import type { DeviceSessionAskPassphrase, DeviceSessionGet } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
 
 const HOST_PASSPHRASE_MAX_BYTES = 50;
 
+const isWalletSessionInvalidError = (error: unknown) =>
+  typeof error === 'object' &&
+  error !== null &&
+  'errorCode' in error &&
+  (error as { errorCode?: unknown }).errorCode === HardwareErrorCode.WalletSessionInvalid;
+
 const utf8ByteLength = (value: string): number | undefined => {
   let length = 0;
   for (const character of value) {
@@ -39,34 +44,11 @@ const negotiateEventlessWalletSession = async (device: Device) => {
   });
 };
 
-const getDeviceSession = async (device: Device, request: DeviceSessionGet) => {
-  try {
-    return await device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
-  } catch (error) {
-    if (!isDeviceLockedError(error) || !request.session_id) {
-      throw error;
-    }
-    await device.unlockDevice(DeviceSessionPinType.Main);
-    return device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
-  }
-};
+const getDeviceSession = async (device: Device, request: DeviceSessionGet) =>
+  device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
 
-const askDevicePassphrase = async (device: Device, passphrase?: string) => {
-  const request = () =>
-    device.commands.typedCall(
-      'DeviceSessionAskPassphrase',
-      'Success',
-      passphrase ? { passphrase, on_device: false } : { on_device: true }
-    );
-  try {
-    await request();
-  } catch (error) {
-    if (!isDeviceLockedError(error)) {
-      throw error;
-    }
-    await device.unlockDevice(DeviceSessionPinType.Main);
-    await request();
-  }
+const askDevicePassphrase = async (device: Device, requestPayload: DeviceSessionAskPassphrase) => {
+  await device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', requestPayload);
   await refreshProtocolV2DeviceStatus(device);
 };
 
@@ -126,25 +108,33 @@ const selectDeviceSession = async (device: Device, expectedPassphraseState?: str
   }
 
   if (hasHostPassphrase) {
-    await askDevicePassphrase(device, hostPassphrase);
+    await askDevicePassphrase(device, {
+      passphrase: hostPassphrase,
+      on_device: false,
+    });
     return getDeviceSession(device, {});
   }
 
   device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
-  await askDevicePassphrase(device);
+  await askDevicePassphrase(device, { on_device: true });
   return getDeviceSession(device, {});
 };
 
 export async function getProtocolV2WalletSession(
   device: Device,
   options?: {
+    forceWalletSelection?: boolean;
+    /** @deprecated 兼容旧 getPassphraseState；新流程使用 forceWalletSelection。 */
     initSession?: boolean;
     expectedPassphraseState?: string;
     onlyMainPin?: boolean;
     resumeOnly?: boolean;
   }
 ) {
-  if (options?.initSession) {
+  const forceWalletSelection =
+    options?.forceWalletSelection === true || options?.initSession === true;
+
+  if (forceWalletSelection) {
     if (options.onlyMainPin) {
       device.clearStandardInternalState?.();
     } else {
@@ -185,7 +175,10 @@ export async function getProtocolV2WalletSession(
         resumed = true;
       } catch (error) {
         device.clearStandardInternalState?.();
-        throw error;
+        if (!isWalletSessionInvalidError(error)) {
+          throw error;
+        }
+        resumed = false;
       }
     }
 
@@ -199,7 +192,10 @@ export async function getProtocolV2WalletSession(
       resumed = true;
     } catch (error) {
       device.clearInternalState();
-      throw error;
+      if (options?.resumeOnly || !isWalletSessionInvalidError(error)) {
+        throw error;
+      }
+      resumed = false;
     }
   }
 
@@ -224,6 +220,10 @@ export async function getProtocolV2WalletSession(
   }
   if (expectedPassphraseState && expectedPassphraseState !== message.btc_test_address) {
     resumed = false;
+    if (options?.resumeOnly) {
+      device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+    }
     if (options?.onlyMainPin) {
       device.clearStandardInternalState?.();
       await device.unlockDevice(DeviceSessionPinType.Main);
@@ -258,7 +258,7 @@ export async function getProtocolV2WalletSession(
     message.btc_test_address,
     device.getCurrentDeviceId(),
     message.session_id,
-    options?.initSession ? null : cachedSessionId ?? null,
+    forceWalletSelection ? null : cachedSessionId ?? null,
   ] as const;
   if (options?.onlyMainPin) {
     device.updateInternalState(...internalStateArgs, 'standard');

package/src/types/api/openWalletSession.ts

@@ -36,7 +36,7 @@ export type OpenWalletSessionPayload = OpenWalletSessionPayloadBase &
   (
     | {
         walletType: 'standard';
-        passphraseState: string | null;
+        passphraseState: null;
       }
     | {
         walletType: 'hidden';

package/src/types/api/protocolV2.ts

@@ -1,5 +1,5 @@
 import type { CommonParams, Response } from '../params';
-import type { DevOnboardingStatus, Success } from '@onekeyfe/hd-transport';
+import type { OnboardingStatus, Success } from '@onekeyfe/hd-transport';
 import type { DeviceRebootParams } from '../../api/protocol-v2/helpers';
 import type {
   DeviceUploadWallpaperParams,
@@ -45,7 +45,7 @@ export declare function deviceReboot(
 export declare function deviceGetOnboardingStatus(
   connectId: string,
   params?: CommonParams
-): Response<DevOnboardingStatus>;
+): Response<OnboardingStatus>;
 
 export declare function deviceUploadWallpaper(
   connectId: string,

package/src/types/device.ts

@@ -7,6 +7,7 @@ import type {
   OneKeyDeviceCommType,
   ProtocolV2DeviceInfo,
   DeviceStatus as ProtocolV2DeviceStatus,
+  ProtocolInfo as ProtocolV2ProtocolInfo,
 } from '@onekeyfe/hd-transport';
 
 export type DeviceStatus = 'available' | 'occupied' | 'used';
@@ -159,6 +160,7 @@ export type DeviceFeaturesVerify = {
 export type DeviceFeaturesRaw = {
   protocolV1Features?: PROTO.Features;
   protocolV1OneKeyFeatures?: OnekeyFeatures;
+  protocolV2ProtocolInfo?: ProtocolV2ProtocolInfo;
   protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
   protocolV2DeviceStatus?: ProtocolV2DeviceStatus;
 };