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

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/GetPassphraseState.ts

@@ -1,7 +1,8 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
+import { getDeviceType } from '../utils/deviceInfoUtils';
 import { BaseMethod } from './BaseMethod';
 
 export default class GetPassphraseState extends BaseMethod {
@@ -14,9 +15,20 @@ export default class GetPassphraseState extends BaseMethod {
     if (!this.device.features)
       return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
 
-    const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(this.device);
+    const { passphraseState, newSession, unlockedAttachPin } =
+      await getPassphraseStateWithRefreshDeviceInfo(this.device);
 
     const { features } = this.device;
+    const isPro2 = getDeviceType(features) === EDeviceType.Pro2;
+
+    if (isPro2) {
+      return Promise.resolve({
+        passphrase_state: passphraseState,
+        session_id: newSession ?? features?.session_id ?? undefined,
+        unlocked_attach_pin: unlockedAttachPin,
+        passphrase_protection: features?.passphrase_protection ?? null,
+      });
+    }
 
     // refresh device info
     if (features && features.passphrase_protection === true) {

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]
@@ -491,9 +492,20 @@ function handleSkippableHardwareError(
   method: BaseMethod
 ): HardwareError | undefined {
   let error: HardwareError | undefined;
+  const skipMethodSupportCheck = shouldSkipMethodSupportCheck(
+    device.features,
+    device.originalDescriptor?.protocolType
+  );
 
   if (e instanceof HardwareError && e.errorCode !== HardwareErrorCode.RuntimeError) {
     const { errorCode } = e;
+    if (
+      skipMethodSupportCheck &&
+      (errorCode === HardwareErrorCode.CallMethodNeedUpgradeFirmware ||
+        errorCode === HardwareErrorCode.DeviceNotSupportMethod)
+    ) {
+      return undefined;
+    }
     if (errorCode === HardwareErrorCode.CallMethodNeedUpgradeFirmware) {
       error = e;
     } else if (errorCode === HardwareErrorCode.DeviceNotSupportMethod) {
@@ -503,6 +515,10 @@ function handleSkippableHardwareError(
     e.message?.includes('Failure_UnexpectedMessage') ||
     e.message?.includes('Failure_UnknownMessage')
   ) {
+    if (skipMethodSupportCheck) {
+      return undefined;
+    }
+
     const versionRange = getMethodVersionRange(
       device.features,
       type => method.getVersionRange()[type]

package/src/api/conflux/ConfluxSignTransaction.ts

@@ -34,7 +34,7 @@ export default class ConfluxSignTransaction extends BaseMethod {
 
     // check if transaction is valid
     const schema: SchemaParam[] = [
-      { name: 'to', type: 'hexString', required: true },
+      { name: 'to', type: 'string', required: true },
       { name: 'value', type: 'hexString', required: true },
       { name: 'gasLimit', type: 'hexString', required: true },
       { name: 'gasPrice', type: 'hexString', required: true },
@@ -47,7 +47,10 @@ export default class ConfluxSignTransaction extends BaseMethod {
 
     validateParams(tx, schema);
 
-    this.formattedTx = formatAnyHex(tx);
+    this.formattedTx = {
+      ...formatAnyHex(tx),
+      to: tx.to,
+    };
   }
 
   processTxRequest = async (request: ConfluxTxRequest, data: string): Promise<ConfluxSignedTx> => {

package/src/api/device/DeviceRebootToBoardloader.ts

@@ -1,3 +1,5 @@
+import { DeviceRebootType } 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 DeviceReboot with reboot_type enum.
+    if (this.device.originalDescriptor?.protocolType === 'V2') {
+      const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
+        reboot_type: DeviceRebootType.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 { DeviceRebootType } 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 DeviceReboot with reboot_type enum.
+    if (this.device.originalDescriptor?.protocolType === 'V2') {
+      const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
+        reboot_type: DeviceRebootType.Bootloader,
+      });
+      return Promise.resolve(res.message);
+    }
 
+    const res = await this.device.commands.typedCall('RebootToBootloader', 'Success');
     return Promise.resolve(res.message);
   }
 }

package/src/api/dynex/DnxGetAddress.ts

@@ -1,7 +1,10 @@
+import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { getFirmwareType } from '../../utils';
 
 import type { DnxGetAddress as HardwareDnxGetAddress } from '@onekeyfe/hd-transport';
 import type { DnxAddress, DnxGetAddressParams } from '../../types';
@@ -47,6 +50,10 @@ export default class DnxGetAddress extends BaseMethod<HardwareDnxGetAddress[]> {
   }
 
   async run() {
+    if (this.device.originalDescriptor?.protocolType === 'V2') {
+      throw createDeviceNotSupportMethodError(this.name, getFirmwareType(this.device.features));
+    }
+
     const responses: DnxAddress[] = [];
 
     for (let i = 0; i < this.params.length; i++) {

package/src/api/dynex/DnxSignTransaction.ts

@@ -1,8 +1,11 @@
+import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { stripHexPrefix } from '../helpers/hexUtils';
+import { getFirmwareType } from '../../utils';
 
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 import type { DnxSignature } from '../../types';
@@ -115,6 +118,10 @@ export default class DnxSignTransaction extends BaseMethod<DnxSignTx> {
   }
 
   async run() {
+    if (this.device.originalDescriptor?.protocolType === 'V2') {
+      throw createDeviceNotSupportMethodError(this.name, getFirmwareType(this.device.features));
+    }
+
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
 
     const res = await this.device.commands.typedCall('DnxSignTx', 'DnxInputRequest', {

package/src/api/evm/EVMGetAddress.ts

@@ -44,7 +44,7 @@ export default class EvmGetAddress extends BaseMethod<EthereumGetAddressOneKey[]
   }
 
   async getEvmAddress(param: EthereumGetAddressOneKey) {
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'protocolV1Legacy') {
       return getAddressLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         param,

package/src/api/evm/EVMGetPublicKey.ts

@@ -57,7 +57,7 @@ export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneK
   }
 
   getEvmPublicKey(param: EthereumGetPublicKey) {
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'protocolV1Legacy') {
       return getPublicKeyLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         param,

package/src/api/evm/EVMSignMessage.ts

@@ -34,7 +34,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumSignMessageOneKey
   }
 
   async run() {
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'protocolV1Legacy') {
       return signMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

package/src/api/evm/EVMSignTransaction.ts

@@ -120,7 +120,7 @@ export default class EVMSignTransaction extends BaseMethod {
 
     if (formattedTx == null) throw ERRORS.TypedError('Runtime', 'formattedTx is not set');
 
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'protocolV1Legacy') {
       return signTransactionLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         addressN,

package/src/api/evm/EVMSignTypedData.ts

@@ -260,8 +260,8 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     let supportTrezor = false;
     let response: MessageResponse<MessageKey>;
-    switch (TransportManager.getMessageVersion()) {
-      case 'v1':
+    switch (TransportManager.getProtocolV1MessageSchema()) {
+      case 'protocolV1Legacy':
         supportTrezor = true;
         response = await signTypedDataLegacyV1({
           typedCall: this.device.commands.typedCall.bind(this.device.commands),
@@ -272,7 +272,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         });
         break;
 
-      case 'latest':
+      case 'protocolV1Current':
       default:
         supportTrezor = false;
         response = await signTypedData({
@@ -308,8 +308,8 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
   }) {
     if (!domainHash) throw ERRORS.TypedError('Runtime', 'domainHash is required');
 
-    switch (TransportManager.getMessageVersion()) {
-      case 'v1':
+    switch (TransportManager.getProtocolV1MessageSchema()) {
+      case 'protocolV1Legacy':
         return signTypedHashLegacyV1({
           typedCall,
           addressN,
@@ -319,7 +319,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
           device: this.device,
         });
 
-      case 'latest':
+      case 'protocolV1Current':
       default:
         return signTypedHash({
           typedCall,

package/src/api/evm/EVMVerifyMessage.ts

@@ -31,7 +31,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessageOneK
   }
 
   async run() {
-    if (TransportManager.getMessageVersion() === 'v1') {
+    if (TransportManager.getProtocolV1MessageSchema() === 'protocolV1Legacy') {
       return verifyMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

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/helpers/batchGetPublickeys.ts

@@ -7,7 +7,7 @@ import {
 import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
 import { isEqualBip44CoinType } from './pathUtils';
 import { splitArray } from '../../utils/arrayUtils';
-import { getDeviceType, getFirmwareType } from '../../utils';
+import { getDeviceType, getFirmwareType, shouldSkipMethodSupportCheck } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 
 import type { EcdsaPublicKeys, Path } from '@onekeyfe/hd-transport';
@@ -28,7 +28,9 @@ export async function batchGetPublickeys(
     throw TypedError(HardwareErrorCode.ForbiddenKeyPath, 'Path length must be greater than 3');
   }
 
-  const supportsBatchPublicKey = supportBatchPublicKey(device.features, options);
+  const supportsBatchPublicKey =
+    shouldSkipMethodSupportCheck(device.features, device.originalDescriptor?.protocolType) ||
+    supportBatchPublicKey(device.features, options);
   if (!supportsBatchPublicKey) {
     throw createDeviceNotSupportMethodError('BatchGetPublickeys', getFirmwareType(device.features));
   }

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 deviceReboot } from './protocol-v2/DeviceReboot';
+export { default as deviceGetDeviceInfo } from './protocol-v2/DeviceGetDeviceInfo';
+export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
+export { default as deviceFirmwareUpdate } from './protocol-v2/DeviceFirmwareUpdate';
+export { default as deviceGetFirmwareUpdateStatus } from './protocol-v2/DeviceGetFirmwareUpdateStatus';
+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/DeviceFirmwareUpdate.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 { DeviceFirmwareUpdateParams } from './helpers';
+
+export default class DeviceFirmwareUpdate extends BaseMethod<DeviceFirmwareUpdateParams> {
+  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(
+      'DeviceFirmwareUpdate',
+      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/DeviceGetDeviceInfo.ts

@@ -0,0 +1,35 @@
+import { BaseMethod } from '../BaseMethod';
+import { buildTargets, buildTypes } from './helpers';
+
+import type { DeviceGetDeviceInfoParams } from './helpers';
+
+export default class DeviceGetDeviceInfo extends BaseMethod<DeviceGetDeviceInfoParams> {
+  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('DeviceGetDeviceInfo', 'DeviceInfo', {
+      targets: buildTargets(this.params),
+      types: buildTypes(this.params),
+    });
+    return Promise.resolve(res.message);
+  }
+}