@onekeyfe/hd-core 1.2.0-alpha.2 → 1.2.0-alpha.21

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

@@ -2,15 +2,17 @@ import { BaseMethod } from '../BaseMethod';
 
 export default class DeviceGetOnboardingStatus extends BaseMethod {
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
     this.requireProtocolV2 = true;
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
-    this.params = undefined;
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('GetOnboardingStatus', 'OnboardingStatus', {});
-    return Promise.resolve(res.message);
+    const { message } = await this.device.commands.typedCall(
+      'DevGetOnboardingStatus',
+      'DevOnboardingStatus',
+      {}
+    );
+    return message;
   }
 }

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

@@ -0,0 +1,145 @@
+import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
+import { UI_REQUEST } from '../../constants/ui-request';
+import { PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS } from '../../protocols/protocol-v2';
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+
+export type DeviceInfoGetTargets = {
+  hw?: boolean;
+  fw?: boolean;
+  coprocessor?: boolean;
+  se1?: boolean;
+  se2?: boolean;
+  se3?: boolean;
+  se4?: boolean;
+};
+
+export type DeviceInfoGetTypes = {
+  version?: boolean;
+  build_id?: boolean;
+  hash?: boolean;
+  specific?: boolean;
+};
+
+export type DeviceInfoGetParams = {
+  targets?: DeviceInfoGetTargets;
+  types?: DeviceInfoGetTypes;
+};
+
+const TARGET_KEYS: (keyof DeviceInfoGetTargets)[] = [
+  'hw',
+  'fw',
+  'coprocessor',
+  'se1',
+  'se2',
+  'se3',
+  'se4',
+];
+
+const TYPE_KEYS: (keyof DeviceInfoGetTypes)[] = ['version', 'build_id', 'hash', 'specific'];
+
+const DEFAULT_TARGETS: DeviceInfoGetTargets = {
+  hw: true,
+  fw: true,
+  coprocessor: true,
+};
+
+const DEFAULT_TYPES: DeviceInfoGetTypes = {
+  version: true,
+  specific: true,
+};
+
+function pickBooleanKeys<T extends Record<string, boolean | undefined>>(
+  value: unknown,
+  keys: (keyof T)[]
+): T | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  const source = value as Record<string, unknown>;
+  const result = {} as T;
+  let hasKey = false;
+  for (const key of keys) {
+    if (source[key as string]) {
+      result[key] = true as T[keyof T];
+      hasKey = true;
+    }
+  }
+  return hasKey ? result : undefined;
+}
+
+function assertKnownKeys(value: unknown, keys: string[], name: string) {
+  if (value == null) return;
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw invalidParameter(`Parameter [${name}] must be an object.`);
+  }
+  const allowed = new Set(keys);
+  const unknownKeys = Object.keys(value).filter(key => !allowed.has(key));
+  if (unknownKeys.length > 0) {
+    throw invalidParameter(
+      `Parameter [${name}] contains unsupported key(s): ${unknownKeys.join(', ')}.`
+    );
+  }
+}
+
+function normalizeTargets(value: unknown): DeviceInfoGetTargets | undefined {
+  assertKnownKeys(
+    value,
+    TARGET_KEYS.map(key => String(key)),
+    'targets'
+  );
+  return pickBooleanKeys<DeviceInfoGetTargets>(value, TARGET_KEYS);
+}
+
+function normalizeTypes(value: unknown): DeviceInfoGetTypes | undefined {
+  assertKnownKeys(
+    value,
+    TYPE_KEYS.map(key => String(key)),
+    'types'
+  );
+  return pickBooleanKeys<DeviceInfoGetTypes>(value, TYPE_KEYS);
+}
+
+/**
+ * Raw DeviceInfoGet command for Protocol V2 only.
+ *
+ * The SDK builds targets/types on demand and returns the raw DeviceInfo message.
+ * This command is internal; integrations should use getDeviceState.
+ */
+export default class DeviceInfoGet extends BaseMethod<{
+  targets: DeviceInfoGetTargets;
+  types: DeviceInfoGetTypes;
+}> {
+  init() {
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'none';
+    this.allowDeviceMode = [
+      ...this.allowDeviceMode,
+      UI_REQUEST.NOT_INITIALIZE,
+      UI_REQUEST.BOOTLOADER,
+    ];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = {
+      targets: normalizeTargets(this.payload.targets) ?? DEFAULT_TARGETS,
+      types: normalizeTypes(this.payload.types) ?? DEFAULT_TYPES,
+    };
+  }
+
+  async run() {
+    if (!this.device.isProtocolV2()) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+
+    const res = await this.device.commands.typedCall(
+      'DeviceInfoGet',
+      'DeviceInfo',
+      {
+        targets: this.params.targets,
+        types: this.params.types,
+      },
+      { timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS }
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -1,11 +1,11 @@
 import { BaseMethod } from '../BaseMethod';
-import { normalizeDeviceRebootType } from './helpers';
+import { normalizeRebootType } from './helpers';
 
 import type { DeviceRebootParams } from './helpers';
 
 export default class DeviceReboot extends BaseMethod<DeviceRebootParams> {
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.requireProtocolV2 = true;
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
@@ -16,9 +16,11 @@ export default class DeviceReboot extends BaseMethod<DeviceRebootParams> {
   }
 
   async run() {
+    const rebootType = normalizeRebootType(this.params.reboot_type ?? this.params.rebootType);
     const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
-      reboot_type: normalizeDeviceRebootType(this.params.reboot_type ?? this.params.rebootType),
+      reboot_type: rebootType,
     });
+    this.device.markProtocolV2Reboot(rebootType);
     return Promise.resolve(res.message);
   }
 }

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

@@ -0,0 +1,16 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceStatusGet extends BaseMethod {
+  init() {
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'none';
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall('DeviceStatusGet', 'DeviceStatus', {});
+    this.device.updateProtocolV2Status(message);
+    return message;
+  }
+}

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

@@ -0,0 +1,131 @@
+import { blake2s } from '@noble/hashes/blake2s';
+import { bytesToHex } from '@noble/hashes/utils';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+import { writeProtocolV2File } from '../helpers/protocolV2FileWrite';
+import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
+import {
+  PRO2_WALLPAPER_HEIGHT,
+  PRO2_WALLPAPER_WIDTH,
+  type Pro2WallpaperColorFormat,
+  encodePro2Wallpaper,
+} from '../../utils/pro2Wallpaper';
+
+export type DeviceUploadWallpaperParams = {
+  width: number;
+  height: number;
+  rgba: Uint8Array | ArrayBuffer;
+  fileName?: string;
+  chunkSize?: number;
+};
+
+export type DeviceUploadWallpaperResponse = {
+  path: string;
+  size: number;
+  colorFormat: Pro2WallpaperColorFormat;
+  message?: string;
+};
+
+const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
+const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
+
+function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
+  if (fileName !== undefined && (!fileName || !SAFE_FILE_NAME.test(fileName))) {
+    throw invalidParameter(
+      'Parameter [fileName] may only contain letters, numbers, underscores, hyphens and an optional .bin suffix.'
+    );
+  }
+  const baseName = fileName ?? `wallpaper-${bytesToHex(blake2s(data)).slice(0, 12)}`;
+  return baseName.endsWith('.bin') ? baseName : `${baseName}.bin`;
+}
+
+export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpaperParams> {
+  private encoded?: { data: Uint8Array; colorFormat: Pro2WallpaperColorFormat };
+
+  private directoryReady = false;
+
+  private uploaded = false;
+
+  private path = '';
+
+  init() {
+    const { width, height, rgba, fileName, chunkSize } = this.payload;
+    if (width !== PRO2_WALLPAPER_WIDTH || height !== PRO2_WALLPAPER_HEIGHT) {
+      throw invalidParameter(
+        `Pro2 wallpaper dimensions must be ${PRO2_WALLPAPER_WIDTH}x${PRO2_WALLPAPER_HEIGHT}.`
+      );
+    }
+    if (!(rgba instanceof ArrayBuffer) && !ArrayBuffer.isView(rgba)) {
+      throw invalidParameter('Parameter [rgba] must be an ArrayBuffer or Uint8Array.');
+    }
+    if (chunkSize !== undefined && (!Number.isInteger(chunkSize) || chunkSize <= 0)) {
+      throw invalidParameter('Parameter [chunkSize] must be a positive integer.');
+    }
+
+    const rgbaBytes =
+      rgba instanceof ArrayBuffer
+        ? rgba
+        : new Uint8Array(rgba.buffer, rgba.byteOffset, rgba.byteLength);
+    this.encoded = encodePro2Wallpaper({ width, height, rgba: rgbaBytes });
+    this.path = `${WALLPAPER_DIRECTORY}/${normalizeFileName(fileName, this.encoded.data)}`;
+    this.params = { width, height, rgba: rgbaBytes, fileName, chunkSize };
+    this.requireProtocolV2 = true;
+    this.unlockPolicy = 'retry-on-locked';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+  }
+
+  private async ensureDirectory() {
+    if (this.directoryReady) return;
+    try {
+      await this.device.commands.typedCall('FilesystemDirMake', 'Success', {
+        path: WALLPAPER_DIRECTORY,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!/exist/i.test(message)) throw error;
+    }
+    this.directoryReady = true;
+  }
+
+  private async upload() {
+    if (this.uploaded) return;
+    const { encoded } = this;
+    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
+
+    await writeProtocolV2File({
+      commands: this.device.commands,
+      path: this.path,
+      data: encoded.data,
+      totalSize: encoded.data.byteLength,
+      chunkSize: this.params.chunkSize,
+      maxChunkRetries: 3,
+      overwrite: true,
+      append: false,
+      throwIfAborted: () => this.throwIfAborted(),
+      onProgress: payload => {
+        if (typeof this.postMessage === 'function') {
+          this.postMessage(createUiMessage(UI_REQUEST.DEVICE_PROGRESS, payload));
+        }
+      },
+    });
+    this.uploaded = true;
+  }
+
+  async run(): Promise<DeviceUploadWallpaperResponse> {
+    const { encoded } = this;
+    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
+    await this.ensureDirectory();
+    await this.upload();
+    const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
+      settings: { wallpaper_path: this.path },
+    });
+    return {
+      path: this.path,
+      size: encoded.data.byteLength,
+      colorFormat: encoded.colorFormat,
+      message: response.message?.message,
+    };
+  }
+}

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

@@ -2,7 +2,7 @@ import { BaseMethod } from '../BaseMethod';
 
 export default class FilesystemFormat extends BaseMethod {
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.requireProtocolV2 = true;
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
@@ -10,7 +10,10 @@ export default class FilesystemFormat extends BaseMethod {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('FilesystemFormat', 'Success', {});
+    const res = await this.device.commands.typedCall('FilesystemFormat', 'Success', {
+      data: true,
+      user: true,
+    });
     return Promise.resolve(res.message);
   }
 }

package/src/api/protocol-v2/{FilesystemFixPermission.ts → FilesystemPermissionFix.ts}

@@ -1,8 +1,8 @@
 import { BaseMethod } from '../BaseMethod';
 
-export default class FilesystemFixPermission extends BaseMethod {
+export default class FilesystemPermissionFix extends BaseMethod {
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.requireProtocolV2 = true;
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
@@ -10,7 +10,7 @@ export default class FilesystemFixPermission extends BaseMethod {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('FilesystemFixPermission', 'Success', {});
+    const res = await this.device.commands.typedCall('FilesystemPermissionFix', 'Success', {});
     return Promise.resolve(res.message);
   }
 }

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

@@ -2,7 +2,7 @@ import { BaseMethod } from '../BaseMethod';
 
 export default class Ping extends BaseMethod<{ message?: string }> {
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.requireProtocolV2 = true;
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;

package/src/api/protocol-v2/{GetProtoVersion.ts → ProtocolInfoRequest.ts}

@@ -1,8 +1,8 @@
 import { BaseMethod } from '../BaseMethod';
 
-export default class GetProtoVersion extends BaseMethod {
+export default class ProtocolInfoRequest extends BaseMethod {
   init() {
-    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    // Protocol V2 (Pro2) only; Core rejects non-V2 devices.
     this.requireProtocolV2 = true;
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
@@ -10,7 +10,7 @@ export default class GetProtoVersion extends BaseMethod {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('GetProtoVersion', 'ProtoVersion', {});
+    const res = await this.device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {});
     return Promise.resolve(res.message);
   }
 }

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

@@ -1,20 +1,16 @@
-import { DevRebootType, DeviceRebootType } from '@onekeyfe/hd-transport';
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
 
 import { invalidParameter, validateNonEmptyString } from '../helpers/filesystemValidation';
+import { ProtocolV2FirmwareTargetType } from '../../protocols/protocol-v2/firmware';
 
 import type {
-  DevFirmwareTarget,
-  DevFirmwareTargetType,
+  DeviceFirmwareTarget,
+  DeviceFirmwareTargetType,
+  DeviceFirmwareUpdateRecordFields,
   TransportCallOptions,
 } from '@onekeyfe/hd-transport';
 
-export type RebootTypeInput =
-  | DevRebootType
-  | DeviceRebootType
-  | keyof typeof DevRebootType
-  | keyof typeof DeviceRebootType
-  | string
-  | number;
+export type RebootTypeInput = DeviceRebootType | keyof typeof DeviceRebootType | string | number;
 
 export type DeviceRebootParams = {
   rebootType?: RebootTypeInput;
@@ -22,38 +18,37 @@ export type DeviceRebootParams = {
 };
 
 export type DeviceFirmwareTargetInput =
-  | DevFirmwareTarget
+  | DeviceFirmwareTarget
   | {
-      targetId?: DevFirmwareTargetType | string | number;
-      target_id?: DevFirmwareTargetType | string | number;
+      targetId?: DeviceFirmwareTargetType | string | number;
+      target_id?: DeviceFirmwareTargetType | string | number;
       path: string;
     };
 
 export type DeviceFirmwareUpdateParams = {
   targets?: DeviceFirmwareTargetInput[];
-  targetId?: DevFirmwareTargetType | string | number;
-  target_id?: DevFirmwareTargetType | string | number;
+  targetId?: DeviceFirmwareTargetType | string | number;
+  target_id?: DeviceFirmwareTargetType | string | number;
   path?: string;
 };
 
-export type FactoryDeviceInfoSettingsParams = {
-  serial_no?: string;
-  serialNo?: string;
-  cpu_info?: string;
-  cpuInfo?: string;
-  pre_firmware?: string;
-  preFirmware?: string;
+export type DeviceFirmwareUpdateStatusGetParams = {
+  fields?: DeviceFirmwareUpdateRecordFields;
 };
 
-const DEV_REBOOT_TYPES: Record<string, DevRebootType> = {
-  Normal: DevRebootType.Normal,
-  normal: DevRebootType.Normal,
-  Romloader: DevRebootType.Boardloader,
-  romloader: DevRebootType.Boardloader,
-  Boardloader: DevRebootType.Boardloader,
-  boardloader: DevRebootType.Boardloader,
-  Bootloader: DevRebootType.Bootloader,
-  bootloader: DevRebootType.Bootloader,
+export type DeviceFactoryInfoSetParams = {
+  version?: number;
+  serial_number?: string;
+  burn_in_completed?: boolean;
+  factory_test_completed?: boolean;
+  manufacture_time?: {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+  };
 };
 
 const DEVICE_REBOOT_TYPES: Record<string, DeviceRebootType> = {
@@ -68,13 +63,13 @@ const DEVICE_REBOOT_TYPES: Record<string, DeviceRebootType> = {
 };
 
 export const PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS: TransportCallOptions = {
-  intermediateTypes: ['DevFirmwareInstallProgress'],
+  intermediateTypes: ['DeviceFirmwareUpdateStatus'],
 };
 
 export const PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES: (
   | 'Success'
-  | 'DevFirmwareUpdateStatus'
-)[] = ['Success', 'DevFirmwareUpdateStatus'];
+  | 'DeviceFirmwareUpdateStatus'
+)[] = ['Success', 'DeviceFirmwareUpdateStatus'];
 
 export const getProtocolV2UnknownErrorText = (error: unknown) => {
   if (!error) {
@@ -123,9 +118,6 @@ export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
     message.includes('connection has timed out unexpectedly') ||
     message.includes('connection error has occured') ||
     message.includes('connection error has occurred') ||
-    message.includes('transferIn') ||
-    message.includes('transferin') ||
-    message.includes('usbdevice') ||
     message.includes('multiplatformbleadapter') ||
     message.includes('multipalformebleadapter') ||
     compactMessage.includes('rxerrorerror6') ||
@@ -133,19 +125,7 @@ export const isProtocolV2DeviceDisconnectedError = (error: unknown) => {
   );
 };
 
-export function normalizeRebootType(value: RebootTypeInput | undefined): DevRebootType {
-  if (typeof value === 'number') return value;
-  if (typeof value === 'string') {
-    const numeric = Number(value);
-    if (Number.isFinite(numeric)) return numeric;
-    if (value in DEV_REBOOT_TYPES) return DEV_REBOOT_TYPES[value];
-  }
-  return DevRebootType.Normal;
-}
-
-export function normalizeDeviceRebootType(
-  value: RebootTypeInput | undefined
-): DeviceRebootType {
+export function normalizeRebootType(value: RebootTypeInput | undefined): DeviceRebootType {
   if (typeof value === 'number') return value;
   if (typeof value === 'string') {
     const numeric = Number(value);
@@ -155,30 +135,46 @@ export function normalizeDeviceRebootType(
   return DeviceRebootType.Normal;
 }
 
-// 当前 firmware-pro2 子模块的 DevFirmwareTargetType 合法值。
-const VALID_FIRMWARE_TARGET_IDS = new Set<number>([0, 1, 2, 3, 4, 5, 6, 10]);
+// 与 firmware-pro2 的 proto_target_to_firmware_target 安装白名单保持一致。
+const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set<number>([
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03,
+  ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04,
+]);
+const FIRMWARE_TARGET_ID_BY_NAME = new Map<string, DeviceFirmwareTargetType>(
+  Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) =>
+    INSTALLABLE_FIRMWARE_TARGET_IDS.has(value) ? [[key, value as DeviceFirmwareTargetType]] : []
+  )
+);
 
 function normalizeTargetId(
-  value: DevFirmwareTargetType | string | number | undefined,
+  value: DeviceFirmwareTargetType | string | number | undefined,
   name: string
-): DevFirmwareTargetType {
+): DeviceFirmwareTargetType {
   if (value === undefined || value === null) {
     throw invalidParameter(`Missing required parameter: ${name}`);
   }
-  const numeric = typeof value === 'number' ? value : Number(value);
-  // 校验值域：仅接受 DevFirmwareTargetType 中定义的 target id，
-  // 不再放行任意非负整数。
-  if (Number.isSafeInteger(numeric) && VALID_FIRMWARE_TARGET_IDS.has(numeric)) {
-    return numeric as DevFirmwareTargetType;
+  const named = typeof value === 'string' ? FIRMWARE_TARGET_ID_BY_NAME.get(value) : undefined;
+  const numeric = named ?? (typeof value === 'number' ? value : Number(value));
+  if (Number.isSafeInteger(numeric) && INSTALLABLE_FIRMWARE_TARGET_IDS.has(numeric)) {
+    return numeric as DeviceFirmwareTargetType;
   }
   throw invalidParameter(
-    `Parameter [${name}] must be a valid firmware target id (one of ${[
-      ...VALID_FIRMWARE_TARGET_IDS,
+    `Parameter [${name}] must be an installable firmware target id (one of ${[
+      ...INSTALLABLE_FIRMWARE_TARGET_IDS,
     ].join(', ')}).`
   );
 }
 
-export function normalizeFirmwareTargets(params: DeviceFirmwareUpdateParams): DevFirmwareTarget[] {
+export function normalizeFirmwareTargets(
+  params: DeviceFirmwareUpdateParams
+): DeviceFirmwareTarget[] {
   const targets =
     params.targets ??
     (params.path

package/src/api/ton/TonSignData.ts

@@ -51,11 +51,7 @@ export default class TonSignData extends BaseMethod<HardwareTonSignData> {
   }
 
   getVersionRange() {
-    return {
-      pro2: {
-        min: '0.0.0',
-      },
-    };
+    return {};
   }
 
   async run() {

package/src/api/utils.ts

@@ -2,16 +2,20 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import * as ApiMethods from './index';
 
+import type { BaseMethod } from './BaseMethod';
 import type { IFrameCallMessage } from '../events';
 
-export function findMethod(message: IFrameCallMessage & { id?: number }) {
+type MethodConstructor = new (message: IFrameCallMessage & { id?: number }) => BaseMethod<any>;
+
+const publicMethodRegistry = ApiMethods as unknown as Record<string, MethodConstructor>;
+
+export function findMethod(message: IFrameCallMessage & { id?: number }): BaseMethod<any> {
   const { method } = message.payload;
   if (typeof method !== 'string') {
     throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
   }
 
-  // @ts-expect-error
-  const MethodConstructor = ApiMethods[method];
+  const MethodConstructor = publicMethodRegistry[method];
   if (MethodConstructor) {
     return new MethodConstructor(message);
   }

package/src/constants/index.ts

@@ -1,2 +1,8 @@
 export { safeThrowError } from './errors';
-export { Messages as PROTO, TonSignDataType } from '@onekeyfe/hd-transport';
+export {
+  Messages as PROTO,
+  ResourceType,
+  TonSignDataType,
+  TonWalletVersion,
+} from '@onekeyfe/hd-transport';
+export type { HDNodeType, Success as DeviceSuccess } from '@onekeyfe/hd-transport';

package/src/core/RequestQueue.ts

@@ -30,6 +30,7 @@ export default class RequestQueue {
       method.responseID = requestId;
     }
     const abortController = new AbortController();
+    method.abortSignal = abortController.signal;
     const task = { id: requestId, method, abortController };
     this.requestQueue.set(requestId, task);
     return task;