@onekeyfe/hd-core 1.1.18 → 1.1.19-alpha.1

package/src/data-manager/DataManager.ts

@@ -1,15 +1,19 @@
 import axios from 'axios';
 import semver from 'semver';
-import { EDeviceType } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
 import MessagesJSON from '../data/messages/messages.json';
 import MessagesLegacyV1JSON from '../data/messages/messages_legacy_v1.json';
 import {
-  getTimeStamp,
   getDeviceBLEFirmwareVersion,
   getDeviceFirmwareVersion,
   getDeviceType,
+  getFirmwareType,
   getFirmwareUpdateField,
+  getTimeStamp,
 } from '../utils';
+import { DeviceModelToTypes } from '../types';
+import { findLatestRelease, getReleaseChangelog, getReleaseStatus } from '../utils/release';
 
 import type {
   AssetsMap,
@@ -22,13 +26,37 @@ import type {
   IVersionArray,
   RemoteConfigResponse,
 } from '../types';
-import { DeviceModelToTypes } from '../types';
-import { findLatestRelease, getReleaseChangelog, getReleaseStatus } from '../utils/release';
 
-export type IFirmwareField = 'firmware' | 'firmware-v2' | 'firmware-v7';
+export const FIRMWARE_FIELDS = [
+  'firmware',
+  'firmware-v2',
+  'firmware-v7',
+  'firmware-btc-v7',
+] as const;
+
+export type IFirmwareField = (typeof FIRMWARE_FIELDS)[number];
 
 export type MessageVersion = 'latest' | 'v1';
 
+const FIRMWARE_FIELD_TYPE_MAP: Readonly<Record<IFirmwareField, EFirmwareType>> = {
+  firmware: EFirmwareType.Universal,
+  'firmware-v2': EFirmwareType.Universal,
+  'firmware-v7': EFirmwareType.Universal,
+  'firmware-btc-v7': EFirmwareType.BitcoinOnly,
+} as const;
+
+function getFirmwareTypeFromField(firmwareField: IFirmwareField): EFirmwareType {
+  const firmwareType = FIRMWARE_FIELD_TYPE_MAP[firmwareField];
+
+  // Explicit check for type safety
+  if (firmwareType === undefined) {
+    // Fallback to Universal for safety
+    return EFirmwareType.Universal;
+  }
+
+  return firmwareType;
+}
+
 export default class DataManager {
   static deviceMap: DeviceTypeMap = {
     [EDeviceType.Classic]: {
@@ -68,10 +96,14 @@ export default class DataManager {
 
   static lastCheckTimestamp = 0;
 
-  static getFirmwareStatus = (features: Features): IDeviceFirmwareStatus => {
+  static getFirmwareStatus = (
+    features: Features,
+    firmwareType: EFirmwareType
+  ): IDeviceFirmwareStatus => {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) return 'unknown';
 
+    const deviceFirmwareType = getFirmwareType(features);
     const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
     if (features.firmware_present === false) {
       return 'none';
@@ -81,9 +113,16 @@ export default class DataManager {
       return 'unknown';
     }
 
-    const firmwareUpdateField = getFirmwareUpdateField({ features, updateType: 'firmware' });
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+      firmwareType,
+    });
     const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
-    const currentVersion = deviceFirmwareVersion.join('.');
+    let currentVersion = deviceFirmwareVersion.join('.');
+    if (targetDeviceConfigList.length > 0 && deviceFirmwareType !== firmwareType) {
+      currentVersion = '0.0.0';
+    }
     return getReleaseStatus(targetDeviceConfigList, currentVersion);
   };
 
@@ -91,7 +130,15 @@ export default class DataManager {
    * Touch、Pro System UI Resource Update
    * ** Interval upgrade is not considered **
    */
-  static getSysResourcesLatestRelease = (features: Features, forcedUpdateRes?: boolean) => {
+  static getSysResourcesLatestRelease = ({
+    features,
+    forcedUpdateRes,
+    firmwareType,
+  }: {
+    features: Features;
+    forcedUpdateRes?: boolean;
+    firmwareType: EFirmwareType;
+  }) => {
     const deviceType = getDeviceType(features);
     const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
 
@@ -100,6 +147,7 @@ export default class DataManager {
     const firmwareUpdateField = getFirmwareUpdateField({
       features,
       updateType: 'firmware',
+      firmwareType,
     }) as IFirmwareField;
     const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
     const currentVersion = deviceFirmwareVersion.join('.');
@@ -116,7 +164,7 @@ export default class DataManager {
    * Touch、Pro System full UI Resource Update
    * ** Interval upgrade is not considered **
    */
-  static getSysFullResource = (features: Features) => {
+  static getSysFullResource = (features: Features, firmwareType: EFirmwareType) => {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) return undefined;
 
@@ -125,6 +173,7 @@ export default class DataManager {
     const firmwareUpdateField = getFirmwareUpdateField({
       features,
       updateType: 'firmware',
+      firmwareType,
     }) as IFirmwareField;
     const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
     const targetDeviceConfig = targetDeviceConfigList.filter(item => !!item.fullResource);
@@ -132,7 +181,7 @@ export default class DataManager {
     return findLatestRelease(targetDeviceConfig)?.fullResource;
   };
 
-  static getBootloaderResource = (features: Features) => {
+  static getBootloaderResource = (features: Features, firmwareType: EFirmwareType) => {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) throw new Error('Device type is unknown');
 
@@ -140,6 +189,7 @@ export default class DataManager {
     const firmwareUpdateField = getFirmwareUpdateField({
       features,
       updateType: 'firmware',
+      firmwareType,
     }) as IFirmwareField;
     const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
     if (targetDeviceConfigList.length === 0) {
@@ -152,13 +202,17 @@ export default class DataManager {
     return findLatestRelease(targetDeviceConfig)?.bootloaderResource;
   };
 
-  static getBootloaderTargetVersion = (features: Features): IVersionArray | undefined => {
+  static getBootloaderTargetVersion = (
+    features: Features,
+    firmwareType: EFirmwareType
+  ): IVersionArray | undefined => {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) return undefined;
 
     const firmwareUpdateField = getFirmwareUpdateField({
       features,
       updateType: 'firmware',
+      firmwareType,
     }) as IFirmwareField;
     const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
     const targetDeviceConfig = targetDeviceConfigList.filter(item => !!item.bootloaderResource);
@@ -166,7 +220,10 @@ export default class DataManager {
     return targetDeviceConfig?.[0]?.bootloaderVersion ?? undefined;
   };
 
-  static getBootloaderRelatedFirmwareVersion = (features: Features): IVersionArray | undefined => {
+  static getBootloaderRelatedFirmwareVersion = (
+    features: Features,
+    firmwareType: EFirmwareType
+  ): IVersionArray | undefined => {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) return undefined;
 
@@ -174,6 +231,7 @@ export default class DataManager {
     const firmwareUpdateField = getFirmwareUpdateField({
       features,
       updateType: 'firmware',
+      firmwareType,
     }) as IFirmwareField;
     const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
     const targetDeviceConfig = targetDeviceConfigList.filter(
@@ -183,7 +241,7 @@ export default class DataManager {
     return targetDeviceConfig?.[0]?.bootloaderRelatedFirmwareVersion ?? undefined;
   };
 
-  static getFirmwareChangelog = (features: Features) => {
+  static getFirmwareChangelog = (features: Features, firmwareType: EFirmwareType) => {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) return [];
 
@@ -192,6 +250,7 @@ export default class DataManager {
     const firmwareUpdateField = getFirmwareUpdateField({
       features,
       updateType: 'firmware',
+      firmwareType,
     }) as IFirmwareField;
     const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
 
@@ -207,13 +266,14 @@ export default class DataManager {
     return getReleaseChangelog(targetDeviceConfigList, currentVersion);
   };
 
-  static getFirmwareLatestRelease = (features: Features) => {
+  static getFirmwareLatestRelease = (features: Features, firmwareType: EFirmwareType) => {
     const deviceType = getDeviceType(features);
     if (deviceType === EDeviceType.Unknown) return undefined;
 
     const firmwareUpdateField = getFirmwareUpdateField({
       features,
       updateType: 'firmware',
+      firmwareType,
     }) as IFirmwareField;
     const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
 
@@ -221,7 +281,7 @@ export default class DataManager {
     if (!target) return target;
 
     if (!target.resource) {
-      const resource = this.getSysResourcesLatestRelease(features);
+      const resource = this.getSysResourcesLatestRelease({ features, firmwareType });
       return {
         ...target,
         resource,
@@ -278,6 +338,50 @@ export default class DataManager {
 
   static getBridgeChangelog = () => this.assets?.bridge.changelog;
 
+  private static enrichFirmwareReleaseInfo(
+    deviceData: DeviceTypeMap[keyof DeviceTypeMap] | undefined
+  ): DeviceTypeMap[keyof DeviceTypeMap] {
+    // Safety check: return default structure if input is undefined/null
+    if (!deviceData || typeof deviceData !== 'object') {
+      return {
+        firmware: [],
+        ble: [],
+      };
+    }
+
+    // Create a shallow copy to avoid mutating original data
+    const enrichedData = { ...deviceData };
+
+    FIRMWARE_FIELDS.forEach(field => {
+      const releases = enrichedData[field];
+
+      if (!releases || !Array.isArray(releases) || releases.length === 0) {
+        return; // Skip this field
+      }
+
+      // Add firmwareType to each release in this field
+      try {
+        enrichedData[field] = releases.map(release => {
+          // Safety checks:
+          if (!release || typeof release !== 'object' || !!release.firmwareType) {
+            return release; // Return as-is if invalid or already has firmwareType
+          }
+
+          const firmwareType = getFirmwareTypeFromField(field);
+
+          return {
+            ...release,
+            firmwareType,
+          };
+        });
+      } catch (error) {
+        console.error(`Error enriching firmware field "${field}":`, error);
+      }
+    });
+
+    return enrichedData;
+  }
+
   static async load(settings: ConnectSettings) {
     this.settings = settings;
     if (!settings.fetchConfig) {
@@ -296,12 +400,12 @@ export default class DataManager {
         }
       );
       this.deviceMap = {
-        [EDeviceType.Classic]: data.classic,
-        [EDeviceType.Classic1s]: data.classic1s,
-        [EDeviceType.ClassicPure]: data.classicpure,
-        [EDeviceType.Mini]: data.mini,
-        [EDeviceType.Touch]: data.touch,
-        [EDeviceType.Pro]: data.pro,
+        [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
+        [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
+        [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
+        [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
+        [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
+        [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
       };
       this.assets = {
         bridge: data.bridge,

package/src/device/Device.ts

@@ -24,6 +24,7 @@ import {
   fixFeaturesFirmwareVersion,
   getPassphraseStateWithRefreshDeviceInfo,
 } from '../utils/deviceFeaturesUtils';
+import { generateInstanceId } from '../utils/tracing';
 
 import type DeviceConnector from './DeviceConnector';
 // eslint-disable-next-line import/no-cycle
@@ -99,6 +100,15 @@ export class Device extends EventEmitter {
    */
   originalDescriptor: DeviceDescriptor;
 
+  sdkInstanceId?: string;
+
+  /**
+   * 设备实例唯一标识
+   */
+  instanceId: string;
+
+  createdAt: number;
+
   /**
    * 设备主 ID
    * 蓝牙连接时是设备的 UUID
@@ -158,14 +168,22 @@ export class Device extends EventEmitter {
 
   pendingCallbackPromise?: Deferred<void>;
 
-  constructor(descriptor: DeviceDescriptor) {
+  constructor(descriptor: DeviceDescriptor, sdkInstanceId?: string) {
     super();
     this.originalDescriptor = descriptor;
+    this.sdkInstanceId = sdkInstanceId;
+    this.instanceId = generateInstanceId('Device', this.sdkInstanceId);
+    this.createdAt = Date.now();
+    Log.debug(
+      `[Device] Created: ${this.instanceId}${
+        this.sdkInstanceId ? ` for SDK: ${this.sdkInstanceId}` : ''
+      }`
+    );
   }
 
-  static fromDescriptor(originalDescriptor: DeviceDescriptor) {
+  static fromDescriptor(originalDescriptor: DeviceDescriptor, sdkInstanceId?: string) {
     const descriptor = { ...originalDescriptor };
-    return new Device(descriptor);
+    return new Device(descriptor, sdkInstanceId);
   }
 
   // simplified object to pass via postMessage
@@ -183,6 +201,9 @@ export class Device extends EventEmitter {
       connectId: DataManager.isBleConnect(env) ? this.mainId || null : getDeviceUUID(this.features),
       /** Hardware ID, will not change at any time */
       uuid: getDeviceUUID(this.features),
+      sdkInstanceId: this.sdkInstanceId,
+      instanceId: this.instanceId,
+      createdAt: this.createdAt,
       deviceType,
       /** ID for current seeds, will clear after replace a new seed at device */
       deviceId: this.features.device_id || null,

package/src/device/DeviceCommands.ts

@@ -6,6 +6,11 @@ import { patchFeatures, getLogger, LoggerNames, getDeviceType } from '../utils';
 import type { Device } from './Device';
 import { DEVICE, type PassphraseRequestPayload } from '../events';
 import { DeviceModelToTypes } from '../types';
+import {
+  formatRequestContext,
+  generateInstanceId,
+  getActiveRequestsByDeviceInstance,
+} from '../utils/tracing';
 
 export type PassphrasePromptResponse = {
   passphrase?: string;
@@ -114,12 +119,17 @@ export const cancelDeviceWithInitialize = (device: Device) => {
 };
 
 const Log = getLogger(LoggerNames.DeviceCommands);
+const LogCore = getLogger(LoggerNames.Core);
 
 /**
  * The life cycle begins with the acquisition of the device and ends with the disposal device commands
  * acquire device -> create DeviceCommands -> release device -> dispose DeviceCommands
  */
 export class DeviceCommands {
+  instanceId: string;
+
+  currentResponseID?: number;
+
   device: Device;
 
   transport: Transport;
@@ -135,6 +145,9 @@ export class DeviceCommands {
     this.mainId = mainId;
     this.transport = TransportManager.getTransport();
     this.disposed = false;
+    this.instanceId = generateInstanceId('DeviceCommands', device.sdkInstanceId);
+
+    Log.debug(`[DeviceCommands] Created: ${this.instanceId}, device: ${this.device.instanceId}`);
   }
 
   async dispose(_cancelRequest: boolean) {
@@ -217,10 +230,10 @@ export class DeviceCommands {
       const promise = this.transport.call(this.mainId, type, msg) as any;
       this.callPromise = promise;
       const res = await promise;
-      Log.debug('[DeviceCommands] [call] Received', res.type);
+      LogCore.debug('[DeviceCommands] [call] Received', res.type);
       return res;
     } catch (error) {
-      Log.debug('[DeviceCommands] [call] Received error', error);
+      LogCore.debug('[DeviceCommands] [call] Received error', error);
       if (error.errorCode === HardwareErrorCode.BleDeviceBondError) {
         return {
           type: 'BleDeviceBondError',
@@ -500,7 +513,7 @@ export class DeviceCommands {
         cancelDeviceInPrompt(this.device, false)
           .then(onCancel => {
             const error = ERRORS.TypedError(
-              HardwareErrorCode.ActionCancelled,
+              HardwareErrorCode.CallQueueActionCancelled,
               `${DEVICE.PIN} canceled`
             );
             // onCancel not void
@@ -515,7 +528,15 @@ export class DeviceCommands {
             reject(error);
           });
 
-      if (this.device.listenerCount(DEVICE.PIN) > 0) {
+      const listenerCount = this.device.listenerCount(DEVICE.PIN);
+
+      Log.debug(`[${this.instanceId}] _promptPin called`, {
+        responseID: this.currentResponseID,
+        deviceInstanceId: this.device.instanceId,
+        listenerCount,
+      });
+
+      if (listenerCount > 0) {
         this.device.setCancelableAction(cancelAndReject);
         this.device.emit(DEVICE.PIN, this.device, type, (err, pin) => {
           this.device.clearCancelableAction();
@@ -526,11 +547,22 @@ export class DeviceCommands {
           }
         });
       } else {
-        console.warn('[DeviceCommands] [call] PIN callback not configured, cancelling request');
+        const activeRequests = getActiveRequestsByDeviceInstance(this.device.instanceId);
+        const errorInfo = {
+          commandsInstanceId: this.instanceId,
+          deviceInstanceId: this.device.instanceId,
+          currentResponseID: this.currentResponseID,
+          listenerCount,
+          activeRequests: activeRequests.map(formatRequestContext),
+        };
+
+        LogCore.error('[DeviceCommands] [call] PIN callback not configured, cancelling request', {
+          ...errorInfo,
+        });
         reject(
           ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            '_promptPin: PIN callback not configured'
+            `_promptPin: PIN callback not configured: ${JSON.stringify(errorInfo)}`
           )
         );
       }
@@ -543,7 +575,7 @@ export class DeviceCommands {
         cancelDeviceInPrompt(this.device, false)
           .then(onCancel => {
             const error = ERRORS.TypedError(
-              HardwareErrorCode.ActionCancelled,
+              HardwareErrorCode.CallQueueActionCancelled,
               `${DEVICE.PASSPHRASE} canceled`
             );
             // onCancel not void
@@ -574,7 +606,9 @@ export class DeviceCommands {
           }
         );
       } else {
-        Log.error('[DeviceCommands] [call] Passphrase callback not configured, cancelling request');
+        LogCore.error(
+          '[DeviceCommands] [call] Passphrase callback not configured, cancelling request'
+        );
         reject(
           ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,

package/src/events/device.ts

@@ -1,6 +1,6 @@
+import type { MessageFactoryFn } from './utils';
 import type { PROTO } from '../constants';
-import type { Features, KnownDevice as Device, SupportFeatures } from '../types/device';
-import { MessageFactoryFn } from './utils';
+import type { KnownDevice as Device, Features, SupportFeatures } from '../types/device';
 
 export const DEVICE_EVENT = 'DEVICE_EVENT';
 export const DEVICE = {

package/src/types/api/checkAllFirmwareRelease.ts

@@ -1,6 +1,8 @@
+import type { IBLEFirmwareReleaseInfo } from '../settings';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
+import type { Features } from '@onekeyfe/hd-transport';
 import type { CommonParams, Response } from '../params';
 import type { IDeviceBLEFirmwareStatus, IDeviceFirmwareStatus } from '../device';
-import { IBLEFirmwareReleaseInfo } from '../settings';
 
 export type FirmwareRelease = {
   shouldUpdate?: boolean;
@@ -18,10 +20,12 @@ export type AllFirmwareRelease = {
   ble: FirmwareRelease;
   bootloader?: FirmwareRelease;
   bridge?: FirmwareRelease;
+  features?: Features;
 };
 
 export type CheckAllFirmwareReleaseParams = {
   checkBridgeRelease?: boolean;
+  firmwareType?: EFirmwareType;
 };
 
 export declare function checkAllFirmwareRelease(

package/src/types/api/checkBootloaderRelease.ts

@@ -1,3 +1,4 @@
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
 
 export type CheckBootloaderReleaseResponse = {
@@ -7,9 +8,12 @@ export type CheckBootloaderReleaseResponse = {
   bootloaderMode: boolean;
 } | null;
 
+export type CheckBootloaderReleaseParams = {
+  willUpdateFirmwareVersion?: string;
+  firmwareType?: EFirmwareType;
+};
+
 export declare function checkBootloaderRelease(
   connectId?: string,
-  params?: CommonParams & {
-    willUpdateFirmwareVersion?: string;
-  }
+  params?: CommonParams & CheckBootloaderReleaseParams
 ): Response<CheckBootloaderReleaseResponse>;

package/src/types/api/checkFirmwareRelease.ts

@@ -1,6 +1,7 @@
+import type { IFirmwareReleaseInfo } from '../settings';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Response } from '../params';
 import type { IDeviceFirmwareStatus } from '../device';
-import { IFirmwareReleaseInfo } from '../settings';
 
 type FirmwareRelease = {
   status: IDeviceFirmwareStatus;
@@ -12,4 +13,11 @@ type FirmwareRelease = {
   bootloaderMode: boolean;
 };
 
-export declare function checkFirmwareRelease(connectId?: string): Response<FirmwareRelease>;
+export type CheckFirmwareReleaseParams = {
+  firmwareType?: EFirmwareType;
+};
+
+export declare function checkFirmwareRelease(
+  connectId?: string,
+  params?: CheckFirmwareReleaseParams
+): Response<FirmwareRelease>;

package/src/types/api/deviceFullyUploadResource.ts

@@ -1,6 +1,12 @@
-import { Success } from '@onekeyfe/hd-transport';
+import type { Success } from '@onekeyfe/hd-transport';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
 
+export type DeviceFullyUploadResourceParams = {
+  binary?: ArrayBuffer;
+  firmwareType?: EFirmwareType;
+};
+
 export declare function deviceFullyUploadResource(
   connectId: string,
   params: CommonParams & {

package/src/types/api/deviceUpdateBootloader.ts

@@ -1,9 +1,13 @@
-import { Success } from '@onekeyfe/hd-transport';
+import type { Success } from '@onekeyfe/hd-transport';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Response } from '../params';
 
+export type DeviceUpdateBootloaderParams = {
+  binary?: ArrayBuffer;
+  firmwareType?: EFirmwareType;
+};
+
 export declare function deviceUpdateBootloader(
   connectId: string,
-  params?: {
-    binary?: ArrayBuffer;
-  }
+  params?: DeviceUpdateBootloaderParams
 ): Response<Success>;

package/src/types/api/firmwareUpdate.ts

@@ -1,3 +1,4 @@
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { PROTO } from '../../constants';
 import type { Params, Response } from '../params';
 
@@ -10,10 +11,10 @@ export interface FirmwareUpdateBinaryParams {
 
 export interface FirmwareUpdateParams {
   version?: number[];
-  btcOnly?: boolean;
   updateType: IUpdateType;
   forcedUpdateRes?: boolean;
   isUpdateBootloader?: boolean;
+  firmwareType?: EFirmwareType;
 }
 
 export declare function firmwareUpdate(
@@ -50,6 +51,8 @@ export interface FirmwareUpdateV3Params {
   resourceBinary?: ArrayBuffer;
   forcedUpdateRes?: boolean;
 
+  firmwareType?: EFirmwareType;
+
   platform: IPlatform;
 }