@onekeyfe/hd-core 1.1.16 → 1.1.18-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/types/api/checkAllFirmwareRelease.ts

@@ -1,6 +1,7 @@
+import type { IBLEFirmwareReleaseInfo } from '../settings';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
 import type { IDeviceBLEFirmwareStatus, IDeviceFirmwareStatus } from '../device';
-import { IBLEFirmwareReleaseInfo } from '../settings';
 
 export type FirmwareRelease = {
   shouldUpdate?: boolean;
@@ -22,6 +23,7 @@ export type AllFirmwareRelease = {
 
 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;
 }
 

package/src/types/settings.ts

@@ -1,3 +1,4 @@
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { IDeviceType } from './device';
 
 export type transportEnv =
@@ -40,6 +41,11 @@ export type ILocale = 'zh-CN' | 'en-US';
 export type IFirmwareReleaseInfo = {
   required: boolean;
   url: string;
+  /**
+   * Firmware type (bitcoinonly or universal)
+   * This field is not present in the remote config, but will be inferred from the firmware field name
+   */
+  firmwareType?: EFirmwareType;
   /** Firmware UI resource */
   resource?: string;
   /** Firmware full UI resource */
@@ -75,11 +81,42 @@ export type IBLEFirmwareReleaseInfo = {
 };
 
 type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
+
+/**
+ * Device firmware configuration map
+ *
+ * IMPORTANT: This type is used for firmware update logic.
+ * - DO NOT remove existing firmware fields
+ * - Only ADD new optional firmware fields for new versions
+ * - 'firmware' field is required for backward compatibility
+ * - 'ble' field is required for BLE firmware updates
+ *
+ * @example
+ * // When adding firmware-v8:
+ * // {
+ * //   firmware: IFirmwareReleaseInfo[];
+ * //   'firmware-v2'?: IFirmwareReleaseInfo[];
+ * //   'firmware-v7'?: IFirmwareReleaseInfo[];
+ * //   'firmware-v8'?: IFirmwareReleaseInfo[];      // New
+ * //   'firmware-btc-v7'?: IFirmwareReleaseInfo[];
+ * //   'firmware-btc-v8'?: IFirmwareReleaseInfo[];  // New
+ * //   ble: IBLEFirmwareReleaseInfo[];
+ * // }
+ */
 export type DeviceTypeMap = {
   [k in IKnownDevice]: {
+    /** Base firmware field (required for backward compatibility) */
     firmware: IFirmwareReleaseInfo[];
+    /** Firmware v2 (Touch/Pro specific) */
     'firmware-v2'?: IFirmwareReleaseInfo[];
+    /** Universal firmware v7 */
     'firmware-v7'?: IFirmwareReleaseInfo[];
+    /** Bitcoin-only firmware v7 */
+    'firmware-btc-v7'?: IFirmwareReleaseInfo[];
+    // Future firmware versions should be added here as optional fields:
+    // 'firmware-v8'?: IFirmwareReleaseInfo[];
+    // 'firmware-btc-v8'?: IFirmwareReleaseInfo[];
+    /** BLE firmware (required) */
     ble: IBLEFirmwareReleaseInfo[];
   };
 };

package/src/utils/deviceFeaturesUtils.ts

@@ -1,18 +1,20 @@
 import semver from 'semver';
 import { isNaN } from 'lodash';
-import { EDeviceType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, type EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { Enum_Capability } from '@onekeyfe/hd-transport';
+
 import { toHardened } from '../api/helpers/pathUtils';
-import { DeviceCommands } from '../device/DeviceCommands';
-import type { Features, SupportFeatureType } from '../types';
 import { DeviceModelToTypes, DeviceTypeToModels } from '../types';
-import DataManager, { IFirmwareField, MessageVersion } from '../data-manager/DataManager';
+import DataManager, { type IFirmwareField, type MessageVersion } from '../data-manager/DataManager';
 import { PROTOBUF_MESSAGE_CONFIG } from '../data-manager/MessagesConfig';
-import { Device } from '../device/Device';
 import { getDeviceType } from './deviceInfoUtils';
 import { getDeviceFirmwareVersion } from './deviceVersionUtils';
 import { existCapability } from './capabilitieUtils';
 
+import type { Device } from '../device/Device';
+import type { DeviceCommands } from '../device/DeviceCommands';
+import type { Features, SupportFeatureType } from '../types';
+
 export const getSupportMessageVersion = (
   features: Features | undefined
 ): { messages: JSON; messageVersion: MessageVersion } => {
@@ -231,6 +233,13 @@ export const supportModifyHomescreen = (features?: Features): SupportFeatureType
   return { support: semver.gte(currentVersion, '3.4.0') };
 };
 
+const getLatestFirmwareField = (firmwareType?: EFirmwareType): IFirmwareField => {
+  if (firmwareType === 'bitcoinonly') {
+    return `firmware-btc-v7`;
+  }
+  return `firmware-v7`;
+};
+
 /**
  *  Since 3.5.0, Touch uses the firmware-v3 field to get firmware release info
  */
@@ -238,33 +247,36 @@ export const getFirmwareUpdateField = ({
   features,
   updateType,
   targetVersion,
+  firmwareType,
 }: {
   features: Features;
   updateType: 'firmware' | 'ble';
   targetVersion?: string;
+  firmwareType: EFirmwareType;
 }): 'ble' | IFirmwareField => {
   const deviceType = getDeviceType(features);
   const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
   if (updateType === 'ble') {
     return 'ble';
   }
+  const latestFirmwareField = getLatestFirmwareField(firmwareType);
 
   if (DeviceModelToTypes.model_mini.includes(deviceType)) {
-    return 'firmware-v7';
+    return latestFirmwareField;
   }
 
   if (deviceType === EDeviceType.Touch) {
     if (targetVersion) {
       if (semver.eq(targetVersion, '4.0.0')) return 'firmware-v2';
-      if (semver.gt(targetVersion, '4.0.0')) return 'firmware-v7';
+      if (semver.gt(targetVersion, '4.0.0')) return latestFirmwareField;
     }
 
     if (semver.lt(deviceFirmwareVersion.join('.'), '3.4.0')) return 'firmware';
 
-    return 'firmware-v7';
+    return latestFirmwareField;
   }
   if (deviceType === EDeviceType.Pro) {
-    return 'firmware-v7';
+    return latestFirmwareField;
   }
   return 'firmware';
 };
@@ -276,7 +288,7 @@ export const getFirmwareUpdateField = ({
 export const getFirmwareUpdateFieldArray = (
   features: Features,
   updateType: 'firmware' | 'ble' | 'bootloader'
-): ('firmware' | 'ble' | 'firmware-v2' | 'firmware-v7')[] => {
+): ('ble' | IFirmwareField)[] => {
   const deviceType = getDeviceType(features);
   if (updateType === 'ble') {
     return ['ble'];

package/src/utils/release.ts

@@ -1,5 +1,6 @@
 import semver from 'semver';
-import {
+
+import type {
   IBLEFirmwareReleaseInfo,
   IDeviceFirmwareStatus,
   IFirmwareReleaseInfo,