@onekeyfe/hd-core 1.2.0-alpha.0 → 1.2.0-alpha.10

package/src/api/protocol-v2/{DeviceGetDeviceInfo.ts → DeviceInfoGet.ts}

@@ -3,11 +3,12 @@ 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 DeviceGetDeviceInfoTargets = {
+export type DeviceInfoGetTargets = {
   hw?: boolean;
   fw?: boolean;
-  bt?: boolean;
+  coprocessor?: boolean;
   se1?: boolean;
   se2?: boolean;
   se3?: boolean;
@@ -15,22 +16,22 @@ export type DeviceGetDeviceInfoTargets = {
   status?: boolean;
 };
 
-export type DeviceGetDeviceInfoTypes = {
+export type DeviceInfoGetTypes = {
   version?: boolean;
   build_id?: boolean;
   hash?: boolean;
   specific?: boolean;
 };
 
-export type DeviceGetDeviceInfoParams = {
-  targets?: DeviceGetDeviceInfoTargets;
-  types?: DeviceGetDeviceInfoTypes;
+export type DeviceInfoGetParams = {
+  targets?: DeviceInfoGetTargets;
+  types?: DeviceInfoGetTypes;
 };
 
-const TARGET_KEYS: (keyof DeviceGetDeviceInfoTargets)[] = [
+const TARGET_KEYS: (keyof DeviceInfoGetTargets)[] = [
   'hw',
   'fw',
-  'bt',
+  'coprocessor',
   'se1',
   'se2',
   'se3',
@@ -38,16 +39,16 @@ const TARGET_KEYS: (keyof DeviceGetDeviceInfoTargets)[] = [
   'status',
 ];
 
-const TYPE_KEYS: (keyof DeviceGetDeviceInfoTypes)[] = ['version', 'build_id', 'hash', 'specific'];
+const TYPE_KEYS: (keyof DeviceInfoGetTypes)[] = ['version', 'build_id', 'hash', 'specific'];
 
-const DEFAULT_TARGETS: DeviceGetDeviceInfoTargets = {
+const DEFAULT_TARGETS: DeviceInfoGetTargets = {
   hw: true,
   fw: true,
-  bt: true,
+  coprocessor: true,
   status: true,
 };
 
-const DEFAULT_TYPES: DeviceGetDeviceInfoTypes = {
+const DEFAULT_TYPES: DeviceInfoGetTypes = {
   version: true,
   specific: true,
 };
@@ -69,16 +70,48 @@ function pickBooleanKeys<T extends Record<string, boolean | undefined>>(
   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);
+}
+
 /**
- * 原生 DevGetDeviceInfo（Protocol V2 only）。
+ * 原生 DeviceInfoGet（Protocol V2 only）。
  *
  * 与 getDeviceInfo 不同：不构建 DeviceProfile、不更新设备缓存，
  * 按调用方给定的 targets/types 原样请求并返回未加工的 DeviceInfo 消息，
  * 用于调试固件字段上报。
  */
-export default class DeviceGetDeviceInfo extends BaseMethod<{
-  targets: DeviceGetDeviceInfoTargets;
-  types: DeviceGetDeviceInfoTypes;
+export default class DeviceInfoGet extends BaseMethod<{
+  targets: DeviceInfoGetTargets;
+  types: DeviceInfoGetTypes;
 }> {
   init() {
     // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
@@ -91,11 +124,8 @@ export default class DeviceGetDeviceInfo extends BaseMethod<{
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;
     this.params = {
-      targets:
-        pickBooleanKeys<DeviceGetDeviceInfoTargets>(this.payload.targets, TARGET_KEYS) ??
-        DEFAULT_TARGETS,
-      types:
-        pickBooleanKeys<DeviceGetDeviceInfoTypes>(this.payload.types, TYPE_KEYS) ?? DEFAULT_TYPES,
+      targets: normalizeTargets(this.payload.targets) ?? DEFAULT_TARGETS,
+      types: normalizeTypes(this.payload.types) ?? DEFAULT_TYPES,
     };
   }
 
@@ -105,7 +135,7 @@ export default class DeviceGetDeviceInfo extends BaseMethod<{
     }
 
     const res = await this.device.commands.typedCall(
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: this.params.targets,

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

@@ -1,5 +1,5 @@
 import { BaseMethod } from '../BaseMethod';
-import { normalizeDeviceRebootType } from './helpers';
+import { normalizeRebootType } from './helpers';
 
 import type { DeviceRebootParams } from './helpers';
 
@@ -17,7 +17,7 @@ export default class DeviceReboot extends BaseMethod<DeviceRebootParams> {
 
   async run() {
     const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
-      reboot_type: normalizeDeviceRebootType(this.params.reboot_type ?? this.params.rebootType),
+      reboot_type: normalizeRebootType(this.params.reboot_type ?? this.params.rebootType),
     });
     return Promise.resolve(res.message);
   }

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

@@ -0,0 +1,26 @@
+import { BaseMethod } from '../BaseMethod';
+
+export type DeviceSessionGetParams = {
+  sessionId?: string;
+};
+
+export default class DeviceSessionGet extends BaseMethod<DeviceSessionGetParams> {
+  init() {
+    this.requireProtocolV2 = true;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = {
+      sessionId: this.payload.sessionId,
+    };
+  }
+
+  async run() {
+    const payload = this.params.sessionId ? { session_id: this.params.sessionId } : {};
+    const { message } = await this.device.commands.typedCall(
+      'DeviceSessionGet',
+      'DeviceSession',
+      payload
+    );
+    return message;
+  }
+}

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

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

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

@@ -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,6 +1,6 @@
 import { BaseMethod } from '../BaseMethod';
 
-export default class FilesystemFixPermission extends BaseMethod {
+export default class FilesystemPermissionFix extends BaseMethod {
   init() {
     // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
     this.requireProtocolV2 = true;
@@ -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/{GetProtoVersion.ts → ProtocolInfoRequest.ts}

@@ -1,6 +1,6 @@
 import { BaseMethod } from '../BaseMethod';
 
-export default class GetProtoVersion extends BaseMethod {
+export default class ProtocolInfoRequest extends BaseMethod {
   init() {
     // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
     this.requireProtocolV2 = true;
@@ -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) {
@@ -133,19 +128,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 +138,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/tron/TronSignMessage.ts

@@ -47,7 +47,6 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
     return {
       pro2: {
         min: '0.0.0',
-        unsupported: true,
       },
       model_mini: {
         min: '2.5.0',

package/src/api/tron/TronSignTransaction.ts

@@ -150,7 +150,6 @@ export default class TronSignTransaction extends BaseMethod<TronSignTx> {
     return {
       pro2: {
         min: '0.0.0',
-        unsupported: true,
       },
       model_mini: {
         min: '2.5.0',

package/src/constants/index.ts

@@ -1,2 +1,11 @@
 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/index.ts

@@ -57,16 +57,12 @@ import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
 import { getSynchronize } from '../utils/getSynchronize';
 
-import type { ConnectSettings, KnownDevice } from '../types';
+import type { ConnectSettings, Features, KnownDevice } from '../types';
 import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
 import type { DeviceEvents, InitOptions, RunOptions } from '../device/Device';
 import type { SdkTracingContext } from '../utils/tracing';
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type {
-  Features,
-  LowlevelTransportSharedPlugin,
-  OneKeyDeviceInfo,
-} from '@onekeyfe/hd-transport';
+import type { LowlevelTransportSharedPlugin, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
@@ -99,6 +95,7 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   deviceId: method?.payload.deviceId,
   deriveCardano: method && hasDeriveCardano(method),
   connectProtocol: method?.payload.connectProtocol,
+  protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
 });
 
 let _core: Core;
@@ -226,9 +223,15 @@ const handlePreWarmSignal = async (
   message: CoreMessage,
   method: BaseMethod
 ): Promise<any> => {
+  const createAckResponse = () => {
+    completeMethodRequestContext(method);
+    method.dispose();
+    return createResponseMessage(method.responseID, true, true);
+  };
+
   // no connectId: can't target a device safely, skip pre-warm (ack only)
   if (!method.connectId) {
-    return createResponseMessage(method.responseID, true, true);
+    return createAckResponse();
   }
 
   const key = method.getPreWarmKey();
@@ -241,12 +244,12 @@ const handlePreWarmSignal = async (
     } catch {
       // pre-warm is best-effort; ignore its failure for the coalesced caller
     }
-    return createResponseMessage(method.responseID, true, true);
+    return createAckResponse();
   }
 
   const doneAt = preWarmDoneAt.get(key);
   if (typeof doneAt === 'number' && Date.now() - doneAt <= method.preWarmTtl) {
-    return createResponseMessage(method.responseID, true, true);
+    return createAckResponse();
   }
 
   const run = onCallDevice(context, message, method);
@@ -735,6 +738,15 @@ function initDevice(method: BaseMethod) {
 
   if (method.connectId) {
     device = _deviceList.getDevice(method.connectId);
+    if (!device && method.name === 'firmwareUpdateV4' && allDevices.length === 1) {
+      const [singleDevice] = allDevices;
+      if (singleDevice.isBootloader()) {
+        Log.debug(
+          'firmwareUpdateV4 uses the only bootloader device when connectId changed after reboot'
+        );
+        device = singleDevice;
+      }
+    }
   } else if (allDevices.length === 1) {
     [device] = allDevices;
   } else if (allDevices.length > 1) {
@@ -1115,7 +1127,7 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
 
   const passphraseProtection = method.device
     ? method.device.getCurrentPassphraseProtection()
-    : features?.passphrase_protection;
+    : features?.passphraseProtection;
 
   if (passphraseProtection === true) {
     const hasNoPassphraseState =