@onekeyfe/hd-core 1.1.26 → 1.1.27-alpha.31

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

@@ -0,0 +1,267 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import type { Features } from '../../types';
+import type { DeviceCommands } from '../../device/DeviceCommands';
+import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+
+type ProtocolV2Bytes = Uint8Array | number[] | string;
+
+type ProtocolV2FirmwareImageInfo = {
+  version?: string;
+  build_id?: string;
+  hash?: ProtocolV2Bytes;
+};
+
+type ProtocolV2SEInfo = {
+  boot?: ProtocolV2FirmwareImageInfo;
+  app?: ProtocolV2FirmwareImageInfo;
+  type?: number;
+  state?: number;
+};
+
+type ProtocolV2DeviceInfo = {
+  protocol_version?: number;
+  hw?: {
+    Device_type?: number;
+    device_type?: number;
+    serial_no?: string;
+    hardware_version?: string;
+    hardware_version_raw_adc?: number;
+  };
+  fw?: {
+    board?: ProtocolV2FirmwareImageInfo;
+    boot?: ProtocolV2FirmwareImageInfo;
+    app?: ProtocolV2FirmwareImageInfo;
+  };
+  bt?: {
+    boot?: ProtocolV2FirmwareImageInfo;
+    app?: ProtocolV2FirmwareImageInfo;
+    adv_name?: string;
+    mac?: ProtocolV2Bytes;
+  };
+  se1?: ProtocolV2SEInfo;
+  se2?: ProtocolV2SEInfo;
+  se3?: ProtocolV2SEInfo;
+  se4?: ProtocolV2SEInfo;
+  status?: {
+    language?: string;
+    bt_enable?: boolean;
+    init_states?: boolean;
+    backup_required?: boolean;
+    passphrase_protection?: boolean;
+    label?: string;
+  };
+};
+
+// const PROTOCOL_V2_DEVICE_INFO_REQUEST = {
+//   targets: {
+//     hw: true,
+//     fw: true,
+//     bt: true,
+//     se1: true,
+//     se2: true,
+//     se3: true,
+//     se4: true,
+//     status: true,
+//   },
+//   types: {
+//     version: true,
+//     build_id: true,
+//     hash: true,
+//     specific: true,
+//   },
+// };
+
+function parseVersion(version?: string | null): [number, number, number] {
+  if (!version) return [0, 0, 0];
+  const [major = 0, minor = 0, patch = 0] = version.split('.').map(part => Number(part) || 0);
+  return [major, minor, patch];
+}
+
+function bytesToHex(value: unknown): string | undefined {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (value instanceof Uint8Array) {
+    return Array.from(value)
+      .map(byte => byte.toString(16).padStart(2, '0'))
+      .join('');
+  }
+  if (Array.isArray(value)) {
+    return value.map(byte => Number(byte).toString(16).padStart(2, '0')).join('');
+  }
+  return undefined;
+}
+
+function getDescriptorId(descriptor: DeviceDescriptor) {
+  return descriptor.path || descriptor.id || '';
+}
+
+function getImageVersion(image?: ProtocolV2FirmwareImageInfo) {
+  return image?.version || undefined;
+}
+
+function getImageBuildId(image?: ProtocolV2FirmwareImageInfo) {
+  return image?.build_id || undefined;
+}
+
+function getImageHash(image?: ProtocolV2FirmwareImageInfo) {
+  return bytesToHex(image?.hash);
+}
+
+function getSeState(se?: ProtocolV2SEInfo) {
+  switch (se?.state) {
+    case 0:
+      return 'BOOT';
+    case 51:
+      return 'APP_FACTORY';
+    case 85:
+      return 'APP';
+    default:
+      return null;
+  }
+}
+
+function createBaseFeatures(descriptor: DeviceDescriptor): Features {
+  const descriptorId = getDescriptorId(descriptor);
+  return {
+    vendor: 'onekey.so',
+    major_version: 0,
+    minor_version: 0,
+    patch_version: 0,
+    bootloader_mode: false,
+    device_id: descriptorId,
+    pin_protection: null,
+    passphrase_protection: null,
+    language: null,
+    label: null,
+    initialized: false,
+    revision: null,
+    bootloader_hash: null,
+    imported: null,
+    unlocked: false,
+    firmware_present: false,
+    needs_backup: null,
+    flags: null,
+    model: 'pro2',
+    fw_major: 0,
+    fw_minor: 0,
+    fw_patch: 0,
+    fw_vendor: null,
+    unfinished_backup: null,
+    no_backup: null,
+    recovery_mode: null,
+    capabilities: [],
+    backup_type: null,
+    sd_card_present: null,
+    sd_protection: null,
+    wipe_code_protection: null,
+    session_id: null,
+    passphrase_always_on_device: null,
+    safety_checks: null,
+    auto_lock_delay_ms: null,
+    display_rotation: null,
+    experimental_features: null,
+    onekey_device_type: EDeviceType.Pro2,
+    onekey_serial_no: descriptorId,
+    serial_no: descriptorId,
+  };
+}
+
+export function normalizeProtocolV2Features(
+  descriptor: DeviceDescriptor,
+  deviceInfo?: ProtocolV2DeviceInfo
+): Features {
+  const features = createBaseFeatures(descriptor);
+  if (!deviceInfo) return features;
+
+  const serialNo =
+    deviceInfo.hw?.serial_no || features.onekey_serial_no || getDescriptorId(descriptor);
+  const firmwareVersion = getImageVersion(deviceInfo.fw?.app);
+  const [fwMajor, fwMinor, fwPatch] = parseVersion(firmwareVersion);
+
+  return {
+    ...features,
+    major_version: fwMajor,
+    minor_version: fwMinor,
+    patch_version: fwPatch,
+    fw_major: fwMajor,
+    fw_minor: fwMinor,
+    fw_patch: fwPatch,
+    device_id: serialNo,
+    serial_no: serialNo,
+    onekey_serial_no: serialNo,
+    label: deviceInfo.status?.label ?? features.label,
+    language: deviceInfo.status?.language ?? features.language,
+    initialized: deviceInfo.status?.init_states ?? features.initialized,
+    passphrase_protection:
+      deviceInfo.status?.passphrase_protection ?? features.passphrase_protection,
+    needs_backup: deviceInfo.status?.backup_required ?? features.needs_backup,
+    ble_enable: deviceInfo.status?.bt_enable,
+    onekey_ble_name: deviceInfo.bt?.adv_name,
+    ble_name: deviceInfo.bt?.adv_name,
+    onekey_firmware_version: firmwareVersion,
+    onekey_firmware_build_id: getImageBuildId(deviceInfo.fw?.app),
+    onekey_firmware_hash: getImageHash(deviceInfo.fw?.app),
+    onekey_boot_version: getImageVersion(deviceInfo.fw?.boot),
+    bootloader_version: getImageVersion(deviceInfo.fw?.boot),
+    onekey_boot_build_id: getImageBuildId(deviceInfo.fw?.boot),
+    onekey_boot_hash: getImageHash(deviceInfo.fw?.boot),
+    onekey_board_version: getImageVersion(deviceInfo.fw?.board),
+    onekey_board_hash: getImageHash(deviceInfo.fw?.board),
+    onekey_ble_version: getImageVersion(deviceInfo.bt?.app),
+    ble_ver: getImageVersion(deviceInfo.bt?.app),
+    onekey_ble_build_id: getImageBuildId(deviceInfo.bt?.app),
+    onekey_ble_hash: getImageHash(deviceInfo.bt?.app),
+    onekey_se01_version: getImageVersion(deviceInfo.se1?.app),
+    onekey_se01_hash: getImageHash(deviceInfo.se1?.app),
+    onekey_se01_build_id: getImageBuildId(deviceInfo.se1?.app),
+    onekey_se01_state: getSeState(deviceInfo.se1),
+    onekey_se02_version: getImageVersion(deviceInfo.se2?.app),
+    onekey_se02_state: getSeState(deviceInfo.se2),
+    onekey_se03_version: getImageVersion(deviceInfo.se3?.app),
+    onekey_se03_state: getSeState(deviceInfo.se3),
+    onekey_se04_version: getImageVersion(deviceInfo.se4?.app),
+    onekey_se04_state: getSeState(deviceInfo.se4),
+  };
+}
+
+export async function getProtocolV2Features({
+  commands,
+  descriptor,
+  // onDeviceInfoError,
+  timeoutMs,
+}: {
+  commands: DeviceCommands;
+  descriptor: DeviceDescriptor;
+  onDeviceInfoError?: (error: unknown) => void;
+  timeoutMs?: number;
+}) {
+  const callOptions = timeoutMs ? { timeoutMs } : undefined;
+  if (callOptions) {
+    await commands.typedCall('Ping', 'Success', { message: 'init' }, callOptions);
+  } else {
+    await commands.typedCall('Ping', 'Success', { message: 'init' });
+  }
+
+  // DeviceGetDeviceInfo 暂时关闭，避免初始化阶段依赖固件侧 DeviceInfo 支持。
+  // try {
+  //   const { message } = callOptions
+  //     ? await commands.typedCall(
+  //         'DeviceGetDeviceInfo',
+  //         'DeviceInfo',
+  //         PROTOCOL_V2_DEVICE_INFO_REQUEST,
+  //         callOptions
+  //       )
+  //     : await commands.typedCall(
+  //         'DeviceGetDeviceInfo',
+  //         'DeviceInfo',
+  //         PROTOCOL_V2_DEVICE_INFO_REQUEST
+  //       );
+  //   return normalizeProtocolV2Features(descriptor, message as unknown as ProtocolV2DeviceInfo);
+  // } catch (error) {
+  //   onDeviceInfoError?.(error);
+  //   return normalizeProtocolV2Features(descriptor);
+  // }
+
+  return normalizeProtocolV2Features(descriptor);
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Protocol V2 DeviceFirmwareTargetType enum (from messages-pro2.json).
+ */
+export const ProtocolV2FirmwareTargetType = {
+  TARGET_INVALID: 0,
+  TARGET_ROMLOADER: 1,
+  TARGET_BOOTLOADER: 2,
+  TARGET_FIRMWARE_P1: 3,
+  TARGET_FIRMWARE_P2: 4,
+  TARGET_COPROCESSOR: 5,
+  TARGET_SE: 6,
+  TARGET_RESOURCE: 10,
+} as const;
+
+/**
+ * Map Protocol V2 firmware file name to DeviceFirmwareUpdate target_id.
+ */
+export function protocolV2FileNameToTargetId(fileName: string): number {
+  const normalized = fileName.toLowerCase();
+  if (normalized.includes('romloader')) return ProtocolV2FirmwareTargetType.TARGET_ROMLOADER;
+  if (normalized.includes('bootloader')) return ProtocolV2FirmwareTargetType.TARGET_BOOTLOADER;
+  if (normalized.includes('ble')) return ProtocolV2FirmwareTargetType.TARGET_COPROCESSOR;
+  if (normalized.includes('se')) return ProtocolV2FirmwareTargetType.TARGET_SE;
+  if (normalized.includes('p2')) return ProtocolV2FirmwareTargetType.TARGET_FIRMWARE_P2;
+  return ProtocolV2FirmwareTargetType.TARGET_FIRMWARE_P1;
+}

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

@@ -0,0 +1,2 @@
+export * from './features';
+export * from './firmware';

package/src/types/api/export.ts

@@ -28,6 +28,7 @@ export type {
   FirmwareUpdateParams,
   FirmwareUpdateBinaryParams,
   FirmwareUpdateV3Params,
+  FirmwareUpdateV4Params,
 } from './firmwareUpdate';
 export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
 

package/src/types/api/firmwareUpdate.ts

@@ -41,6 +41,7 @@ export declare function firmwareUpdateV2(
 export interface FirmwareUpdateV3Params {
   bleVersion?: number[];
   bleBinary?: ArrayBuffer;
+  chunkSize?: number;
 
   firmwareVersion?: number[];
   firmwareBinary?: ArrayBuffer;
@@ -56,6 +57,8 @@ export interface FirmwareUpdateV3Params {
   platform: IPlatform;
 }
 
+export type FirmwareUpdateV4Params = FirmwareUpdateV3Params;
+
 export declare function firmwareUpdateV3(
   connectId: string | undefined,
   params: Params<FirmwareUpdateV3Params>
@@ -64,3 +67,12 @@ export declare function firmwareUpdateV3(
   firmwareVersion: string;
   bootloaderVersion: string;
 }>;
+
+export declare function firmwareUpdateV4(
+  connectId: string | undefined,
+  params: Params<FirmwareUpdateV4Params>
+): Response<{
+  bleVersion: string;
+  firmwareVersion: string;
+  bootloaderVersion: string;
+}>;

package/src/types/api/getPassphraseState.ts

@@ -1,6 +1,15 @@
 import type { CommonParams, Response } from '../params';
 
+export type GetPassphraseStatePayload =
+  | string
+  | {
+      passphrase_state?: string;
+      session_id?: string;
+      unlocked_attach_pin?: boolean;
+      passphrase_protection?: boolean | null;
+    };
+
 export declare function getPassphraseState(
   connectId?: string,
   params?: CommonParams
-): Response<string>;
+): Response<GetPassphraseStatePayload>;

package/src/types/api/index.ts

@@ -1,3 +1,30 @@
+import type {
+  deviceFirmwareUpdate,
+  deviceGetDeviceInfo,
+  deviceGetFirmwareUpdateStatus,
+  deviceGetOnboardingStatus,
+  deviceReboot,
+  dirList,
+  dirMake,
+  dirRemove,
+  factoryDeviceInfoSettings,
+  factoryGetDeviceInfo,
+  fileDelete,
+  fileRead,
+  fileWrite,
+  filesystemDirList,
+  filesystemDirMake,
+  filesystemDirRemove,
+  filesystemFileDelete,
+  filesystemFileRead,
+  filesystemFileWrite,
+  filesystemFixPermission,
+  filesystemFormat,
+  filesystemPathInfoQuery,
+  getProtoVersion,
+  pathInfo,
+  ping,
+} from './protocolV2';
 import type { off, on, removeAllListeners } from './event';
 import type { uiResponse } from './uiResponse';
 import type { init, updateSettings } from './init';
@@ -14,7 +41,12 @@ import type { getOnekeyFeatures } from './getOnekeyFeatures';
 import type { getPassphraseState } from './getPassphraseState';
 import type { checkFirmwareRelease } from './checkFirmwareRelease';
 import type { checkBLEFirmwareRelease } from './checkBLEFirmwareRelease';
-import type { firmwareUpdate, firmwareUpdateV2, firmwareUpdateV3 } from './firmwareUpdate';
+import type {
+  firmwareUpdate,
+  firmwareUpdateV2,
+  firmwareUpdateV3,
+  firmwareUpdateV4,
+} from './firmwareUpdate';
 import type { promptWebDeviceAccess } from './promptWebDeviceAccess';
 import type { deviceReset } from './deviceReset';
 import type { deviceRecovery } from './deviceRecovery';
@@ -130,6 +162,7 @@ import type { neoSignTransaction } from './neoSignTransaction';
 import type { ConnectSettings } from '../settings';
 
 export * from './export';
+export type { GetPassphraseStatePayload } from './getPassphraseState';
 
 export type CoreApi = {
   /**
@@ -195,8 +228,38 @@ export type CoreApi = {
   firmwareUpdate: typeof firmwareUpdate;
   firmwareUpdateV2: typeof firmwareUpdateV2;
   firmwareUpdateV3: typeof firmwareUpdateV3;
+  firmwareUpdateV4: typeof firmwareUpdateV4;
   cipherKeyValue: typeof cipherKeyValue;
 
+  /**
+   * File system & device control API (Protocol V2 only)
+   */
+  getProtoVersion: typeof getProtoVersion;
+  ping: typeof ping;
+  deviceReboot: typeof deviceReboot;
+  deviceGetDeviceInfo: typeof deviceGetDeviceInfo;
+  deviceGetOnboardingStatus: typeof deviceGetOnboardingStatus;
+  deviceFirmwareUpdate: typeof deviceFirmwareUpdate;
+  deviceGetFirmwareUpdateStatus: typeof deviceGetFirmwareUpdateStatus;
+  factoryDeviceInfoSettings: typeof factoryDeviceInfoSettings;
+  factoryGetDeviceInfo: typeof factoryGetDeviceInfo;
+  filesystemFixPermission: typeof filesystemFixPermission;
+  fileRead: typeof fileRead;
+  fileWrite: typeof fileWrite;
+  fileDelete: typeof fileDelete;
+  dirList: typeof dirList;
+  dirMake: typeof dirMake;
+  dirRemove: typeof dirRemove;
+  pathInfo: typeof pathInfo;
+  filesystemFileRead: typeof filesystemFileRead;
+  filesystemFileWrite: typeof filesystemFileWrite;
+  filesystemFileDelete: typeof filesystemFileDelete;
+  filesystemDirList: typeof filesystemDirList;
+  filesystemDirMake: typeof filesystemDirMake;
+  filesystemDirRemove: typeof filesystemDirRemove;
+  filesystemPathInfoQuery: typeof filesystemPathInfoQuery;
+  filesystemFormat: typeof filesystemFormat;
+
   /**
    * All network function
    */

package/src/types/api/protocolV2.ts

@@ -0,0 +1,221 @@
+import type { CommonParams, Response } from '../params';
+import type {
+  DeviceFirmwareTarget,
+  DeviceFirmwareUpdateStatus,
+  DeviceOnboardingStatus,
+  DeviceInfoTargets,
+  DeviceInfoTypes,
+  DeviceRebootType,
+  FactoryDeviceInfo,
+  ProtoVersion,
+  ProtocolV2DeviceInfo,
+  Success,
+} from '@onekeyfe/hd-transport';
+
+// ── Shared response shapes (Protocol V2 file system) ────────────────────
+
+export type FileOpSuccess = { message?: string };
+
+export type FileInfo = {
+  path: string;
+  offset: number;
+  total_size: number;
+  data?: Uint8Array;
+  data_hash?: number;
+  processed_byte?: number;
+  chunks?: number;
+};
+
+export type DirInfo = {
+  path: string;
+  child_dirs?: string;
+  child_files?: string;
+};
+
+export type PathInfoResult = {
+  exist: boolean;
+  size: number;
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+  readonly?: boolean;
+  hidden?: boolean;
+  system?: boolean;
+  archive?: boolean;
+  directory?: boolean;
+};
+
+export type DeviceRebootParams = {
+  rebootType?: DeviceRebootType | string | number;
+  reboot_type?: DeviceRebootType | string | number;
+};
+
+export type DeviceGetDeviceInfoParams = {
+  targets?: DeviceInfoTargets;
+  types?: DeviceInfoTypes;
+  targetHw?: boolean;
+  targetFw?: boolean;
+  targetBt?: boolean;
+  targetSe1?: boolean;
+  targetSe2?: boolean;
+  targetSe3?: boolean;
+  targetSe4?: boolean;
+  targetStatus?: boolean;
+  includeVersion?: boolean;
+  includeBuildId?: boolean;
+  includeHash?: boolean;
+  includeSpecific?: boolean;
+};
+
+export type DeviceFirmwareUpdateParams = {
+  targets?: DeviceFirmwareTarget[];
+  targetId?: DeviceFirmwareTarget['target_id'] | string | number;
+  target_id?: DeviceFirmwareTarget['target_id'] | string | number;
+  path?: string;
+};
+
+export type FactoryDeviceInfoSettingsParams = {
+  serial_no?: string;
+  serialNo?: string;
+  cpu_info?: string;
+  cpuInfo?: string;
+  pre_firmware?: string;
+  preFirmware?: string;
+};
+
+// ── Method signatures ─────────────────────────────────────────────────────
+
+export declare function fileRead(
+  connectId: string,
+  params: {
+    path: string;
+    offset?: number;
+    totalSize?: number;
+    chunkLen?: number;
+    uiPercentage?: number;
+  }
+): Response<FileInfo>;
+
+export declare function fileWrite(
+  connectId: string,
+  params: {
+    path: string;
+    offset?: number;
+    totalSize?: number;
+    chunkSize?: number;
+    chunkLen?: number;
+    data: ArrayBuffer | Uint8Array | Blob | string;
+    overwrite?: boolean;
+    append?: boolean;
+    uiPercentage?: number;
+  }
+): Response<FileInfo>;
+
+export declare function fileDelete(
+  connectId: string,
+  params: { path: string }
+): Response<FileOpSuccess>;
+
+export declare function dirList(
+  connectId: string,
+  params: { path: string; depth?: number }
+): Response<DirInfo>;
+
+export declare function dirMake(
+  connectId: string,
+  params: { path: string }
+): Response<FileOpSuccess>;
+
+export declare function dirRemove(
+  connectId: string,
+  params: { path: string }
+): Response<FileOpSuccess>;
+
+export declare function pathInfo(
+  connectId: string,
+  params: { path: string }
+): Response<PathInfoResult>;
+
+export declare function getProtoVersion(
+  connectId: string,
+  params?: CommonParams
+): Response<ProtoVersion>;
+
+export declare function ping(
+  connectId: string,
+  params?: CommonParams & { message?: string }
+): Response<Success>;
+
+export declare function deviceReboot(
+  connectId: string,
+  params: CommonParams & DeviceRebootParams
+): Response<Success>;
+
+export declare function deviceGetDeviceInfo(
+  connectId: string,
+  params?: CommonParams & DeviceGetDeviceInfoParams
+): Response<ProtocolV2DeviceInfo>;
+
+export declare function deviceGetOnboardingStatus(
+  connectId: string,
+  params?: CommonParams
+): Response<DeviceOnboardingStatus>;
+
+export declare function deviceFirmwareUpdate(
+  connectId: string,
+  params: CommonParams & DeviceFirmwareUpdateParams
+): Response<Success | DeviceFirmwareUpdateStatus>;
+
+export declare function deviceGetFirmwareUpdateStatus(
+  connectId: string,
+  params?: CommonParams
+): Response<DeviceFirmwareUpdateStatus>;
+
+export declare function factoryDeviceInfoSettings(
+  connectId: string,
+  params: FactoryDeviceInfoSettingsParams
+): Response<Success>;
+
+export declare function factoryGetDeviceInfo(connectId: string): Response<FactoryDeviceInfo>;
+
+export declare function filesystemFixPermission(connectId: string): Response<Success>;
+
+export declare function filesystemFileRead(
+  connectId: string,
+  params: Parameters<typeof fileRead>[1]
+): ReturnType<typeof fileRead>;
+
+export declare function filesystemFileWrite(
+  connectId: string,
+  params: Parameters<typeof fileWrite>[1]
+): ReturnType<typeof fileWrite>;
+
+export declare function filesystemFileDelete(
+  connectId: string,
+  params: Parameters<typeof fileDelete>[1]
+): ReturnType<typeof fileDelete>;
+
+export declare function filesystemDirList(
+  connectId: string,
+  params: Parameters<typeof dirList>[1]
+): ReturnType<typeof dirList>;
+
+export declare function filesystemDirMake(
+  connectId: string,
+  params: Parameters<typeof dirMake>[1]
+): ReturnType<typeof dirMake>;
+
+export declare function filesystemDirRemove(
+  connectId: string,
+  params: Parameters<typeof dirRemove>[1]
+): ReturnType<typeof dirRemove>;
+
+export declare function filesystemPathInfoQuery(
+  connectId: string,
+  params: Parameters<typeof pathInfo>[1]
+): ReturnType<typeof pathInfo>;
+
+export declare function filesystemFormat(connectId: string): Response<Success>;

package/src/types/api/searchDevices.ts

@@ -1,4 +1,4 @@
 import type { SearchDevice } from '../device';
-import type { Response } from '../params';
+import type { CommonParams, Response } from '../params';
 
-export declare function searchDevices(): Response<SearchDevice[]>;
+export declare function searchDevices(params?: CommonParams): Response<SearchDevice[]>;

package/src/types/device.ts

@@ -96,7 +96,8 @@ export type IDeviceType =
   | EDeviceType.ClassicPure
   | EDeviceType.Mini
   | EDeviceType.Touch
-  | EDeviceType.Pro;
+  | EDeviceType.Pro
+  | EDeviceType.Pro2;
 
 /**
  * model_classic: 'classic' | 'classic1s' | 'classicpure'
@@ -124,6 +125,7 @@ export const DeviceTypeToModels: { [deviceType in IDeviceType]: IDeviceModel[] }
   [EDeviceType.Mini]: ['model_mini'],
   [EDeviceType.Touch]: ['model_touch'],
   [EDeviceType.Pro]: ['model_touch'],
+  [EDeviceType.Pro2]: [],
   [EDeviceType.Unknown]: [],
 };