@onekeyfe/hd-core 1.2.0-alpha.58 → 1.2.0-alpha.59

package/src/data-manager/DataManager.ts

@@ -69,7 +69,7 @@ function getFirmwareTypeFromField(firmwareField: IFirmwareField): EFirmwareType
 
 export default class DataManager {
   static deviceMap: DeviceTypeMap & {
-    [k: string]: DeviceTypeMap[keyof DeviceTypeMap] | undefined;
+    [k: string]: NonNullable<DeviceTypeMap[keyof DeviceTypeMap]> | undefined;
   } = {
     [EDeviceType.Classic]: {
       firmware: [],
@@ -95,6 +95,10 @@ export default class DataManager {
       firmware: [],
       ble: [],
     },
+    [EDeviceType.Neo]: {
+      firmware: [],
+      ble: [],
+    },
     [EDeviceType.ClassicPure]: {
       firmware: [],
       ble: [],
@@ -359,7 +363,7 @@ export default class DataManager {
 
   private static enrichFirmwareReleaseInfo(
     deviceData: DeviceTypeMap[keyof DeviceTypeMap] | undefined
-  ): DeviceTypeMap[keyof DeviceTypeMap] {
+  ): NonNullable<DeviceTypeMap[keyof DeviceTypeMap]> {
     // Safety check: return default structure if input is undefined/null
     if (!deviceData || typeof deviceData !== 'object') {
       return {
@@ -451,10 +455,15 @@ export default class DataManager {
     // 3. Apply config if available
     if (data) {
       let pro2Resources: IProtocolV2Resources | undefined;
+      let neoResources: IProtocolV2Resources | undefined;
+      this.protocolV2ResourcesConfigError = undefined;
       try {
         pro2Resources = parseProtocolV2Resources(
           (data.pro2 as { resources?: unknown } | undefined)?.resources
         );
+        neoResources = parseProtocolV2Resources(
+          (data.neo as { resources?: unknown } | undefined)?.resources
+        );
       } catch (error) {
         // Firmware resource metadata is not required for base communication. If the
         // remote config is temporarily incomplete, disable this resource update only.
@@ -463,7 +472,9 @@ export default class DataManager {
         Log.warn('[DataConfig] Ignoring invalid Pro2 resources config:', error);
       }
       const enrichedPro2Config = this.enrichFirmwareReleaseInfo(data.pro2);
+      const enrichedNeoConfig = this.enrichFirmwareReleaseInfo(data.neo);
       const { resources: _unvalidatedResources, ...pro2Config } = enrichedPro2Config;
+      const { resources: _unvalidatedNeoResources, ...neoConfig } = enrichedNeoConfig;
       Log.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
       this.deviceMap = {
         [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
@@ -476,6 +487,10 @@ export default class DataManager {
           ...pro2Config,
           ...(pro2Resources ? { resources: pro2Resources } : undefined),
         },
+        [EDeviceType.Neo]: {
+          ...neoConfig,
+          ...(neoResources ? { resources: neoResources } : undefined),
+        },
       };
       this.assets = {
         bridge: data.bridge,
@@ -509,7 +524,9 @@ export default class DataManager {
   }
 
   /** Force a fresh remote config before an update is allowed to mutate the device. */
-  static async forceReloadData(): Promise<void> {
+  static async forceReloadData({
+    requireResources = false,
+  }: { requireResources?: boolean } = {}): Promise<void> {
     if (!this.settings) {
       throw new Error('Remote config settings are not initialized');
     }
@@ -520,21 +537,23 @@ export default class DataManager {
         'Unable to refresh the latest remote config'
       );
     }
-    if (this.protocolV2ResourcesConfigError) {
+    if (requireResources && this.protocolV2ResourcesConfigError) {
       throw ERRORS.TypedError(
-        HardwareErrorCode.NetworkError,
+        HardwareErrorCode.FirmwareUpdateDownloadFailed,
         `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`
       );
     }
     this.lastCheckTimestamp = getTimeStamp();
   }
 
-  static getProtocolV2Resources() {
-    return this.deviceMap[EDeviceType.Pro2]?.resources?.stable;
+  static getProtocolV2Resources(deviceType: EDeviceType.Pro2 | EDeviceType.Neo = EDeviceType.Pro2) {
+    return this.deviceMap[deviceType]?.resources?.stable;
   }
 
-  static getProtocolV2BootResources() {
-    return this.deviceMap[EDeviceType.Pro2]?.resources?.boot;
+  static getProtocolV2BootResources(
+    deviceType: EDeviceType.Pro2 | EDeviceType.Neo = EDeviceType.Pro2
+  ) {
+    return this.deviceMap[deviceType]?.resources?.boot;
   }
 
   static getProtobufMessages(schema: ProtobufMessageSchema = 'v1CurrentSchema'): JSON {

package/src/device/Device.ts

@@ -696,6 +696,7 @@ export class Device extends EventEmitter {
     // Most-specific model first; must match getMethodVersionRange in deviceInfoUtils,
     // otherwise e.g. Classic1s resolves the looser model_mini range before model_classic1s.
     const modelFallbacks: IDeviceModel[] = [
+      'model_pro2',
       'model_classic1s',
       'model_classic',
       'model_mini',
@@ -715,7 +716,8 @@ export class Device extends EventEmitter {
     if (
       deviceType === EDeviceType.Touch ||
       deviceType === EDeviceType.Pro ||
-      deviceType === EDeviceType.Pro2
+      deviceType === EDeviceType.Pro2 ||
+      deviceType === EDeviceType.Neo
     ) {
       return { support: true };
     }
@@ -732,7 +734,8 @@ export class Device extends EventEmitter {
     if (
       deviceType === EDeviceType.Touch ||
       deviceType === EDeviceType.Pro ||
-      deviceType === EDeviceType.Pro2
+      deviceType === EDeviceType.Pro2 ||
+      deviceType === EDeviceType.Neo
     ) {
       return { support: false };
     }
@@ -1167,10 +1170,14 @@ export class Device extends EventEmitter {
     const protocolV2DeviceType = runtimeDeviceInfo
       ? resolveProtocolV2DeviceIdentity(runtimeDeviceInfo.hw?.Device_type).deviceType
       : this.getCurrentDeviceType();
-    if (runtimeMode === 'romloader' && protocolV2DeviceType !== EDeviceType.Pro2) {
+    if (
+      runtimeMode === 'romloader' &&
+      protocolV2DeviceType !== EDeviceType.Pro2 &&
+      protocolV2DeviceType !== EDeviceType.Neo
+    ) {
       throw ERRORS.TypedError(
         HardwareErrorCode.DeviceInitializeFailed,
-        'Protocol V2 romloader mode is only supported for Pro2.'
+        'Protocol V2 romloader mode is only supported for Pro2 and Neo.'
       );
     }
     const deviceStatusSupported = supportsProtocolV2Message(
@@ -1569,7 +1576,8 @@ export class Device extends EventEmitter {
     if (!this.state) return undefined;
     return (
       this.isProtocolV2() &&
-      this.getCurrentDeviceType() === EDeviceType.Pro2 &&
+      (this.getCurrentDeviceType() === EDeviceType.Pro2 ||
+        this.getCurrentDeviceType() === EDeviceType.Neo) &&
       this.state.status.mode === 'romloader'
     );
   }
@@ -1615,7 +1623,8 @@ export class Device extends EventEmitter {
     const isModeT =
       deviceType === EDeviceType.Touch ||
       deviceType === EDeviceType.Pro ||
-      deviceType === EDeviceType.Pro2;
+      deviceType === EDeviceType.Pro2 ||
+      deviceType === EDeviceType.Neo;
     const unlocked = this.state?.status.unlocked;
     const preCheckTouch = isModeT && unlocked === false;
     const passphraseProtection = this.getCurrentPassphraseProtection();

package/src/device/DeviceCommands.ts

@@ -54,8 +54,16 @@ const DEVICE_SESSION_CALLS = new Set([
   'DeviceSessionAskPin',
   'DeviceSessionAskPassphrase',
 ]);
-
-const PROTOCOL_V2_ACTION_CANCELLED_SUBCODE = 1;
+const DEVICE_CONTROL_CALLS = new Set([
+  'DeviceReboot',
+  'DeviceSettingsGet',
+  'DeviceSettingsSet',
+  'DeviceSettingsPageShow',
+  'DeviceCertificateWrite',
+  'DeviceCertificateRead',
+  'DeviceCertificateSign',
+  'DeviceMiscUsbMscControl',
+]);
 
 // Older Protocol V2 firmware may omit the cancellation subcode, so retain a
 // narrow message fallback for compatibility.
@@ -501,14 +509,9 @@ export class DeviceCommands {
         const normalizedMessage = message?.trim() ?? '';
         const isProtocolV2ActionCancelledFailure =
           this.device.isProtocolV2() && isProtocolV2ActionCancelledMessage(normalizedMessage);
-        const isProtocolV2ActionCancelledSubcode =
-          this.device.isProtocolV2() && subcode === PROTOCOL_V2_ACTION_CANCELLED_SUBCODE;
-        // DeviceErrorCode currently reuses subcode 1 for Busy. Resolve that
-        // domain-specific exception before applying the common cancellation map.
         const isProtocolV2DeviceBusyFailure =
           this.device.isProtocolV2() &&
-          callType.startsWith('Device') &&
-          !DEVICE_SESSION_CALLS.has(callType) &&
+          DEVICE_CONTROL_CALLS.has(callType) &&
           subcode === DeviceErrorCode.DeviceError_Busy;
         const isLegacyProtocolV2LockedFailure =
           this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
@@ -574,8 +577,8 @@ export class DeviceCommands {
             firmwareMessage: message,
           });
         } else if (
-          subcode === DeviceErrorCode.DeviceError_ActionCancelled ||
-          isProtocolV2ActionCancelledSubcode ||
+          (DEVICE_CONTROL_CALLS.has(callType) &&
+            subcode === DeviceErrorCode.DeviceError_ActionCancelled) ||
           isProtocolV2ActionCancelledFailure
         ) {
           error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled, message, {

package/src/device/DevicePool.ts

@@ -103,7 +103,7 @@ export class DevicePool extends EventEmitter {
       const device = this.devicesCache[connectId];
       if (device) {
         const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
-        if (exist) {
+        if (exist && !initOptions?.forceProtocolDetection) {
           // Log.debug('find existed Device: ', connectId);
           device.updateDescriptor(exist, true);
           await this._refreshRuntimeState(device, initOptions);
@@ -151,14 +151,23 @@ export class DevicePool extends EventEmitter {
     }
   }
 
-  static async _createDevice(descriptor: DeviceDescriptor, initOptions?: InitOptions) {
-    let device = this.getDeviceByPath(descriptor.path);
-    if (!device) {
-      device = Device.fromDescriptor(descriptor);
+  static async _createDevice(
+    descriptor: DeviceDescriptor,
+    initOptions?: InitOptions
+  ): Promise<Device> {
+    const cachedDevice = this.getDeviceByPath(descriptor.path);
+    const forceProtocolDetection = initOptions?.forceProtocolDetection === true;
+    const isNewDevice = !cachedDevice;
+    const device = cachedDevice ?? Device.fromDescriptor(descriptor);
+    if (isNewDevice || forceProtocolDetection) {
       device.deviceConnector = this.connector;
-      await device.connect(initOptions?.connectProtocol, {
-        forceProtocolDetection: initOptions?.forceProtocolDetection,
-      });
+      if (forceProtocolDetection && !isNewDevice) {
+        await device.acquire(initOptions?.connectProtocol, { forceProtocolDetection: true });
+      } else {
+        await device.connect(initOptions?.connectProtocol, {
+          forceProtocolDetection: initOptions?.forceProtocolDetection,
+        });
+      }
       try {
         await device.initialize(initOptions);
         if (initOptions?.refreshRuntimeState && device.isProtocolV2()) {

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -1,4 +1,4 @@
-import { EFirmwareType } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
 import {
   resolveDeviceBleFirmwareVersion,
@@ -386,7 +386,7 @@ export const buildProtocolV2FeaturesPayload = ({
     device_id: deviceId ?? undefined,
     session_id: cached?.sessionId ?? undefined,
     ble_name: bleName ?? undefined,
-    onekey_device_type: 'PRO2',
+    onekey_device_type: deviceType === EDeviceType.Unknown ? undefined : deviceType.toUpperCase(),
     passphrase_protection: passphraseProtection ?? undefined,
     bootloader_mode: bootloaderMode,
     passphraseState: cached?.passphraseState,

package/src/deviceProfile/protocolV2DeviceIdentity.ts

@@ -26,6 +26,9 @@ export const resolveProtocolV2DeviceIdentity = (
     case DeviceType.PRO2:
     case 'PRO2':
       return { deviceType: EDeviceType.Pro2, model: 'pro2' };
+    case DeviceType.NEO:
+    case 'NEO':
+      return { deviceType: EDeviceType.Neo, model: 'neo' };
     default:
       return { deviceType: EDeviceType.Unknown, model: null };
   }

package/src/protocols/protocol-v2/resources.ts

@@ -4,6 +4,7 @@ import { PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE } from '@onekeyfe/hd-transport';
 import type {
   IProtocolV2BootResources,
   IProtocolV2Resource,
+  IProtocolV2ResourceFile,
   IProtocolV2ResourceType,
   IProtocolV2Resources,
 } from '../../types';
@@ -247,23 +248,53 @@ function validateBootResources(value: unknown): IProtocolV2BootResources {
   if (resource.required !== false) {
     throw new Error('Invalid Pro2 boot resources required flag: expected false');
   }
-  if (resource.target !== 'CRATE') {
-    throw new Error('Invalid Pro2 boot resources target: expected CRATE');
+  if (resource.target !== 'RES') {
+    throw new Error('Invalid Pro2 boot resources target: expected RES');
   }
-  if (typeof resource.url !== 'string' || !resource.url.startsWith('https://')) {
-    throw new Error('Invalid Pro2 boot resources url');
+  if (
+    resource.manifestUrl !== undefined &&
+    (typeof resource.manifestUrl !== 'string' || !resource.manifestUrl.startsWith('https://'))
+  ) {
+    throw new Error('Invalid Pro2 boot resources manifestUrl');
   }
-  if (!Number.isSafeInteger(resource.size) || Number(resource.size) <= 0) {
-    throw new Error('Invalid Pro2 boot resources size');
+  if (!Array.isArray(resource.files) || resource.files.length === 0) {
+    throw new Error('Invalid Pro2 boot resources files');
+  }
+  const files = resource.files.map((value, index): IProtocolV2ResourceFile => {
+    if (!value || typeof value !== 'object') {
+      throw new Error(`Invalid Pro2 boot resource file at files[${index}]`);
+    }
+    const file = value as Partial<IProtocolV2ResourceFile>;
+    if (typeof file.url !== 'string' || !file.url.startsWith('https://')) {
+      throw new Error(`Invalid Pro2 boot resource url at files[${index}]`);
+    }
+    if (
+      typeof file.devicePath !== 'string' ||
+      !file.devicePath.startsWith('vol0:/') ||
+      file.devicePath.includes('..') ||
+      file.devicePath.includes('\\\\')
+    ) {
+      throw new Error(`Invalid Pro2 boot resource devicePath at files[${index}]`);
+    }
+    if (!Number.isSafeInteger(file.size) || Number(file.size) <= 0) {
+      throw new Error(`Invalid Pro2 boot resource size at files[${index}]`);
+    }
+    return {
+      ...(typeof file.name === 'string' && file.name ? { name: file.name } : undefined),
+      url: file.url,
+      devicePath: file.devicePath,
+      size: Number(file.size),
+      fileHash: normalizeHex(file.fileHash, SHA256_HEX_LENGTH, `boot files[${index}].fileHash`),
+    };
+  });
+  if (new Set(files.map(file => file.devicePath)).size !== files.length) {
+    throw new Error('Invalid Pro2 boot resources files: duplicate devicePath');
   }
   return {
     required: false,
-    target: 'CRATE',
-    url: resource.url,
-    size: Number(resource.size),
-    fileHash: normalizeHex(resource.fileHash, SHA256_HEX_LENGTH, 'boot fileHash'),
-    payloadHash: normalizeHex(resource.payloadHash, SHA3_512_HEX_LENGTH, 'boot payloadHash'),
-    headerHash: normalizeHex(resource.headerHash, SHA3_512_HEX_LENGTH, 'boot headerHash'),
+    target: 'RES',
+    ...(resource.manifestUrl ? { manifestUrl: resource.manifestUrl } : undefined),
+    files,
   };
 }
 
@@ -352,7 +383,7 @@ function bytesToHex(bytes: Uint8Array): string {
 /** Verify the complete downloaded file before any device mutation. */
 export function isProtocolV2ResourceFileValid(
   binary: ArrayBuffer,
-  resource: Pick<IProtocolV2Resource, 'size' | 'fileHash'>
+  resource: Pick<IProtocolV2ResourceFile, 'size' | 'fileHash'>
 ): boolean {
   if (binary.byteLength !== resource.size) return false;
   return bytesToHex(sha256(new Uint8Array(binary))) === resource.fileHash.toLowerCase();

package/src/types/api/checkAllFirmwareRelease.ts

@@ -54,7 +54,7 @@ export type AllFirmwareRelease = {
   bridge?: FirmwareRelease;
   features?: Features;
   protocol?: 'V1' | 'V2';
-  deviceType?: 'pro2';
+  deviceType?: 'pro2' | 'neo';
   firmwareType?: EFirmwareType;
   status?: ProtocolV2FirmwareReleaseStatus;
   hasUpgrade?: boolean;

package/src/types/api/firmwareUpdate.ts

@@ -83,8 +83,6 @@ export interface FirmwareUpdateV4Params {
   romloaderBinary?: ArrayBuffer;
   /** FW_MGMT_TARGET_BOOTLOADER = 3 */
   bootloaderBinary?: ArrayBuffer;
-  /** FW_MGMT_TARGET_CRATE = 1; optional Pro2 startup resources. */
-  bootResourcesBinary?: ArrayBuffer;
   /** FW_MGMT_TARGET_APPLICATION_P1 = 4 */
   applicationP1Binary?: ArrayBuffer;
   /** FW_MGMT_TARGET_APPLICATION_P2 = 5 */
@@ -98,12 +96,14 @@ export interface FirmwareUpdateV4Params {
   se04Binary?: ArrayBuffer;
   forcedUpdateRes?: boolean;
   /**
-   * RESC bundle okpkg files written directly to devicePath through FilesystemFileWrite.
-   * Manual mode installs them without version comparison.
+   * Arbitrary Protocol V2 resource files written directly with FilesystemFileWrite.
+   * Use this for manifest-driven boot resources and other non-RESC files.
    */
-  resourceBundleFiles?: Array<{
+  resourceFiles?: Array<{
     binary: ArrayBuffer;
     devicePath: string;
+    size?: number;
+    fileHash?: string;
   }>;
 }
 

package/src/types/device.ts

@@ -374,14 +374,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: [
@@ -391,6 +398,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],
 };
@@ -402,7 +410,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]: [],
 };
 

package/src/types/settings.ts

@@ -81,19 +81,22 @@ export type IProtocolV2Resource = {
   headerHash: string;
 };
 
-/** Optional Pro2 startup-resource CRATE installed by the bootloader updater. */
-export type IProtocolV2BootResources = {
-  required: false;
-  target: 'CRATE';
+/** A file from the Protocol V2 resource manifest, written directly with FileWrite. */
+export type IProtocolV2ResourceFile = {
+  name?: string;
   url: string;
-  /** Complete CRATE file size in bytes. */
+  devicePath: string;
   size: number;
-  /** SHA-256 of the complete CRATE file. */
+  /** SHA-256 of the complete file. */
   fileHash: string;
-  /** SHA3-512 payload_hash from the signed CRATE header. */
-  payloadHash: string;
-  /** SHA3-512 header_hash from the signed CRATE header. */
-  headerHash: string;
+};
+
+/** Optional Protocol V2 boot resources restored as individual files. */
+export type IProtocolV2BootResources = {
+  required: false;
+  target: 'RES';
+  manifestUrl?: string;
+  files: IProtocolV2ResourceFile[];
 };
 
 export type IProtocolV2Resources = {
@@ -166,19 +169,25 @@ export type IBLEFirmwareReleaseInfo = {
 };
 
 type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
+type ILegacyKnownDevice = Exclude<IKnownDevice, 'neo'>;
+
+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;
+};
 
 export type DeviceTypeMap = {
-  [k in IKnownDevice]: {
-    firmware: IFirmwareReleaseInfo[];
-    /** Pro2 Protocol V2 payload package set */
-    'firmware-v1'?: IFirmwareReleaseInfo[];
-    'firmware-v2'?: IFirmwareReleaseInfo[];
-    'firmware-v8'?: IFirmwareReleaseInfo[];
-    'firmware-btc-v8'?: IFirmwareReleaseInfo[];
-    ble: IBLEFirmwareReleaseInfo[];
-    /** Independent Pro2 resource release configuration. */
-    resources?: IProtocolV2Resources;
-  };
+  [k in ILegacyKnownDevice]: IDeviceReleaseInfo;
+} & {
+  /** Optional until every remote-config producer publishes a Neo entry. */
+  neo?: IDeviceReleaseInfo;
 };
 
 export type AssetsMap = {

package/src/utils/deviceFeaturesCompat.ts

@@ -60,6 +60,8 @@ export const resolveDeviceType = (features?: DeviceFeaturesInput): IDeviceType =
       return EDeviceType.Pro;
     case 'PRO2':
       return EDeviceType.Pro2;
+    case 'NEO':
+      return EDeviceType.Neo;
     case 'PURE':
       return EDeviceType.ClassicPure;
     default:
@@ -69,6 +71,9 @@ export const resolveDeviceType = (features?: DeviceFeaturesInput): IDeviceType =
   if (compatible.model?.toString().toLowerCase() === EDeviceType.Pro2) {
     return EDeviceType.Pro2;
   }
+  if (compatible.model?.toString().toLowerCase() === EDeviceType.Neo) {
+    return EDeviceType.Neo;
+  }
 
   const serialNo = resolveDeviceSerialNo(features);
   const prefix = serialNo.slice(0, 2).toLowerCase();

package/src/utils/deviceFeaturesUtils.ts

@@ -74,7 +74,8 @@ export const supportInputPinOnSoftware = (features?: Features): SupportFeatureTy
   if (
     deviceType === EDeviceType.Touch ||
     deviceType === EDeviceType.Pro ||
-    deviceType === EDeviceType.Pro2
+    deviceType === EDeviceType.Pro2 ||
+    deviceType === EDeviceType.Neo
   ) {
     return { support: false };
   }
@@ -90,7 +91,8 @@ export const supportNewPassphrase = (features?: Features): SupportFeatureType =>
   if (
     deviceType === EDeviceType.Touch ||
     deviceType === EDeviceType.Pro ||
-    deviceType === EDeviceType.Pro2
+    deviceType === EDeviceType.Pro2 ||
+    deviceType === EDeviceType.Neo
   ) {
     return { support: true };
   }
@@ -143,7 +145,8 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   const isModeT =
     deviceType === EDeviceType.Touch ||
     deviceType === EDeviceType.Pro ||
-    deviceType === EDeviceType.Pro2;
+    deviceType === EDeviceType.Pro2 ||
+    deviceType === EDeviceType.Neo;
 
   // 如果可以获取到 passphraseState，但是设备 features 显示设备未开启 passphrase，需要刷新设备状态
   // if passphraseState can be obtained, but the device features show that the device has not enabled passphrase, the device status needs to be refreshed

package/src/utils/deviceInfoUtils.ts

@@ -31,6 +31,7 @@ export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
   if (/^Touch/i.test(name)) return EDeviceType.Touch;
 
   if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name)) return EDeviceType.Pro2;
+  if (/\bNeo\b/i.test(name) || /^Neo/i.test(name)) return EDeviceType.Neo;
   if (/\bPro\b/i.test(name) || /^Pro/i.test(name)) return EDeviceType.Pro;
 
   return EDeviceType.Unknown;
@@ -93,6 +94,7 @@ export const getMethodVersionRange = (
   }
 
   const modelFallbacks: IDeviceModel[] = [
+    'model_pro2',
     'model_classic1s',
     'model_classic',
     'model_mini',

package/src/utils/deviceSettings.ts

@@ -127,6 +127,7 @@ export const getLanguageConfig = (deviceType: IDeviceType): Record<string, strin
       keys = Object.keys(LANGUAGE_LABELS) as LanguageKey[];
       break;
     case EDeviceType.Pro2:
+    case EDeviceType.Neo:
       return PRO2_LANGUAGE_OPTIONS.map(option => ({ ...option }));
     default:
       keys = [];
@@ -176,6 +177,7 @@ export const getAutoLockOptions = (
     case EDeviceType.Touch:
     case EDeviceType.Pro:
     case EDeviceType.Pro2:
+    case EDeviceType.Neo:
       return withNever([30_000, 60_000, 120_000, 300_000, 600_000, 1_800_000], protocol);
     default:
       return [];
@@ -197,6 +199,7 @@ export const getAutoShutDownOptions = (
     case EDeviceType.Pro:
       return withNever([60_000, 120_000, 300_000, 600_000], protocol);
     case EDeviceType.Pro2:
+    case EDeviceType.Neo:
       return withNever([60_000, 120_000, 300_000, 600_000, 1_800_000], protocol);
     default:
       return [];