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

package/src/api/GetOnekeyFeatures.ts

@@ -4,6 +4,76 @@ import { UI_REQUEST } from '../constants/ui-request';
 import { fixVersion } from '../utils/deviceFeaturesUtils';
 import { BaseMethod } from './BaseMethod';
 
+import type { OnekeyFeatures } from '../types';
+
+const ONEKEY_FEATURE_KEYS: Array<keyof OnekeyFeatures> = [
+  'onekey_device_type',
+  'onekey_board_version',
+  'onekey_boot_version',
+  'onekey_firmware_version',
+  'onekey_board_hash',
+  'onekey_boot_hash',
+  'onekey_firmware_hash',
+  'onekey_board_build_id',
+  'onekey_boot_build_id',
+  'onekey_firmware_build_id',
+  'onekey_serial_no',
+  'onekey_ble_name',
+  'onekey_ble_version',
+  'onekey_ble_build_id',
+  'onekey_ble_hash',
+  'onekey_se_type',
+  'onekey_se01_state',
+  'onekey_se02_state',
+  'onekey_se03_state',
+  'onekey_se04_state',
+  'onekey_se01_version',
+  'onekey_se02_version',
+  'onekey_se03_version',
+  'onekey_se04_version',
+  'onekey_se01_hash',
+  'onekey_se02_hash',
+  'onekey_se03_hash',
+  'onekey_se04_hash',
+  'onekey_se01_build_id',
+  'onekey_se02_build_id',
+  'onekey_se03_build_id',
+  'onekey_se04_build_id',
+  'onekey_se01_boot_version',
+  'onekey_se02_boot_version',
+  'onekey_se03_boot_version',
+  'onekey_se04_boot_version',
+  'onekey_se01_boot_hash',
+  'onekey_se02_boot_hash',
+  'onekey_se03_boot_hash',
+  'onekey_se04_boot_hash',
+  'onekey_se01_boot_build_id',
+  'onekey_se02_boot_build_id',
+  'onekey_se03_boot_build_id',
+  'onekey_se04_boot_build_id',
+];
+
+function normalizeOnekeyFirmwareVersion(message: OnekeyFeatures) {
+  if (message.onekey_firmware_version && !semver.valid(message.onekey_firmware_version)) {
+    message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
+  }
+}
+
+function pickOnekeyFeatures(features?: OnekeyFeatures | null): OnekeyFeatures {
+  const message: OnekeyFeatures = {};
+  if (!features) return message;
+
+  for (const key of ONEKEY_FEATURE_KEYS) {
+    const value = features[key];
+    if (value !== undefined && value !== null) {
+      (message as Record<string, unknown>)[key] = value;
+    }
+  }
+
+  normalizeOnekeyFirmwareVersion(message);
+  return message;
+}
+
 export default class GetOnekeyFeatures extends BaseMethod {
   init() {
     this.allowDeviceMode = [
@@ -16,10 +86,12 @@ export default class GetOnekeyFeatures extends BaseMethod {
   }
 
   async run() {
-    const { message } = await this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
-    if (!!message.onekey_firmware_version && !semver.valid(message.onekey_firmware_version)) {
-      message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
+    if (this.device.originalDescriptor?.protocolType === 'V2') {
+      return Promise.resolve(pickOnekeyFeatures(this.device.features as OnekeyFeatures));
     }
+
+    const { message } = await this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
+    normalizeOnekeyFirmwareVersion(message);
     return Promise.resolve(message);
   }
 }

package/src/api/PathInfo.ts

@@ -0,0 +1,24 @@
+import { BaseMethod } from './BaseMethod';
+
+export type PathInfoParams = {
+  path: string;
+};
+
+export default class PathInfo extends BaseMethod<PathInfoParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { path: this.payload.path };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'FilesystemPathInfoQuery',
+      'FilesystemPathInfo',
+      {
+        path: this.params.path,
+      }
+    );
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/SearchDevices.ts

@@ -34,17 +34,22 @@ export default class SearchDevices extends BaseMethod {
         const lowerId = device.id?.toLowerCase();
         if (!seenIds.has(lowerId)) {
           seenIds.add(lowerId);
+          const bleName =
+            device.name ?? (device as unknown as { localName?: string }).localName ?? '';
           devices.push({
             ...device,
             connectId: device.id,
-            deviceType: getDeviceTypeByBleName(device.name ?? ''),
+            name: bleName || device.name,
+            deviceType: getDeviceTypeByBleName(bleName),
           });
         }
       }
       return devices;
     }
 
-    const { deviceList } = await DevicePool.getDevices(devicesDescriptor);
+    const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
+      connectProtocol: this.payload.connectProtocol,
+    });
     return deviceList.map(device => device.toMessageObject());
   }
 }

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -12,7 +12,12 @@ import { validateParams } from '../helpers/paramsValidator';
 import { PROTO } from '../../constants';
 import { findMethod } from '../utils';
 import { DEVICE, IFRAME, createUiMessage } from '../../events';
-import { getDeviceFirmwareVersion, getFirmwareType, getMethodVersionRange } from '../../utils';
+import {
+  getDeviceFirmwareVersion,
+  getFirmwareType,
+  getMethodVersionRange,
+  shouldSkipMethodSupportCheck,
+} from '../../utils';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { onDeviceButtonHandler } from '../../core';
 import {
@@ -371,14 +376,6 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       this.device.on(DEVICE.PASSPHRASE, onSignalAbort);
 
       preCheckDeviceSupport(this.device, method);
-      if (this.temporarySafetyCheckPrompted) {
-        method.temporarySafetyCheckPrompted = true;
-      } else {
-        const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
-        if (appliedTemporarySafetyCheck) {
-          this.temporarySafetyCheckPrompted = true;
-        }
-      }
 
       const response = await method.run();
 
@@ -463,6 +460,10 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
  * @param method BaseMethod
  */
 function preCheckDeviceSupport(device: Device, method: BaseMethod) {
+  if (shouldSkipMethodSupportCheck(device.features, device.originalDescriptor?.protocolType)) {
+    return;
+  }
+
   const versionRange = getMethodVersionRange(
     device.features,
     type => method.getVersionRange()[type]

package/src/api/device/DeviceRebootToBoardloader.ts

@@ -1,3 +1,5 @@
+import { DevRebootType } from '@onekeyfe/hd-transport';
+
 import { BaseMethod } from '../BaseMethod';
 
 import type { RebootToBoardloaderParams } from '../../types/api/deviceRebootToBoardloader';
@@ -21,10 +23,17 @@ export default class DeviceRebootToBoardloader extends BaseMethod<RebootToBoardl
   }
 
   async run() {
+    // Protocol V2 uses DevReboot with reboot_type enum.
+    if (this.device.originalDescriptor?.protocolType === 'V2') {
+      const res = await this.device.commands.typedCall('DevReboot', 'Success', {
+        reboot_type: DevRebootType.Boardloader,
+      });
+      return Promise.resolve(res.message);
+    }
+
     // On Touch devices, messsage code 904 is RebootToBoardloader
     // so BininOutMessageSE message code 904 is used here
     const res = await this.device.commands.typedCall('BixinOutMessageSE', 'Success');
-
     return Promise.resolve(res.message);
   }
 }

package/src/api/device/DeviceRebootToBootloader.ts

@@ -1,3 +1,5 @@
+import { DevRebootType } from '@onekeyfe/hd-transport';
+
 import { BaseMethod } from '../BaseMethod';
 
 import type { RebootToBootloader } from '@onekeyfe/hd-transport';
@@ -21,8 +23,15 @@ export default class DeviceRebootToBootloader extends BaseMethod<RebootToBootloa
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('RebootToBootloader', 'Success');
+    // Protocol V2 uses DevReboot with reboot_type enum.
+    if (this.device.originalDescriptor?.protocolType === 'V2') {
+      const res = await this.device.commands.typedCall('DevReboot', 'Success', {
+        reboot_type: DevRebootType.Bootloader,
+      });
+      return Promise.resolve(res.message);
+    }
 
+    const res = await this.device.commands.typedCall('RebootToBootloader', 'Success');
     return Promise.resolve(res.message);
   }
 }

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -28,6 +28,13 @@ const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
 
+type FirmwareProgressMetadata = {
+  transferredBytes?: number;
+  totalBytes?: number;
+  rateBytesPerSecond?: number;
+  elapsedMs?: number;
+};
+
 const isDeviceDisconnectedError = (error: unknown) => {
   const message = error instanceof Error ? error.message : String(error ?? '');
   return (
@@ -82,12 +89,17 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
    * @description Post the progress message
    * @param progress Post the percentage of the progress
    */
-  postProgressMessage = (progress: number, progressType: IFirmwareUpdateProgressType) => {
+  postProgressMessage = (
+    progress: number,
+    progressType: IFirmwareUpdateProgressType,
+    metadata: FirmwareProgressMetadata = {}
+  ) => {
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
         device: this.device.toMessageObject() as KnownDevice,
         progress,
         progressType,
+        ...metadata,
       })
     );
   };
@@ -325,10 +337,12 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     filePath,
     processedSize,
     totalSize,
+    transferStartTime = Date.now(),
   }: PROTO.FirmwareUpload & {
     filePath: string;
     processedSize?: number;
     totalSize?: number;
+    transferStartTime?: number;
   }) {
     if (!filePath.startsWith('0:')) {
       throw new Error('filePath must start with 0:');
@@ -338,7 +352,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     const chunkSize = 1024 * perPackageSize;
     const totalChunks = Math.ceil(payload.byteLength / chunkSize);
     let offset = 0;
-    let currentFileProcessed = 0;
 
     for (let i = 0; i < totalChunks; i++) {
       const chunkStart = i * chunkSize;
@@ -350,7 +363,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
       // Calculate progress based on whether we're tracking overall progress or single file progress
       let progress: number;
       if (totalSize !== undefined && processedSize !== undefined) {
-        currentFileProcessed = processedSize + chunkEnd;
+        const currentFileProcessed = processedSize + chunkEnd;
         progress = Math.min(Math.ceil((currentFileProcessed / totalSize) * 100), 99);
       } else {
         progress = Math.min(Math.ceil(((i + 1) / totalChunks) * 100), 99);
@@ -366,7 +379,17 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
       );
       // @ts-expect-error
       offset += writeRes.message.processed_byte;
-      this.postProgressMessage(progress, 'transferData');
+      const elapsedMs = Date.now() - transferStartTime;
+      const transferredBytes =
+        totalSize !== undefined && processedSize !== undefined ? processedSize + offset : offset;
+      const totalBytes = totalSize ?? payload.byteLength;
+      this.postProgressMessage(progress, 'transferData', {
+        transferredBytes,
+        totalBytes,
+        rateBytesPerSecond:
+          elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
+        elapsedMs,
+      });
     }
 
     // Return processed size only if we're tracking overall progress

package/src/api/index.ts

@@ -37,8 +37,36 @@ export { default as getNextU2FCounter } from './u2f/GetNextU2FCounter';
 export { default as firmwareUpdate } from './FirmwareUpdate';
 export { default as firmwareUpdateV2 } from './FirmwareUpdateV2';
 export { default as firmwareUpdateV3 } from './FirmwareUpdateV3';
+export { default as firmwareUpdateV4 } from './FirmwareUpdateV4';
 export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 
+// File system & device control API (Protocol V2 only)
+export { default as getProtoVersion } from './protocol-v2/GetProtoVersion';
+export { default as ping } from './protocol-v2/Ping';
+export { default as devReboot } from './protocol-v2/DevReboot';
+export { default as devGetDeviceInfo } from './protocol-v2/DevGetDeviceInfo';
+export { default as devGetOnboardingStatus } from './protocol-v2/DevGetOnboardingStatus';
+export { default as devFirmwareUpdate } from './protocol-v2/DevFirmwareUpdate';
+export { default as devGetFirmwareUpdateStatus } from './protocol-v2/DevGetFirmwareUpdateStatus';
+export { default as factoryDeviceInfoSettings } from './protocol-v2/FactoryDeviceInfoSettings';
+export { default as factoryGetDeviceInfo } from './protocol-v2/FactoryGetDeviceInfo';
+export { default as filesystemFixPermission } from './protocol-v2/FilesystemFixPermission';
+export { default as filesystemFormat } from './protocol-v2/FilesystemFormat';
+export { default as fileRead } from './FileRead';
+export { default as fileWrite } from './FileWrite';
+export { default as fileDelete } from './FileDelete';
+export { default as dirList } from './DirList';
+export { default as dirMake } from './DirMake';
+export { default as dirRemove } from './DirRemove';
+export { default as pathInfo } from './PathInfo';
+export { default as filesystemFileRead } from './FileRead';
+export { default as filesystemFileWrite } from './FileWrite';
+export { default as filesystemFileDelete } from './FileDelete';
+export { default as filesystemDirList } from './DirList';
+export { default as filesystemDirMake } from './DirMake';
+export { default as filesystemDirRemove } from './DirRemove';
+export { default as filesystemPathInfoQuery } from './PathInfo';
+
 export { default as cipherKeyValue } from './CipherKeyValue';
 
 export { default as allNetworkGetAddress } from './allnetwork/AllNetworkGetAddress';

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

@@ -0,0 +1,33 @@
+import { BaseMethod } from '../BaseMethod';
+import {
+  PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS,
+  PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
+  normalizeFirmwareTargets,
+} from './helpers';
+
+import type { DevFirmwareUpdateParams } from './helpers';
+
+export default class DevFirmwareUpdate extends BaseMethod<DevFirmwareUpdateParams> {
+  init() {
+    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 res = await this.device.commands.typedCall(
+      'DevFirmwareUpdate',
+      PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
+      {
+        targets: normalizeFirmwareTargets(this.params),
+      },
+      PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,35 @@
+import { BaseMethod } from '../BaseMethod';
+import { buildTargets, buildTypes } from './helpers';
+
+import type { DevGetDeviceInfoParams } from './helpers';
+
+export default class DevGetDeviceInfo extends BaseMethod<DevGetDeviceInfoParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      targets: this.payload.targets,
+      types: this.payload.types,
+      targetHw: this.payload.targetHw,
+      targetFw: this.payload.targetFw,
+      targetBt: this.payload.targetBt,
+      targetSe1: this.payload.targetSe1,
+      targetSe2: this.payload.targetSe2,
+      targetSe3: this.payload.targetSe3,
+      targetSe4: this.payload.targetSe4,
+      targetStatus: this.payload.targetStatus,
+      includeVersion: this.payload.includeVersion,
+      includeBuildId: this.payload.includeBuildId,
+      includeHash: this.payload.includeHash,
+      includeSpecific: this.payload.includeSpecific,
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('DevGetDeviceInfo', 'DeviceInfo', {
+      targets: buildTargets(this.params),
+      types: buildTypes(this.params),
+    });
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DevGetFirmwareUpdateStatus extends BaseMethod {
+  init() {
+    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/DevGetOnboardingStatus.ts

@@ -0,0 +1,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class DevGetOnboardingStatus extends BaseMethod {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = undefined;
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'DevGetOnboardingStatus',
+      'DevOnboardingStatus',
+      {}
+    );
+    return Promise.resolve(res.message);
+  }
+}

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

@@ -0,0 +1,22 @@
+import { BaseMethod } from '../BaseMethod';
+import { normalizeRebootType } from './helpers';
+
+import type { DevRebootParams } from './helpers';
+
+export default class DevReboot extends BaseMethod<DevRebootParams> {
+  init() {
+    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,27 @@
+import { BaseMethod } from '../BaseMethod';
+
+import type { FactoryDeviceInfoSettingsParams } from './helpers';
+
+export default class FactoryDeviceInfoSettings extends BaseMethod<FactoryDeviceInfoSettingsParams> {
+  init() {
+    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,18 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FactoryGetDeviceInfo extends BaseMethod {
+  init() {
+    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/FilesystemFixPermission.ts

@@ -0,0 +1,14 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FilesystemFixPermission extends BaseMethod {
+  init() {
+    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,14 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class FilesystemFormat extends BaseMethod {
+  init() {
+    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,14 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class GetProtoVersion extends BaseMethod {
+  init() {
+    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,16 @@
+import { BaseMethod } from '../BaseMethod';
+
+export default class Ping extends BaseMethod<{ message?: string }> {
+  init() {
+    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);
+  }
+}