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

package/src/api/firmware/getBinary.ts

@@ -1,17 +1,21 @@
 import semver from 'semver';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { Features } from '../../types';
+
 import { getDeviceType, httpRequest } from '../../utils';
 import { DataManager } from '../../data-manager';
 import { findLatestRelease } from '../../utils/release';
 import { getFirmwareUpdateField } from '../../utils/deviceFeaturesUtils';
-import { IFirmwareField } from '../../data-manager/DataManager';
+
+import type { Features } from '../../types';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
+import type { IFirmwareField } from '../../data-manager/DataManager';
 
 export interface GetInfoProps {
   features: Features;
   updateType: 'firmware' | 'ble';
   isUpdateBootloader?: boolean;
   targetVersion?: string;
+  firmwareType: EFirmwareType;
 }
 
 interface GetBinaryProps extends GetInfoProps {
@@ -23,8 +27,14 @@ export const getBinary = async ({
   updateType,
   version,
   isUpdateBootloader,
+  firmwareType,
 }: GetBinaryProps) => {
-  const releaseInfo = getInfo({ features, updateType, targetVersion: version?.join('.') });
+  const releaseInfo = getInfo({
+    features,
+    updateType,
+    targetVersion: version?.join('.'),
+    firmwareType,
+  });
 
   if (!releaseInfo) {
     throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'no firmware found for this device');
@@ -71,7 +81,7 @@ export const getSysResourceBinary = async (url: string) => {
   };
 };
 
-export const getInfo = ({ features, updateType, targetVersion }: GetInfoProps) => {
+export const getInfo = ({ features, updateType, targetVersion, firmwareType }: GetInfoProps) => {
   const deviceType = getDeviceType(features);
   if (deviceType === 'unknown') {
     return null;
@@ -82,6 +92,7 @@ export const getInfo = ({ features, updateType, targetVersion }: GetInfoProps) =
     features,
     updateType,
     targetVersion,
+    firmwareType,
   });
   const releaseInfo = deviceMap?.[deviceType]?.[firmwareUpdateField] ?? [];
   return findLatestRelease(releaseInfo);

package/src/api/firmware/releaseHelper.ts

@@ -6,10 +6,12 @@ import {
   getDeviceType,
 } from '../../utils';
 
-export const getFirmwareReleaseInfo = (features: Features) => {
-  const firmwareStatus = DataManager.getFirmwareStatus(features);
-  const changelog = DataManager.getFirmwareChangelog(features);
-  const release = DataManager.getFirmwareLatestRelease(features);
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
+
+export const getFirmwareReleaseInfo = (features: Features, firmwareType: EFirmwareType) => {
+  const firmwareStatus = DataManager.getFirmwareStatus(features, firmwareType);
+  const changelog = DataManager.getFirmwareChangelog(features, firmwareType);
+  const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
   const bootloaderMode = !!features.bootloader_mode;
   return {
     status: firmwareStatus,
@@ -32,11 +34,16 @@ export const getBleFirmwareReleaseInfo = (features: Features) => {
   };
 };
 
-export const getBootloaderReleaseInfo = (
-  features: Features,
-  willUpdateFirmwareVersion?: string
-) => {
-  const release = DataManager.getFirmwareLatestRelease(features);
+export const getBootloaderReleaseInfo = ({
+  features,
+  willUpdateFirmwareVersion,
+  firmwareType,
+}: {
+  features: Features;
+  willUpdateFirmwareVersion?: string;
+  firmwareType: EFirmwareType;
+}) => {
+  const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
   const changelog = [release?.bootloaderChangelog].filter(
     item =>
       item != null &&
@@ -52,9 +59,13 @@ export const getBootloaderReleaseInfo = (
   const deviceType = getDeviceType(features);
   // classic mini classic1s
   if (DeviceModelToTypes.model_mini.includes(deviceType)) {
-    shouldUpdate = !!checkNeedUpdateBootForClassicAndMini(features, willUpdateFirmwareVersion);
+    shouldUpdate = !!checkNeedUpdateBootForClassicAndMini({
+      features,
+      willUpdateFirmware: willUpdateFirmwareVersion,
+      firmwareType,
+    });
   } else if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-    shouldUpdate = checkNeedUpdateBootForTouch(features);
+    shouldUpdate = checkNeedUpdateBootForTouch(features, firmwareType);
   }
 
   return {

package/src/api/firmware/updateBootloader.ts

@@ -1,16 +1,17 @@
 import ByteBuffer from 'bytebuffer';
 import semver from 'semver';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import { DeviceModelToTypes, Features } from '../../types';
 import { getDeviceType, getDeviceBootloaderVersion, getDeviceFirmwareVersion } from '../../utils';
 import { DataManager } from '../../data-manager';
 import { shouldUpdateBootloaderForClassicAndMini } from './bootloaderHelper';
 
-export function checkNeedUpdateBootForTouch(features: Features) {
+export function checkNeedUpdateBootForTouch(features: Features, firmwareType: EFirmwareType) {
   const deviceType = getDeviceType(features);
   if (!DeviceModelToTypes.model_touch.includes(deviceType)) return false;
   const currentVersion = getDeviceFirmwareVersion(features).join('.');
   const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
-  const targetBootloaderVersion = DataManager.getBootloaderTargetVersion(features);
+  const targetBootloaderVersion = DataManager.getBootloaderTargetVersion(features, firmwareType);
   if (!targetBootloaderVersion) return false;
 
   return (
@@ -23,22 +24,29 @@ export function checkNeedUpdateBootForTouch(features: Features) {
   );
 }
 
-export function checkNeedUpdateBootForClassicAndMini(
-  features: Features,
-  willUpdateFirmware?: string
-) {
+export function checkNeedUpdateBootForClassicAndMini({
+  features,
+  willUpdateFirmware,
+  firmwareType,
+}: {
+  features: Features;
+  willUpdateFirmware?: string;
+  firmwareType: EFirmwareType;
+}) {
   const deviceType = getDeviceType(features);
   if (!DeviceModelToTypes.model_mini.includes(deviceType)) return false;
   if (!willUpdateFirmware) return false;
   const currentVersion = getDeviceFirmwareVersion(features).join('.');
   const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
-  const targetBootloaderVersion = DataManager.getBootloaderTargetVersion(features);
+  const targetBootloaderVersion = DataManager.getBootloaderTargetVersion(features, firmwareType);
   if (targetBootloaderVersion && semver.gte(bootloaderVersion, targetBootloaderVersion.join('.'))) {
     return false;
   }
 
-  const bootloaderRelatedFirmwareVersion =
-    DataManager.getBootloaderRelatedFirmwareVersion(features);
+  const bootloaderRelatedFirmwareVersion = DataManager.getBootloaderRelatedFirmwareVersion(
+    features,
+    firmwareType
+  );
   if (!bootloaderRelatedFirmwareVersion) return false;
 
   return shouldUpdateBootloaderForClassicAndMini({

package/src/api/sui/SuiSignTransaction.ts

@@ -1,6 +1,6 @@
-import { SuiSignTx as HardwareSuiSignTx, TypedCall, SuiSignedTx } from '@onekeyfe/hd-transport';
 import semver from 'semver';
 import { bytesToHex } from '@noble/hashes/utils';
+
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
@@ -8,6 +8,12 @@ import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 import { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
+
+import type {
+  SuiSignTx as HardwareSuiSignTx,
+  SuiSignedTx,
+  TypedCall,
+} from '@onekeyfe/hd-transport';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 
 type SuiSignTx = Omit<HardwareSuiSignTx, 'data_initial_chunk' | 'data_length'> & HardwareSuiSignTx;

package/src/core/index.ts

@@ -22,6 +22,7 @@ import {
   setLoggerPostMessage,
   wait,
   getMethodVersionRange,
+  getFirmwareType,
 } from '../utils';
 import {
   findDefectiveBatchDevice,
@@ -282,7 +283,8 @@ const onCallDevice = async (
           }
         }
 
-        const newVersionStatus = DataManager.getFirmwareStatus(device.features);
+        const deviceFirmwareType = getFirmwareType(device.features);
+        const newVersionStatus = DataManager.getFirmwareStatus(device.features, deviceFirmwareType);
         const bleVersionStatus = DataManager.getBLEFirmwareStatus(device.features);
 
         const currentFirmwareVersion = getDeviceFirmwareVersion(device.features).join('.');

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/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;
 }