@onekeyfe/hd-core 1.1.28 → 1.2.0-alpha.1

package/src/api/nervos/NervosSignTransaction.ts

@@ -5,8 +5,12 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 
-import type { NervosSignTransactionParams, NervosSignedTx } from '../../types';
-import type { NervosSignTx as HardwareNervosSignTx, TypedCall } from '@onekeyfe/hd-transport';
+import type { DeviceFirmwareRange, NervosSignTransactionParams, NervosSignedTx } from '../../types';
+import type {
+  NervosSignTx as HardwareNervosSignTx,
+  NervosTxRequest,
+  TypedCall,
+} from '@onekeyfe/hd-transport';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 
 type NervosSignTx = Omit<HardwareNervosSignTx, 'data_initial_chunk' | 'data_length'> & {
@@ -41,8 +45,12 @@ export default class NervosSignTransaction extends BaseMethod<NervosSignTx> {
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '3.7.0',
       },
@@ -59,7 +67,9 @@ export default class NervosSignTransaction extends BaseMethod<NervosSignTx> {
     res: TypedResponseMessage<'NervosSignedTx'> | TypedResponseMessage<'NervosTxRequest'>,
     data: Buffer,
     offset = 0
-  ): Promise<NervosSignedTx> => {
+    // 设备可能在最后一个 NervosTxRequest（无 data_length）里返回签名，
+    // 该消息没有 address 字段，返回类型如实声明为联合类型
+  ): Promise<NervosSignedTx | (NervosTxRequest & { path: string })> => {
     if (res.type === 'NervosSignedTx') {
       if (!res?.message?.signature) {
         throw new Error('No signature returned');

package/src/api/nexa/NexaGetAddress.ts

@@ -4,7 +4,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 
 import type { NexaGetAddress as HardwareNexaGetAddress } from '@onekeyfe/hd-transport';
-import type { NexaGetAddressParams } from '../../types';
+import type { DeviceFirmwareRange, NexaGetAddressParams } from '../../types';
 
 export default class NexaGetAddress extends BaseMethod<HardwareNexaGetAddress[]> {
   hasBundle = false;
@@ -43,8 +43,12 @@ export default class NexaGetAddress extends BaseMethod<HardwareNexaGetAddress[]>
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '3.2.0',
       },

package/src/api/nexa/NexaSignTransaction.ts

@@ -6,7 +6,7 @@ import { validateParams } from '../helpers/paramsValidator';
 
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 import type { TypedCall } from '@onekeyfe/hd-transport';
-import type { NexaSignTransactionParams, NexaSignature } from '../../types';
+import type { DeviceFirmwareRange, NexaSignTransactionParams, NexaSignature } from '../../types';
 
 export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionParams> {
   hasBundle = false;
@@ -27,8 +27,12 @@ export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionP
     this.params = payload;
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '3.2.0',
       },
@@ -68,17 +72,12 @@ export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionP
 
       const nextIndex = res.message.request_index;
       const input = this.params.inputs[nextIndex];
-      const response = await typedCall(
-        'NexaTxInputAck',
-        // @ts-expect-error
-        ['NexaTxInputRequest', 'NexaSignedTx'],
-        {
-          address_n: input.path,
-          raw_message: input.message,
-        }
-      );
+      const response = await typedCall('NexaTxInputAck', ['NexaTxInputRequest', 'NexaSignedTx'], {
+        // path 为字符串形式，归一为 address_n 数组（与 run() 中首个 input 的处理一致）
+        address_n: validatePath(input.path, 3),
+        raw_message: input.message,
+      });
 
-      // @ts-expect-error
       return this.processTxRequest(typedCall, response, nextIndex, signatures);
     }
 

package/src/api/polkadot/networks.ts

@@ -23,6 +23,9 @@ const baseVersionRange = {
   model_touch: {
     min: '4.3.0',
   },
+  pro2: {
+    min: '0.0.0',
+  },
 };
 
 const specialVersionRange: Record<string, DeviceFirmwareRange> = {
@@ -33,6 +36,9 @@ const specialVersionRange: Record<string, DeviceFirmwareRange> = {
     model_touch: {
       min: '4.7.0',
     },
+    pro2: {
+      min: '0.0.0',
+    },
   },
   [Networks.Manta]: {
     model_mini: {
@@ -41,6 +47,9 @@ const specialVersionRange: Record<string, DeviceFirmwareRange> = {
     model_touch: {
       min: '4.9.0',
     },
+    pro2: {
+      min: '0.0.0',
+    },
   },
 };
 

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

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

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

@@ -0,0 +1,63 @@
+import { BaseMethod } from '../BaseMethod';
+import {
+  PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS,
+  PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
+  isProtocolV2DeviceDisconnectedError,
+  normalizeFirmwareTargets,
+} from './helpers';
+import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
+
+import type { KnownDevice } from '../../types';
+import type { MessageFromOneKey } from '@onekeyfe/hd-transport';
+import type { DeviceFirmwareUpdateParams } from './helpers';
+
+export default class DeviceFirmwareUpdate extends BaseMethod<DeviceFirmwareUpdateParams> {
+  init() {
+    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      targets: this.payload.targets,
+      targetId: this.payload.targetId,
+      target_id: this.payload.target_id,
+      path: this.payload.path,
+    };
+  }
+
+  async run() {
+    const targets = normalizeFirmwareTargets(this.params);
+    try {
+      const res = await this.device.commands.typedCall(
+        'DevFirmwareUpdate',
+        PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
+        {
+          targets,
+        },
+        {
+          ...PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS,
+          onIntermediateResponse: (response: MessageFromOneKey) => {
+            if (response.type !== 'DevFirmwareInstallProgress') return;
+            const progress = Number(response.message?.progress);
+            if (!Number.isFinite(progress)) return;
+            this.postMessage(
+              createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
+                device: this.device.toMessageObject() as KnownDevice,
+                progress: Math.min(Math.max(progress, 0), 100),
+                progressType: 'installingFirmware',
+              })
+            );
+          },
+        }
+      );
+      return Promise.resolve(res.message);
+    } catch (error) {
+      if (isProtocolV2DeviceDisconnectedError(error)) {
+        return Promise.resolve({
+          message: 'Device firmware update started',
+        });
+      }
+      throw error;
+    }
+  }
+}

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

@@ -0,0 +1,118 @@
+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';
+
+export type DeviceGetDeviceInfoTargets = {
+  hw?: boolean;
+  fw?: boolean;
+  bt?: boolean;
+  se1?: boolean;
+  se2?: boolean;
+  se3?: boolean;
+  se4?: boolean;
+  status?: boolean;
+};
+
+export type DeviceGetDeviceInfoTypes = {
+  version?: boolean;
+  build_id?: boolean;
+  hash?: boolean;
+  specific?: boolean;
+};
+
+export type DeviceGetDeviceInfoParams = {
+  targets?: DeviceGetDeviceInfoTargets;
+  types?: DeviceGetDeviceInfoTypes;
+};
+
+const TARGET_KEYS: (keyof DeviceGetDeviceInfoTargets)[] = [
+  'hw',
+  'fw',
+  'bt',
+  'se1',
+  'se2',
+  'se3',
+  'se4',
+  'status',
+];
+
+const TYPE_KEYS: (keyof DeviceGetDeviceInfoTypes)[] = ['version', 'build_id', 'hash', 'specific'];
+
+const DEFAULT_TARGETS: DeviceGetDeviceInfoTargets = {
+  hw: true,
+  fw: true,
+  bt: true,
+  status: true,
+};
+
+const DEFAULT_TYPES: DeviceGetDeviceInfoTypes = {
+  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;
+}
+
+/**
+ * 原生 DevGetDeviceInfo（Protocol V2 only）。
+ *
+ * 与 getDeviceInfo 不同：不构建 DeviceProfile、不更新设备缓存，
+ * 按调用方给定的 targets/types 原样请求并返回未加工的 DeviceInfo 消息，
+ * 用于调试固件字段上报。
+ */
+export default class DeviceGetDeviceInfo extends BaseMethod<{
+  targets: DeviceGetDeviceInfoTargets;
+  types: DeviceGetDeviceInfoTypes;
+}> {
+  init() {
+    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    this.requireProtocolV2 = true;
+    this.allowDeviceMode = [
+      ...this.allowDeviceMode,
+      UI_REQUEST.NOT_INITIALIZE,
+      UI_REQUEST.BOOTLOADER,
+    ];
+    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,
+    };
+  }
+
+  async run() {
+    if (!this.device.isProtocolV2()) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+
+    const res = await this.device.commands.typedCall(
+      'DevGetDeviceInfo',
+      '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/DeviceGetFirmwareUpdateStatus.ts

@@ -0,0 +1,20 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DeviceGetFirmwareUpdateStatus 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(
+      'DevGetFirmwareUpdateStatus',
+      'DevFirmwareUpdateStatus',
+      {}
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,16 @@
+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);
+  }
+}

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

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

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

@@ -0,0 +1,29 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { FactoryDeviceInfoSettingsParams } from './helpers';
+
+export default class FactoryDeviceInfoSettings extends BaseMethod<FactoryDeviceInfoSettingsParams> {
+  init() {
+    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      serial_no: this.payload.serial_no,
+      serialNo: this.payload.serialNo,
+      cpu_info: this.payload.cpu_info,
+      cpuInfo: this.payload.cpuInfo,
+      pre_firmware: this.payload.pre_firmware,
+      preFirmware: this.payload.preFirmware,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FactoryDeviceInfoSettings', 'Success', {
+      serial_no: this.params.serial_no ?? this.params.serialNo,
+      cpu_info: this.params.cpu_info ?? this.params.cpuInfo,
+      pre_firmware: this.params.pre_firmware ?? this.params.preFirmware,
+    });
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,20 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FactoryGetDeviceInfo 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(
+      'FactoryGetDeviceInfo',
+      'FactoryDeviceInfo',
+      {}
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,50 @@
+import { BaseMethod } from '../BaseMethod';
+import {
+  invalidParameter,
+  validateOptionalNonNegativeInteger,
+} from '../helpers/filesystemValidation';
+
+export type FilesystemDiskControlParams = {
+  // 收紧为 boolean | 0 | 1；'0' / '1' 字符串仅作为历史输入向后兼容，内部归一化为 0/1
+  enable?: boolean | 0 | 1;
+  timeoutMs?: number | string;
+};
+
+function normalizeDiskControlEnable(value: unknown): 0 | 1 {
+  if (value === undefined || value === null) return 0;
+  if (typeof value === 'boolean') return value ? 1 : 0;
+  if (value === 0 || value === '0') return 0;
+  if (value === 1 || value === '1') return 1;
+  throw invalidParameter('Parameter [enable] must be a boolean or 0 | 1.');
+}
+
+export default class FilesystemDiskControl extends BaseMethod<{
+  enable: 0 | 1;
+  timeoutMs?: number;
+}> {
+  init() {
+    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      enable: normalizeDiskControlEnable(this.payload.enable),
+      timeoutMs: validateOptionalNonNegativeInteger(this.payload.timeoutMs, 'timeoutMs'),
+    };
+  }
+
+  async run() {
+    const typedCall = this.device.commands.typedCall as any;
+    const res = await typedCall(
+      'FilesystemDiskControl',
+      'Success',
+      {
+        enable: this.params.enable,
+      },
+      {
+        timeoutMs: this.params.timeoutMs,
+      }
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,16 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FilesystemFixPermission 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('FilesystemFixPermission', 'Success', {});
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,16 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FilesystemFormat 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('FilesystemFormat', 'Success', {});
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,16 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class GetProtoVersion 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('GetProtoVersion', 'ProtoVersion', {});
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class Ping extends BaseMethod<{ message?: string }> {
+  init() {
+    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { message: this.payload.message };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('Ping', 'Success', {
+      message: this.params.message ?? '',
+    });
+    return Promise.resolve(res.message);
+  }
+}