@onekeyfe/hd-core 1.2.0-alpha.76 → 1.2.0-alpha.78

package/src/api/utils.ts

@@ -4,6 +4,7 @@ import * as ApiMethods from './index';
 
 import type { BaseMethod } from './BaseMethod';
 import type { IFrameCallMessage } from '../events';
+import type { ProtocolType } from '@onekeyfe/hd-transport';
 
 type MethodConstructor = new (message: IFrameCallMessage & { id?: number }) => BaseMethod<any>;
 
@@ -25,3 +26,27 @@ export function findMethod(message: IFrameCallMessage & { id?: number }): BaseMe
     `Method ${method} is not set`
   );
 }
+
+/**
+ * Read the protocol contract from the same method instance used by the Core dispatcher.
+ * Passing a payload initializes the method first so parameter-dependent contracts, such
+ * as Bitcoin fork support, are evaluated with the actual request.
+ */
+export function getMethodSupportedProtocols(
+  method: string,
+  payload?: Record<string, unknown>
+): readonly ProtocolType[] {
+  const instance = findMethod({
+    id: 0,
+    payload: {
+      ...payload,
+      method,
+    },
+  } as unknown as IFrameCallMessage);
+
+  if (payload !== undefined) {
+    instance.init();
+  }
+
+  return instance.getSupportedProtocols();
+}

package/src/data-manager/DataManager.ts

@@ -32,6 +32,8 @@ import type {
   RemoteConfigResponse,
 } from '../types';
 
+const FIRMWARE_UPDATE_CONFIG_FRESHNESS_MS = 5 * 60 * 1000;
+
 const Log = getLogger(LoggerNames.Core);
 
 export const FIRMWARE_FIELDS = [
@@ -507,6 +509,7 @@ export default class DataManager {
     this.assets = {
       bridge: data.bridge,
     };
+    this.lastCheckTimestamp = getTimeStamp();
   }
 
   static updateEnv(newEnv: ConnectSettings['env']) {
@@ -538,6 +541,18 @@ export default class DataManager {
     if (!this.settings) {
       throw new Error('Remote config settings are not initialized');
     }
+    const hasFreshConfig =
+      this.lastCheckTimestamp > 0 &&
+      getTimeStamp() - this.lastCheckTimestamp <= FIRMWARE_UPDATE_CONFIG_FRESHNESS_MS;
+    if (hasFreshConfig) {
+      if (requireResources && this.protocolV2ResourcesConfigError) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.FirmwareUpdateDownloadFailed,
+          `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`
+        );
+      }
+      return;
+    }
     const loaded = await this.load(this.settings);
     if (!loaded) {
       throw ERRORS.TypedError(

package/src/device/DeviceStateMapper.ts

@@ -7,6 +7,7 @@ import {
   mapLanguageToProtocolV2,
   normalizeSafetyCheckLevel,
 } from '../utils/deviceSettings';
+import { getProtocolV2SeState, getProtocolV2SeType } from '../protocols/protocol-v2/features';
 
 import type {
   ApplySettings,
@@ -159,6 +160,11 @@ const meaningfulVersion = (version?: string | null) => {
   return parts.map(part => (Number.isNaN(Number.parseInt(part, 10)) ? '0' : part)).join('.');
 };
 
+const meaningfulText = (value: unknown): string | null => {
+  if (value === undefined || value === null || value === '') return null;
+  return String(value);
+};
+
 export const mapProtocolV1OnekeyFeaturesToState = (features: OnekeyFeatures): DeviceStatePatch => {
   const verification = definedEntries<DeviceFeaturesVerify>({
     firmwareBuildId: features.onekey_firmware_build_id,
@@ -203,6 +209,24 @@ export const mapProtocolV1OnekeyFeaturesToState = (features: OnekeyFeatures): De
       se04Boot: meaningfulVersion(features.onekey_se04_boot_version),
     }),
     ...(Object.keys(verification).length > 0 ? { verification } : {}),
+    securityElements: {
+      se01: {
+        type: meaningfulText(features.onekey_se_type),
+        state: meaningfulText(features.onekey_se01_state),
+      },
+      se02: {
+        type: null,
+        state: meaningfulText(features.onekey_se02_state),
+      },
+      se03: {
+        type: null,
+        state: meaningfulText(features.onekey_se03_state),
+      },
+      se04: {
+        type: null,
+        state: meaningfulText(features.onekey_se04_state),
+      },
+    },
     raw: { protocolV1OneKeyFeatures: features },
   };
 };
@@ -288,6 +312,24 @@ export const mapProtocolV2DeviceInfoToState = (
       se04BootBuildId: imageBuildId(info.se4?.bootloader),
       se04BootHash: imageHash(info.se4?.bootloader),
     }),
+    securityElements: {
+      se01: {
+        type: getProtocolV2SeType(info.se1),
+        state: getProtocolV2SeState(info.se1),
+      },
+      se02: {
+        type: getProtocolV2SeType(info.se2),
+        state: getProtocolV2SeState(info.se2),
+      },
+      se03: {
+        type: getProtocolV2SeType(info.se3),
+        state: getProtocolV2SeState(info.se3),
+      },
+      se04: {
+        type: getProtocolV2SeType(info.se4),
+        state: getProtocolV2SeState(info.se4),
+      },
+    },
     raw: {
       protocolV2DeviceInfo: info,
       ...(loader ? { protocolV2DeviceStatus: null } : {}),

package/src/device/DeviceStateProjector.ts

@@ -9,6 +9,62 @@ type StoredDeviceState = DeviceState & {
 const getBootloaderMode = (state: StoredDeviceState) =>
   state.status.mode === 'bootloader' || state.status.mode === 'romloader';
 
+const projectLegacyAdvancedFields = (state: StoredDeviceState) => {
+  const verification = state.verification ?? {};
+  const securityElements = state.securityElements ?? {};
+
+  return {
+    onekey_device_type: state.identity.deviceType,
+    onekey_serial_no: state.identity.serialNo,
+    onekey_se_type:
+      securityElements.se01?.type ??
+      securityElements.se02?.type ??
+      securityElements.se03?.type ??
+      securityElements.se04?.type,
+    onekey_board_version: state.versions.board,
+    onekey_board_hash: verification.boardHash,
+    onekey_board_build_id: verification.boardBuildId,
+    onekey_boot_version: state.versions.bootloader,
+    onekey_boot_hash: verification.bootloaderHash,
+    onekey_boot_build_id: verification.bootloaderBuildId,
+    onekey_firmware_version: state.versions.firmware,
+    onekey_firmware_hash: verification.firmwareHash,
+    onekey_firmware_build_id: verification.firmwareBuildId,
+    onekey_ble_version: state.versions.ble,
+    onekey_ble_hash: verification.bleHash,
+    onekey_ble_build_id: verification.bleBuildId,
+    onekey_ble_name: state.identity.bleName,
+    onekey_se01_version: state.versions.se01,
+    onekey_se01_hash: verification.se01Hash,
+    onekey_se01_build_id: verification.se01BuildId,
+    onekey_se01_state: securityElements.se01?.state,
+    onekey_se01_boot_version: state.versions.se01Boot,
+    onekey_se01_boot_hash: verification.se01BootHash,
+    onekey_se01_boot_build_id: verification.se01BootBuildId,
+    onekey_se02_version: state.versions.se02,
+    onekey_se02_hash: verification.se02Hash,
+    onekey_se02_build_id: verification.se02BuildId,
+    onekey_se02_state: securityElements.se02?.state,
+    onekey_se02_boot_version: state.versions.se02Boot,
+    onekey_se02_boot_hash: verification.se02BootHash,
+    onekey_se02_boot_build_id: verification.se02BootBuildId,
+    onekey_se03_version: state.versions.se03,
+    onekey_se03_hash: verification.se03Hash,
+    onekey_se03_build_id: verification.se03BuildId,
+    onekey_se03_state: securityElements.se03?.state,
+    onekey_se03_boot_version: state.versions.se03Boot,
+    onekey_se03_boot_hash: verification.se03BootHash,
+    onekey_se03_boot_build_id: verification.se03BootBuildId,
+    onekey_se04_version: state.versions.se04,
+    onekey_se04_hash: verification.se04Hash,
+    onekey_se04_build_id: verification.se04BuildId,
+    onekey_se04_state: securityElements.se04?.state,
+    onekey_se04_boot_version: state.versions.se04Boot,
+    onekey_se04_boot_hash: verification.se04BootHash,
+    onekey_se04_boot_build_id: verification.se04BootBuildId,
+  };
+};
+
 export const projectFeatures = (state: StoredDeviceState): Features => {
   const snapshot = cloneDeviceState(state);
   const rawFeatures = snapshot.raw?.protocolV1Features ?? {};
@@ -21,10 +77,12 @@ export const projectFeatures = (state: StoredDeviceState): Features => {
     snapshot.protocol === 'V1'
       ? (rawFeatures as { bootloader_mode?: boolean | null }).bootloader_mode ?? null
       : getBootloaderMode(snapshot);
+  const legacyAdvancedFields = projectLegacyAdvancedFields(snapshot);
 
   return {
     ...publicRawFeatures,
     ...rawOneKeyFeatures,
+    ...legacyAdvancedFields,
     protocol: snapshot.protocol,
     protocolVersion: snapshot.protocolVersion ?? (snapshot.protocol === 'V1' ? 1 : null),
     deviceType: snapshot.identity.deviceType,

package/src/device/DeviceStateStore.ts

@@ -106,6 +106,27 @@ const applySectionPatch = <T extends object>(
   }
 };
 
+const mergeSecurityElements = (
+  current: StoredDeviceState['securityElements'],
+  patch: NonNullable<DeviceStatePatch['securityElements']>
+) => {
+  const merged = cloneDeviceState(current ?? {});
+
+  for (const key of Object.keys(patch) as Array<keyof typeof patch>) {
+    const elementPatch = patch[key];
+    if (elementPatch !== undefined) {
+      const currentElement = merged[key];
+      merged[key] = {
+        type: elementPatch.type !== undefined ? elementPatch.type : currentElement?.type ?? null,
+        state:
+          elementPatch.state !== undefined ? elementPatch.state : currentElement?.state ?? null,
+      };
+    }
+  }
+
+  return merged;
+};
+
 export class DeviceStateStore {
   private state: StoredDeviceState | undefined;
 
@@ -148,6 +169,16 @@ export class DeviceStateStore {
     if (patch.status) applySectionPatch(next.status, patch.status, 'status', changedKeys);
     if (patch.settings) applySectionPatch(next.settings, patch.settings, 'settings', changedKeys);
     if (patch.versions) applySectionPatch(next.versions, patch.versions, 'versions', changedKeys);
+    if (patch.securityElements !== undefined) {
+      const mergedSecurityElements = mergeSecurityElements(
+        next.securityElements,
+        patch.securityElements
+      );
+      if (!isEqual(next.securityElements, mergedSecurityElements)) {
+        next.securityElements = mergedSecurityElements;
+        changedKeys.push('securityElements');
+      }
+    }
 
     if (patch.capabilities !== undefined && !isEqual(next.capabilities, patch.capabilities)) {
       next.capabilities = cloneDeviceState(patch.capabilities);

package/src/index.ts

@@ -19,6 +19,8 @@ export * from './types';
 export { whitelist, whitelistExtension } from './data/config';
 export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
+export { projectFeatures as projectDeviceStateFeatures } from './device/DeviceStateProjector';
+export { getMethodSupportedProtocols } from './api/utils';
 export {
   getFirmwareUpdateHostBindingGeneration,
   registerFirmwareUpdateHostBinding,

package/src/types/device.ts

@@ -259,6 +259,19 @@ export type DeviceStateVersions = {
   se04Boot?: string | null;
 };
 
+export type DeviceStateSecurityElement = {
+  type: string | null;
+  state: string | null;
+};
+
+export type DeviceStateSecurityElements = Partial<
+  Record<'se01' | 'se02' | 'se03' | 'se04', DeviceStateSecurityElement>
+>;
+
+export type DeviceStateSecurityElementsPatch = Partial<
+  Record<keyof DeviceStateSecurityElements, Partial<DeviceStateSecurityElement>>
+>;
+
 export type DeviceState = {
   schemaVersion: 1;
   revision: number;
@@ -270,6 +283,8 @@ export type DeviceState = {
   status: DeviceStateStatus;
   settings: DeviceStateSettings;
   versions: DeviceStateVersions;
+  /** Secure-element metadata exposed by the unified firmware information read. */
+  securityElements?: DeviceStateSecurityElements;
   capabilities: Array<number | string>;
   verification?: Partial<DeviceFeaturesVerify>;
 };
@@ -281,6 +296,7 @@ export type DeviceStatePatch = {
   status?: Partial<DeviceStateStatus>;
   settings?: Partial<DeviceStateSettings>;
   versions?: Partial<DeviceStateVersions>;
+  securityElements?: DeviceStateSecurityElementsPatch;
   capabilities?: Array<number | string>;
   verification?: DeviceFeaturesVerify;
   raw?: DeviceFeaturesRawPatch;

package/src/utils/homescreen.ts

@@ -328,6 +328,10 @@ export const getNftSize = ({
       full: { width: PRO2_NFT_IMAGE_WIDTH, height: PRO2_NFT_IMAGE_HEIGHT },
       thumbnail: { width: PRO2_NFT_THUMBNAIL_WIDTH, height: PRO2_NFT_THUMBNAIL_HEIGHT },
     },
+    neo: {
+      full: { width: PRO2_NFT_IMAGE_WIDTH, height: PRO2_NFT_IMAGE_HEIGHT },
+      thumbnail: { width: PRO2_NFT_THUMBNAIL_WIDTH, height: PRO2_NFT_THUMBNAIL_HEIGHT },
+    },
   };
 
   return sizes[deviceType]?.[thumbnail ? 'thumbnail' : 'full'];
@@ -342,7 +346,7 @@ export const getHomeScreenSize = ({
   homeScreenType: 'WallPaper' | 'Nft';
   thumbnail?: boolean;
 }) => {
-  if (deviceType === EDeviceType.Pro2) {
+  if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) {
     return thumbnail ? undefined : { width: PRO2_WALLPAPER_WIDTH, height: PRO2_WALLPAPER_HEIGHT };
   }