@onekeyfe/hd-core 1.2.0-alpha.1 → 1.2.0-alpha.100

package/src/types/device.ts

@@ -1,8 +1,14 @@
-import { EDeviceType, type EFirmwareType } from '@onekeyfe/hd-shared';
+import { EDeviceType, type EFirmwareType, type HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 
 import type { IVersionArray } from './settings';
 import type { PROTO } from '../constants';
-import type { OneKeyDeviceCommType, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+import type {
+  Enum_SafetyCheckLevel,
+  OneKeyDeviceCommType,
+  ProtocolV2DeviceInfo,
+  DeviceStatus as ProtocolV2DeviceStatus,
+  ProtocolInfo as ProtocolV2ProtocolInfo,
+} from '@onekeyfe/hd-transport';
 
 export type DeviceStatus = 'available' | 'occupied' | 'used';
 
@@ -23,6 +29,14 @@ export type UnavailableCapabilities = { [key: string]: UnavailableCapability };
 
 export type KnownDevice = {
   connectId: string | null;
+  /** Protocol family confirmed by the transport's active probe. */
+  connectProtocol?: HardwareConnectProtocol;
+  /**
+   * Stable physical-device identity. Current SDK responses always include this
+   * value; it remains optional in the type during the uuid compatibility window.
+   */
+  serialNo?: string;
+  /** @deprecated Use serialNo instead. */
   uuid: string;
   deviceId: string | null;
   deviceType: IDeviceType | null;
@@ -32,9 +46,12 @@ export type KnownDevice = {
   bleName: string | null;
   name: string;
   error?: typeof undefined;
+  /** Current SDK/transport usage state for connection indicators. */
+  status?: DeviceStatus;
   mode: EOneKeyDeviceMode;
-  features?: Features;
-  sessionId?: string | null;
+  features: Features;
+  /** Unified SDK device-state snapshot; features remains a legacy projection. */
+  state?: DeviceState;
   unavailableCapabilities: UnavailableCapabilities;
   bleFirmwareVersion: IVersionArray | null;
   firmwareVersion: IVersionArray | null;
@@ -47,6 +64,19 @@ export type KnownDevice = {
 
 export type SearchDevice = {
   connectId: string | null;
+  /** Protocol family confirmed by the transport's active probe. */
+  connectProtocol?: HardwareConnectProtocol;
+  /**
+   * Available after device initialization. BLE discovery does not connect to the
+   * device, so it returns null until a later initialized device response. Current
+   * SDK responses always include the field; it remains optional in the type during
+   * the uuid compatibility window.
+   */
+  serialNo?: string | null;
+  /**
+   * @deprecated Ambiguous legacy identifier. Use serialNo for hardware identity
+   * and connectId for transport routing.
+   */
   uuid: string;
   deviceId: string | null;
   deviceType: IDeviceType;
@@ -91,6 +121,7 @@ export type DeviceFeaturesProtocol = 'V1' | 'V2' | 'unknown';
 export type DeviceFeaturesMode =
   | 'normal'
   | 'bootloader'
+  | 'romloader'
   | 'notInitialized'
   | 'backupMode'
   | 'unknown';
@@ -98,6 +129,10 @@ export type DeviceFeaturesMode =
 export type DeviceFeaturesVerify = {
   firmwareBuildId?: string;
   firmwareHash?: string;
+  applicationP1BuildId?: string;
+  applicationP1Hash?: string;
+  applicationP2BuildId?: string;
+  applicationP2Hash?: string;
   bootloaderBuildId?: string;
   bootloaderHash?: string;
   boardBuildId?: string;
@@ -125,10 +160,157 @@ export type DeviceFeaturesVerify = {
 export type DeviceFeaturesRaw = {
   protocolV1Features?: PROTO.Features;
   protocolV1OneKeyFeatures?: OnekeyFeatures;
+  protocolV2ProtocolInfo?: ProtocolV2ProtocolInfo;
   protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
+  protocolV2DeviceStatus?: ProtocolV2DeviceStatus;
 };
 
-export type Features = {
+export type DeviceFeaturesRawPatch = {
+  [Key in keyof DeviceFeaturesRaw]?: DeviceFeaturesRaw[Key] | null;
+};
+
+export type DeviceStateProtocol = DeviceFeaturesProtocol;
+export type DeviceStateMode = DeviceFeaturesMode;
+export type DeviceStateSection = 'identity' | 'status' | 'settings' | 'versions' | 'verification';
+
+export type DeviceStateUpdateSource =
+  | 'initialize'
+  | 'device-info'
+  | 'device-status'
+  | 'settings-read'
+  | 'settings-write'
+  | 'change-pin'
+  | 'lock'
+  | 'unlock'
+  | 'passphrase'
+  | 'session-clear'
+  | 'firmware-update'
+  | 'transport-reconnect'
+  | 'compatibility';
+
+export type DeviceStateIdentity = {
+  deviceType: IDeviceType;
+  firmwareType: EFirmwareType;
+  model: string | null;
+  vendor: string | null;
+  deviceId: string | null;
+  serialNo: string;
+  label: string | null;
+  bleName: string | null;
+};
+
+export type DeviceStateStatus = {
+  mode: DeviceStateMode;
+  initialized: boolean | null;
+  unlocked: boolean | null;
+  firmwarePresent: boolean | null;
+  backupRequired: boolean | null;
+  noBackup: boolean | null;
+  unfinishedBackup: boolean | null;
+  recoveryMode: boolean | null;
+  passphraseProtection: boolean | null;
+  pinProtection: boolean | null;
+  /** `attach_to_pin_enabled`：是否至少存在一个 Attach PIN 绑定。 */
+  attachToPinEnabled: boolean | null;
+  /** `unlocked_by_attach_to_pin`：本次解锁是否由 Attach PIN 完成。 */
+  unlockedAttachPin: boolean | null;
+};
+
+export type DeviceStateSettings = {
+  language: string | null;
+  bleEnabled: boolean | null;
+  sdCardPresent: boolean | null;
+  sdProtection: boolean | null;
+  wipeCodeProtection: boolean | null;
+  passphraseAlwaysOnDevice: boolean | null;
+  safetyChecks: Enum_SafetyCheckLevel | null;
+  autoLockDelayMs: number | null;
+  autoShutdownDelayMs: number | null;
+  displayRotation: number | null;
+  experimentalFeatures: boolean | null;
+  wallpaperPath: string | null;
+  brightness: number | null;
+  animationEnabled: boolean | null;
+  tapToWake: boolean | null;
+  hapticFeedback: boolean | null;
+  deviceNameDisplayEnabled: boolean | null;
+  airgapMode: boolean | null;
+  fidoEnabled: boolean | null;
+  usbLockEnabled: boolean | null;
+  randomKeypad: boolean | null;
+};
+
+export type DeviceStateVersions = {
+  firmware: string | null;
+  applicationP1?: string | null;
+  applicationP2?: string | null;
+  bootloader: string | null;
+  board: string | null;
+  ble: string | null;
+  /** @deprecated Kept for legacy consumers; new code should read se01. */
+  se?: string | null;
+  se01?: string | null;
+  se02?: string | null;
+  se03?: string | null;
+  se04?: string | null;
+  se01Boot?: string | null;
+  se02Boot?: string | null;
+  se03Boot?: string | null;
+  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;
+  updatedAt: number;
+  protocol: DeviceStateProtocol;
+  /** Device-message protocol version, independent of the SDK V1/V2 protocol family. */
+  protocolVersion: number | null;
+  identity: DeviceStateIdentity;
+  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>;
+};
+
+export type DeviceStatePatch = {
+  protocol?: DeviceStateProtocol;
+  protocolVersion?: number | null;
+  identity?: Partial<DeviceStateIdentity>;
+  status?: Partial<DeviceStateStatus>;
+  settings?: Partial<DeviceStateSettings>;
+  versions?: Partial<DeviceStateVersions>;
+  securityElements?: DeviceStateSecurityElementsPatch;
+  capabilities?: Array<number | string>;
+  verification?: DeviceFeaturesVerify;
+  raw?: DeviceFeaturesRawPatch;
+};
+
+export type DeviceStateEvent = {
+  connectId: string | null;
+  state: DeviceState;
+  revision: number;
+  source: DeviceStateUpdateSource;
+  changedKeys: string[];
+};
+
+export type NormalizedFeatures = {
   protocol: DeviceFeaturesProtocol;
   protocolVersion?: number | null;
   deviceType: IDeviceType;
@@ -157,10 +339,23 @@ export type Features = {
   sdProtection: boolean | null;
   wipeCodeProtection: boolean | null;
   passphraseAlwaysOnDevice: boolean | null;
-  safetyChecks: string | null;
+  /** `attach_to_pin_enabled`：是否至少存在一个 Attach PIN 绑定。 */
+  attachToPinEnabled?: boolean | null;
+  safetyChecks: Enum_SafetyCheckLevel | null;
   autoLockDelayMs: number | null;
+  autoShutdownDelayMs: number | null;
   displayRotation: number | null;
   experimentalFeatures: boolean | null;
+  wallpaperPath: string | null;
+  brightness: number | null;
+  animationEnabled: boolean | null;
+  tapToWake: boolean | null;
+  hapticFeedback: boolean | null;
+  deviceNameDisplayEnabled: boolean | null;
+  airgapMode: boolean | null;
+  fidoEnabled: boolean | null;
+  usbLockEnabled: boolean | null;
+  randomKeypad: boolean | null;
   firmwareVersion: string | null;
   bootloaderVersion: string | null;
   boardVersion: string | null;
@@ -181,6 +376,10 @@ export type Features = {
   raw?: DeviceFeaturesRaw;
 };
 
+export type Features = NormalizedFeatures &
+  Partial<Omit<PROTO.Features, keyof NormalizedFeatures>> &
+  Partial<Omit<PROTO.OnekeyFeatures, keyof NormalizedFeatures | keyof PROTO.Features>>;
+
 export type OnekeyFeatures = PROTO.OnekeyFeatures;
 
 export type IDeviceType =
@@ -191,14 +390,21 @@ export type IDeviceType =
   | EDeviceType.Mini
   | EDeviceType.Touch
   | EDeviceType.Pro
-  | EDeviceType.Pro2;
+  | EDeviceType.Pro2
+  | EDeviceType.Neo;
 
 /**
  * model_classic: 'classic' | 'classic1s' | 'classicpure'
  * model_mini: 'classic' | 'classic1s' | 'classicpure' | 'mini'
  * model_touch: 'touch' | 'pro'
+ * model_pro2: 'pro2' | 'neo'
  */
-export type IDeviceModel = 'model_classic' | 'model_mini' | 'model_touch' | 'model_classic1s';
+export type IDeviceModel =
+  | 'model_classic'
+  | 'model_mini'
+  | 'model_touch'
+  | 'model_classic1s'
+  | 'model_pro2';
 
 export const DeviceModelToTypes: { [deviceModel in IDeviceModel]: IDeviceType[] } = {
   model_mini: [
@@ -208,6 +414,7 @@ export const DeviceModelToTypes: { [deviceModel in IDeviceModel]: IDeviceType[]
     EDeviceType.Mini,
   ],
   model_touch: [EDeviceType.Touch, EDeviceType.Pro],
+  model_pro2: [EDeviceType.Pro2, EDeviceType.Neo],
   model_classic: [EDeviceType.Classic, EDeviceType.Classic1s, EDeviceType.ClassicPure],
   model_classic1s: [EDeviceType.Classic1s, EDeviceType.ClassicPure],
 };
@@ -219,7 +426,8 @@ export const DeviceTypeToModels: { [deviceType in IDeviceType]: IDeviceModel[] }
   [EDeviceType.Mini]: ['model_mini'],
   [EDeviceType.Touch]: ['model_touch'],
   [EDeviceType.Pro]: ['model_touch'],
-  [EDeviceType.Pro2]: [],
+  [EDeviceType.Pro2]: ['model_pro2'],
+  [EDeviceType.Neo]: ['model_pro2'],
   [EDeviceType.Unknown]: [],
 };
 
@@ -232,7 +440,6 @@ export type ITransportStatus = 'valid' | 'outdated';
 export type IVersionRange = {
   min: string;
   max?: string;
-  unsupported?: boolean;
 };
 
 export type DeviceFirmwareRange = {

package/src/types/params.ts

@@ -14,6 +14,10 @@ export interface CommonParams {
    * Timeout time for single polling
    */
   timeout?: number;
+  /**
+   * DeviceInfoGet timeout during Protocol V2 initialization.
+   */
+  protocolV2DeviceInfoTimeoutMs?: number;
   /**
    * passphrase state
    */
@@ -56,9 +60,16 @@ export interface CommonParams {
   usePreInitialize?: boolean;
 
   /**
-   * Expected transport protocol. If omitted, SDK probes Protocol V1 then Protocol V2.
+   * Strictly expected transport protocol. The SDK actively verifies this value and
+   * rejects a mismatch. After a successful probe, the cached protocol is also strict.
    */
   connectProtocol?: HardwareConnectProtocol;
+
+  /**
+   * Ignore a previously bound protocol for this call and actively detect the
+   * protocol again. Intended for the first verified connection or explicit recovery.
+   */
+  forceProtocolDetection?: boolean;
 }
 
 export type Params<T> = CommonParams & T & { bundle?: undefined };

package/src/types/settings.ts

@@ -31,20 +31,79 @@ export type ConnectSettings = {
   timestamp: number;
   isFrame?: boolean;
   preRelease?: boolean;
+  firmwareManifestMode?: 'sdk-managed' | 'external-only';
+  preloadedConfig?: RemoteConfigResponse;
   fetchConfig?: boolean;
   extension?: string;
   configFetcher?: (url: string) => Promise<RemoteConfigResponse | null>;
-  /**
-   * 临时开关：Protocol V2 DevGetDeviceInfo 未稳定前用于 mock 设备信息。
-   * 正式 app 可显式设置为 false 以调用真实 DevGetDeviceInfo；固件稳定后删除。
-   */
-  protocolV2DeviceInfoMockEnabled?: boolean;
 };
 
 export type IVersionArray = [number, number, number];
 
 export type ILocale = 'zh-CN' | 'en-US';
 
+export type IProtocolV2FirmwareComponentTarget =
+  | 'ROMLOADER'
+  | 'BOOTLOADER'
+  | 'APPLICATION_P1'
+  | 'APPLICATION_P2'
+  | 'COPROCESSOR'
+  | 'SE01'
+  | 'SE02'
+  | 'SE03'
+  | 'SE04';
+
+export type IProtocolV2FirmwareComponent = {
+  target: IProtocolV2FirmwareComponentTarget;
+  url: string;
+  /** SHA-256 of the complete okpkg, used after downloading the package. */
+  fingerprint?: string;
+  /** OKPP payload hash, used to detect same-version package changes. */
+  payloadHash?: string;
+  expectedSize?: number;
+  version?: IVersionArray;
+};
+
+export type IProtocolV2ResourceSource = {
+  archiveUrl: string;
+  archiveSha256: string;
+  archiveSize: number;
+};
+
+export type IProtocolV2Resources = {
+  source: IProtocolV2ResourceSource;
+};
+
+export type IProtocolV2ResourceManifestFile = {
+  archive_path: string;
+  original_name: string;
+  device_path: string;
+  size: number;
+  sha256: string;
+  signed: true;
+  sig_algo: 'ed25519' | 'mldsa65';
+  payload_version: string | null;
+};
+
+export type IProtocolV2ResourceManifest = {
+  schema: 1;
+  artifact_name: string;
+  release_name: string;
+  variant: 'resource';
+  commit: string;
+  short_sha: string;
+  timestamp_utc: string;
+  core_version: string;
+  key_set: string;
+  device_root: 'vol0:';
+  restore_mode: 'bootloader_update';
+  trees: Array<{
+    path: string;
+    device: string;
+  }>;
+  files: IProtocolV2ResourceManifestFile[];
+};
+
 /** STM32 firmware config */
 export type IFirmwareReleaseInfo = {
   required: boolean;
@@ -56,17 +115,27 @@ export type IFirmwareReleaseInfo = {
   firmwareType?: EFirmwareType;
   /** Firmware UI resource */
   resource?: string;
+  resourceFingerprint?: string;
+  resourceExpectedSize?: number;
   /** Firmware full UI resource */
   fullResource?: string;
+  fullResourceFingerprint?: string;
+  fullResourceExpectedSize?: number;
   fullResourceRange?: string[];
   bootloaderResource?: string;
+  bootloaderFingerprint?: string;
+  bootloaderExpectedSize?: number;
   bootloaderVersion?: IVersionArray;
   displayBootloaderVersion?: IVersionArray;
   bootloaderRelatedFirmwareVersion?: IVersionArray;
+  upgradeType?: 'payload-package-set' | string;
+  components?: Record<string, IProtocolV2FirmwareComponent>;
+  installOrder?: string[];
   bootloaderChangelog?: {
     [k in ILocale]: string;
   };
   fingerprint: string;
+  expectedSize?: number;
   version: IVersionArray;
   changelog: {
     [k in ILocale]: string;
@@ -82,51 +151,31 @@ export type IBLEFirmwareReleaseInfo = {
   webUpdate: string;
   fingerprint: string;
   fingerprintWeb: string;
+  expectedSize?: number;
   version: IVersionArray;
   changelog: {
     [k in ILocale]: string;
   };
 };
 
-type IKnownDevice = Exclude<IDeviceType, 'unknown' | 'pro2'>;
+type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
+type IDeviceReleaseInfo = {
+  firmware?: IFirmwareReleaseInfo[];
+  /** Protocol V2 payload package set */
+  'firmware-v1'?: IFirmwareReleaseInfo[];
+  'firmware-v2'?: IFirmwareReleaseInfo[];
+  'firmware-v8'?: IFirmwareReleaseInfo[];
+  'firmware-btc-v8'?: IFirmwareReleaseInfo[];
+  ble?: IBLEFirmwareReleaseInfo[];
+  /** Independent Protocol V2 resource release configuration. */
+  resources?: IProtocolV2Resources;
+};
 
-/**
- * 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-v8'?: IFirmwareReleaseInfo[];
- * //   'firmware-v8'?: IFirmwareReleaseInfo[];      // New
- * //   'firmware-btc-v8'?: 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-v8'?: IFirmwareReleaseInfo[];
-    /** Bitcoin-only firmware v7 */
-    'firmware-btc-v8'?: IFirmwareReleaseInfo[];
-    // Future firmware versions should be added here as optional fields:
-    // 'firmware-v8'?: IFirmwareReleaseInfo[];
-    // 'firmware-btc-v8'?: IFirmwareReleaseInfo[];
-    /** BLE firmware (required) */
-    ble: IBLEFirmwareReleaseInfo[];
-  };
+  [k in Exclude<IKnownDevice, 'neo'>]: IDeviceReleaseInfo;
+} & {
+  /** Optional until every remote-config producer publishes a Neo entry. */
+  neo?: IDeviceReleaseInfo;
 };
 
 export type AssetsMap = {

package/src/utils/assets.ts

@@ -1,5 +1,8 @@
 import { httpRequest as browserHttpRequest } from './networkUtils';
 
-export const httpRequest = (url: string, type: string): any => browserHttpRequest(url, type);
+import type { HttpRequestOptions } from './networkUtils';
+
+export const httpRequest = (url: string, type: string, options?: HttpRequestOptions): any =>
+  browserHttpRequest(url, type, options);
 
 export const getTimeStamp = () => new Date().getTime();