@onekeyfe/hd-core 1.1.27-alpha.4 → 1.1.27-alpha.40

package/src/api/BaseMethod.ts

@@ -8,18 +8,16 @@ import { supportInputPinOnSoftware, supportModifyHomescreen } from '../utils/dev
 import { createDeviceMessage } from '../events/device';
 import { UI_REQUEST } from '../constants/ui-request';
 import { DEVICE, FIRMWARE, createFirmwareMessage, createUiMessage } from '../events';
-import { getHDPath, toHardened } from './helpers/pathUtils';
 import { getBleFirmwareReleaseInfo, getFirmwareReleaseInfo } from './firmware/releaseHelper';
 import {
   LoggerNames,
   getDeviceFirmwareVersion,
-  getDeviceType,
   getFirmwareType,
   getLogger,
   getMethodVersionRange,
+  isMethodVersionRangeUnsupported,
 } from '../utils';
 import { generateInstanceId } from '../utils/tracing';
-import { DeviceModelToTypes } from '../types';
 
 import type { Device } from '../device/Device';
 import type DeviceConnector from '../device/DeviceConnector';
@@ -30,31 +28,6 @@ import type { CoreContext } from '../core';
 
 const Log = getLogger(LoggerNames.Method);
 
-const isEvmLedgerLegacyPathWithHighIndex = (path: unknown) => {
-  let addressN: number[] | undefined;
-  if (typeof path === 'string') {
-    try {
-      addressN = getHDPath(path);
-    } catch {
-      return false;
-    }
-  } else if (Array.isArray(path)) {
-    addressN = path.map((item: unknown) => Number(item));
-  }
-
-  return (
-    Array.isArray(addressN) &&
-    addressN.length === 4 &&
-    addressN[0] === toHardened(44) &&
-    addressN[1] === toHardened(60) &&
-    addressN[2] === toHardened(0) &&
-    addressN[3] > 1 &&
-    addressN[3] < toHardened(0)
-  );
-};
-
-const EVM_LEDGER_LEGACY_METHODS = ['evmGetAddress', 'evmGetPublicKey'];
-
 export abstract class BaseMethod<Params = undefined> {
   responseID: number;
 
@@ -133,28 +106,6 @@ export abstract class BaseMethod<Params = undefined> {
    */
   skipForceUpdateCheck = false;
 
-  /** Allow skipping Initialize (sign methods only; never getAddress/getPublicKey). @default false */
-  allowUsePreInitialize = false;
-
-  /** Pre-warm signal method (fire-and-forget; core dedups + hangs up). @default false */
-  isPreWarmSignal = false;
-
-  /** Pre-warm dedup TTL (ms) */
-  preWarmTtl = 60 * 1000;
-
-  /** Pre-warm dedup key: connectId + passphraseState + method name */
-  getPreWarmKey(): string {
-    const payload = (this.payload ?? {}) as {
-      connectId?: string;
-      passphraseState?: string;
-    };
-    return [
-      this.connectId ?? payload.connectId ?? '',
-      payload.passphraseState ?? '',
-      this.name,
-    ].join('|');
-  }
-
   /**
    * 严格检查设备是否支持该方法，不支持则抛出错误
    * @experiment 默认不严格检查，如果需要严格检查，则需要设置为 true
@@ -167,8 +118,6 @@ export abstract class BaseMethod<Params = undefined> {
 
   context?: CoreContext;
 
-  temporarySafetyCheckPrompted = false;
-
   constructor(message: { id?: number; payload: any }) {
     const { payload } = message;
     this.name = payload.method;
@@ -274,6 +223,10 @@ export abstract class BaseMethod<Params = undefined> {
       type => getVersionRange()[type]
     );
 
+    if (isMethodVersionRangeUnsupported(versionRange)) {
+      throw createDeviceNotSupportMethodError(this.name, getFirmwareType(this.device.features));
+    }
+
     if (!versionRange) {
       if (options?.strictCheckDeviceSupport) {
         throw createDeviceNotSupportMethodError(this.name, getFirmwareType(this.device.features));
@@ -292,32 +245,11 @@ export abstract class BaseMethod<Params = undefined> {
     }
   }
 
-  private shouldPromptSafetyCheckForEvmLedgerLegacyPath() {
-    if (!EVM_LEDGER_LEGACY_METHODS.includes(this.name)) {
-      return false;
-    }
-
-    const deviceType = getDeviceType(this.device.features);
-    if (!DeviceModelToTypes.model_touch.includes(deviceType)) {
-      return false;
-    }
-
-    const paths = Array.isArray(this.payload?.bundle)
-      ? this.payload.bundle.map((item: { path?: unknown }) => item?.path)
-      : [this.payload?.path];
-
-    return paths.some(isEvmLedgerLegacyPathWithHighIndex);
-  }
-
   /**
-   * Automatic check safety_check level for selected calls that require temporary relaxed checks.
-   * @returns whether a temporary safety check prompt was applied.
+   * Automatic check safety_check level for Kovan, Ropsten, Rinkeby, Goerli test networks.
+   * @returns {void}
    */
   async checkSafetyLevelOnTestNet() {
-    if (this.temporarySafetyCheckPrompted) {
-      return false;
-    }
-
     let checkFlag = false;
     // 3 - Ropsten, 4 - Rinkeby, 5 - Goerli, 420 - Optimism Goerli, 11155111 - zkSync Sepolia
     if (
@@ -326,19 +258,12 @@ export abstract class BaseMethod<Params = undefined> {
     ) {
       checkFlag = true;
     }
-    if (this.shouldPromptSafetyCheckForEvmLedgerLegacyPath()) {
-      checkFlag = true;
-    }
     if (checkFlag && this.device.features?.safety_checks === 'Strict') {
       Log.debug('will change safety_checks level');
       await this.device.commands.typedCall('ApplySettings', 'Success', {
         safety_checks: 'PromptTemporarily',
       });
-      this.temporarySafetyCheckPrompted = true;
-      return true;
     }
-
-    return false;
   }
 
   dispose() {}

package/src/api/DirList.ts

@@ -0,0 +1,29 @@
+import { BaseMethod } from './BaseMethod';
+import {
+  validateNonEmptyString,
+  validateOptionalNonNegativeInteger,
+} from './helpers/filesystemValidation';
+
+export type DirListParams = {
+  path: string;
+  depth?: number;
+};
+
+export default class DirList extends BaseMethod<DirListParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      path: validateNonEmptyString(this.payload.path, 'path'),
+      depth: validateOptionalNonNegativeInteger(this.payload.depth, 'depth'),
+    };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemDirList', 'FilesystemDir', {
+      path: this.params.path,
+      depth: this.params.depth,
+    });
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/DirMake.ts

@@ -0,0 +1,21 @@
+import { BaseMethod } from './BaseMethod';
+import { validateNonEmptyString } from './helpers/filesystemValidation';
+
+export type DirMakeParams = {
+  path: string;
+};
+
+export default class DirMake extends BaseMethod<DirMakeParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { path: validateNonEmptyString(this.payload.path, 'path') };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemDirMake', 'Success', {
+      path: this.params.path,
+    });
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/DirRemove.ts

@@ -0,0 +1,21 @@
+import { BaseMethod } from './BaseMethod';
+import { validateNonEmptyString } from './helpers/filesystemValidation';
+
+export type DirRemoveParams = {
+  path: string;
+};
+
+export default class DirRemove extends BaseMethod<DirRemoveParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { path: validateNonEmptyString(this.payload.path, 'path') };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemDirRemove', 'Success', {
+      path: this.params.path,
+    });
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/FileDelete.ts

@@ -0,0 +1,21 @@
+import { BaseMethod } from './BaseMethod';
+import { validateNonEmptyString } from './helpers/filesystemValidation';
+
+export type FileDeleteParams = {
+  path: string;
+};
+
+export default class FileDelete extends BaseMethod<FileDeleteParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { path: validateNonEmptyString(this.payload.path, 'path') };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall('FilesystemFileDelete', 'Success', {
+      path: this.params.path,
+    });
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/FileRead.ts

@@ -0,0 +1,165 @@
+import {
+  PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
+  PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
+} from '@onekeyfe/hd-transport';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { BaseMethod } from './BaseMethod';
+import {
+  validateNonEmptyString,
+  validateNonNegativeInteger,
+  validateOptionalNonNegativeInteger,
+  validateOptionalPercentage,
+} from './helpers/filesystemValidation';
+import { hexToBytes, isHexString, stripHexPrefix } from './helpers/hexUtils';
+import { DataManager } from '../data-manager';
+
+export type FileReadParams = {
+  path: string;
+  offset?: number;
+  totalSize?: number;
+  chunkLen?: number;
+  uiPercentage?: number;
+};
+
+const MIN_FILE_READ_CHUNK_SIZE = 64;
+
+function getProtocolV2FileReadChunkLimit() {
+  const env = DataManager.getSettings('env');
+  if (env && DataManager.isBleConnect(env)) {
+    return PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+  }
+  return PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+
+function normalizeChunkSize(value: unknown, maxChunkSize: number): number {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) return maxChunkSize;
+  return Math.min(Math.max(Math.floor(numeric), MIN_FILE_READ_CHUNK_SIZE), maxChunkSize);
+}
+
+function toFiniteNumber(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string') {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : undefined;
+  }
+  if (value && typeof value === 'object') {
+    const longLike = value as { toNumber?: () => number };
+    if (typeof longLike.toNumber === 'function') {
+      const numeric = longLike.toNumber();
+      return Number.isFinite(numeric) ? numeric : undefined;
+    }
+  }
+  return undefined;
+}
+
+function toUint8Array(value: unknown): Uint8Array {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (typeof value === 'string') {
+    const hex = stripHexPrefix(value);
+    if (!hex) return new Uint8Array(0);
+    if (!isHexString(hex) || hex.length % 2 !== 0) return new Uint8Array(0);
+    return hexToBytes(hex);
+  }
+  return new Uint8Array(0);
+}
+
+export default class FileRead extends BaseMethod<FileReadParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    const path = validateNonEmptyString(this.payload.path, 'path');
+    this.params = {
+      path,
+      offset: validateNonNegativeInteger(this.payload.offset, 'offset', 0),
+      totalSize: validateNonNegativeInteger(this.payload.totalSize, 'totalSize', 0),
+      chunkLen: validateOptionalNonNegativeInteger(this.payload.chunkLen, 'chunkLen'),
+      uiPercentage: validateOptionalPercentage(this.payload.uiPercentage, 'uiPercentage'),
+    };
+  }
+
+  async run() {
+    const startOffset = this.params.offset ?? 0;
+    const requestedLength = Number(this.params.totalSize);
+    const chunkSize = normalizeChunkSize(this.params.chunkLen, getProtocolV2FileReadChunkLimit());
+    let totalLength = Number.isFinite(requestedLength) && requestedLength > 0 ? requestedLength : 0;
+
+    if (totalLength === 0) {
+      const pathInfoRes = await this.device.commands.typedCall(
+        'FilesystemPathInfoQuery',
+        'FilesystemPathInfo',
+        {
+          path: this.params.path,
+        }
+      );
+      const fileSize = toFiniteNumber(pathInfoRes.message?.size);
+      if (!pathInfoRes.message?.exist || pathInfoRes.message?.directory) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileRead path is not a file: ${this.params.path}`
+        );
+      }
+      if (fileSize === undefined || fileSize < startOffset) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileRead invalid offset ${startOffset} for ${this.params.path}`
+        );
+      }
+      totalLength = fileSize - startOffset;
+    }
+
+    const chunks: Uint8Array[] = [];
+    let read = 0;
+    let lastMessage: Record<string, unknown> | undefined;
+
+    while (read < totalLength) {
+      const readLen = Math.min(chunkSize, totalLength - read);
+      const offset = startOffset + read;
+      const progress =
+        this.params.uiPercentage ??
+        Math.min(Math.ceil(((read + readLen) / Math.max(totalLength, 1)) * 100), 99);
+      const res = await this.device.commands.typedCall('FilesystemFileRead', 'FilesystemFile', {
+        file: {
+          path: this.params.path,
+          offset,
+          total_size: 0,
+        },
+        chunk_len: readLen,
+        ui_percentage: progress,
+      });
+      const data = toUint8Array(res.message?.data);
+      lastMessage = res.message;
+
+      if (data.byteLength === 0) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileRead received empty data at offset ${offset}`
+        );
+      }
+
+      chunks.push(data);
+      read += data.byteLength;
+    }
+
+    const combined = new Uint8Array(read);
+    let cursor = 0;
+    chunks.forEach(chunk => {
+      combined.set(chunk, cursor);
+      cursor += chunk.byteLength;
+    });
+
+    return Promise.resolve({
+      ...lastMessage,
+      path: this.params.path,
+      offset: startOffset,
+      total_size: totalLength,
+      data: combined,
+      chunks: chunks.length,
+    });
+  }
+}

package/src/api/FileWrite.ts

@@ -0,0 +1,203 @@
+import {
+  PROTOCOL_V2_BLE_FILE_CHUNK_SIZE,
+  PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE,
+} from '@onekeyfe/hd-transport';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { BaseMethod } from './BaseMethod';
+import {
+  validateNonEmptyString,
+  validateNonNegativeInteger,
+  validateOptionalNonNegativeInteger,
+  validateOptionalPercentage,
+  validateRequiredData,
+} from './helpers/filesystemValidation';
+import { UI_REQUEST, createUiMessage } from '../events/ui-request';
+import { DataManager } from '../data-manager';
+
+export type FileWriteParams = {
+  path: string;
+  offset?: number;
+  totalSize?: number;
+  data: ArrayBuffer | Uint8Array | Blob | string;
+  chunkSize?: number;
+  chunkLen?: number;
+  overwrite?: boolean;
+  append?: boolean;
+  uiPercentage?: number;
+};
+
+const MIN_FILE_CHUNK_SIZE = 64;
+
+function getProtocolV2FileChunkLimit() {
+  const env = DataManager.getSettings('env');
+  if (env && DataManager.isBleConnect(env)) {
+    return PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+  }
+  return PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+
+async function dataToUint8Array(data: FileWriteParams['data'] | Blob): Promise<Uint8Array> {
+  if (typeof data === 'string') {
+    return new TextEncoder().encode(data);
+  }
+
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+
+  if (typeof Blob !== 'undefined' && data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+
+  throw ERRORS.TypedError(
+    HardwareErrorCode.CallMethodInvalidParameter,
+    'Unsupported FilesystemFileWrite data'
+  );
+}
+
+function normalizeChunkSize(value: unknown, maxChunkSize: number): number {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) return maxChunkSize;
+  return Math.min(Math.max(Math.floor(numeric), MIN_FILE_CHUNK_SIZE), maxChunkSize);
+}
+
+function getConfirmedProgress(
+  processedByte: number,
+  totalSize: number,
+  written: number,
+  dataLength: number
+) {
+  if (Number.isFinite(processedByte) && Number.isFinite(totalSize) && totalSize > 0) {
+    if (processedByte >= totalSize) return 100;
+    return Math.min(Math.max(Math.floor((processedByte / totalSize) * 100), 0), 99);
+  }
+  if (dataLength > 0) {
+    if (written >= dataLength) return 100;
+    return Math.min(Math.max(Math.floor((written / dataLength) * 100), 0), 99);
+  }
+  return 100;
+}
+
+export default class FileWrite extends BaseMethod<FileWriteParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    validateRequiredData(this.payload.data, 'data');
+    const path = validateNonEmptyString(this.payload.path, 'path');
+    const offset = validateNonNegativeInteger(this.payload.offset, 'offset', 0);
+    this.params = {
+      path,
+      offset,
+      totalSize: validateNonNegativeInteger(this.payload.totalSize, 'totalSize', 0),
+      data: this.payload.data,
+      chunkSize: validateOptionalNonNegativeInteger(this.payload.chunkSize, 'chunkSize'),
+      chunkLen: validateOptionalNonNegativeInteger(this.payload.chunkLen, 'chunkLen'),
+      overwrite: this.payload.overwrite ?? offset === 0,
+      append: this.payload.append ?? false,
+      uiPercentage: validateOptionalPercentage(this.payload.uiPercentage, 'uiPercentage'),
+    };
+  }
+
+  async run() {
+    const data = await dataToUint8Array(this.params.data);
+    const dataLength = data.byteLength;
+    const offsetValue = Number(this.params.offset ?? 0);
+    const startOffset = Number.isFinite(offsetValue) && offsetValue > 0 ? offsetValue : 0;
+    const payloadTotalSize = Number(this.params.totalSize);
+    const totalSize =
+      Number.isFinite(payloadTotalSize) && payloadTotalSize > 0
+        ? payloadTotalSize
+        : startOffset + dataLength;
+
+    if (totalSize < startOffset + dataLength) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `FilesystemFileWrite totalSize ${totalSize} is smaller than offset + data length ${
+          startOffset + dataLength
+        }`
+      );
+    }
+
+    const chunkSize = normalizeChunkSize(
+      this.params.chunkSize ?? this.params.chunkLen,
+      getProtocolV2FileChunkLimit()
+    );
+    const overwrite = this.params.overwrite ?? false;
+    const append = this.params.append ?? false;
+    let written = 0;
+    let chunkIndex = 0;
+    let lastMessage: Record<string, unknown> | undefined;
+    const startTime = Date.now();
+
+    while (written < dataLength) {
+      const chunkEnd = Math.min(written + chunkSize, dataLength);
+      const chunk = data.slice(written, chunkEnd);
+      const offset = startOffset + written;
+      const isFirstChunk = chunkIndex === 0;
+      const progress =
+        this.params.uiPercentage ??
+        Math.min(Math.ceil(((written + chunk.byteLength) / dataLength) * 100), 99);
+
+      const res = await this.device.commands.typedCall('FilesystemFileWrite', 'FilesystemFile', {
+        file: {
+          path: this.params.path,
+          offset,
+          total_size: totalSize,
+          data: chunk,
+        },
+        overwrite: isFirstChunk ? overwrite : false,
+        append,
+        ui_percentage: progress,
+      });
+
+      lastMessage = res.message;
+      const processedByte = Number(res.message?.processed_byte);
+      if (Number.isFinite(processedByte) && processedByte > offset) {
+        written = processedByte - startOffset;
+      } else {
+        written += chunk.byteLength;
+      }
+
+      if (written > dataLength) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `FilesystemFileWrite invalid processed_byte ${processedByte}`
+        );
+      }
+
+      const confirmedProcessedByte =
+        Number.isFinite(processedByte) && processedByte > offset
+          ? processedByte
+          : startOffset + written;
+      if (typeof this.postMessage === 'function') {
+        const elapsedMs = Date.now() - startTime;
+        const transferredBytes = Math.min(written, dataLength);
+        this.postMessage(
+          createUiMessage(UI_REQUEST.DEVICE_PROGRESS, {
+            progress: getConfirmedProgress(confirmedProcessedByte, totalSize, written, dataLength),
+            transferredBytes,
+            totalBytes: dataLength,
+            rateBytesPerSecond:
+              elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
+            elapsedMs,
+          })
+        );
+      }
+      chunkIndex += 1;
+    }
+
+    return Promise.resolve({
+      ...lastMessage,
+      path: this.params.path,
+      offset: startOffset,
+      total_size: totalSize,
+      processed_byte: startOffset + written,
+      chunks: chunkIndex,
+    });
+  }
+}

package/src/api/FirmwareUpdateV3.ts

@@ -79,6 +79,20 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   async run() {
+    if (this.device.originalDescriptor?.protocolType === 'V2') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 firmware update must use firmwareUpdateV4'
+      );
+    }
+    Log.debug('FirmwareUpdateV3 strategy: Protocol V1');
+    return this.runProtocolV1();
+  }
+
+  /**
+   * Protocol V1 firmware update strategy for existing Pro devices.
+   */
+  private async runProtocolV1() {
     const { device } = this;
     const { features } = device;
 
@@ -251,6 +265,8 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+    const transferStartTime = Date.now();
+
     // Process resource zip contents
     if (resourceBinary) {
       const file = await JSZip.loadAsync(resourceBinary);
@@ -264,6 +280,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
             filePath: `0:res/${name}`,
             processedSize,
             totalSize,
+            transferStartTime,
           });
         }
       }
@@ -275,6 +292,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
         filePath: `0:boot/bootloader.bin`,
         processedSize,
         totalSize,
+        transferStartTime,
       });
     }
 
@@ -287,16 +305,15 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
           filePath: `0:updates/${fwbinary.fileName}`,
           processedSize,
           totalSize,
+          transferStartTime,
         });
       }
     }
 
-    // trigger firmware update, support folder updates
+    // trigger firmware update
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
-      await this.startEmmcFirmwareUpdate({
-        path: '0:updates',
-      });
+      await this.startEmmcFirmwareUpdate({ path: '0:updates' });
     } catch (error) {
       Log.error('triggerFirmwareUpdateEmmc error: ', error);
       // Re-throw errors with specific error codes that should not be ignored