@onekeyfe/hd-core 1.2.0-alpha.22 → 1.2.0-alpha.24

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

@@ -1,6 +1,7 @@
 import { LoggerNames, getLogger } from '../../utils';
 import { isDeviceLockedError } from './lockedError';
 import { isProtocolV2UiEnabled, resolveProtocolV2UiInteraction } from './uiInteraction';
+import { restoreProtocolV2WalletSession } from './walletSession';
 
 import type { BaseMethod } from '../../api/BaseMethod';
 import type { Device } from '../../device/Device';
@@ -10,9 +11,14 @@ const Log = getLogger(LoggerNames.Core);
 
 type RunnableMethod = Pick<
   BaseMethod,
-  'run' | 'unlockPolicy' | 'protocolV2UiInteraction' | 'protocolV2UiMode' | 'params' | 'payload'
+  | 'run'
+  | 'unlockPolicy'
+  | 'protocolV2UiInteraction'
+  | 'protocolV2UiMode'
+  | 'params'
+  | 'payload'
+  | 'useDevicePassphraseState'
 > & { name?: string };
-type UnlockableDevice = Pick<Device, 'isProtocolV2' | 'unlockDevice' | 'features'>;
 type UiInteractionCoordinator = Pick<
   ProtocolV2UiInteractionCoordinator,
   'enterMethodInteraction' | 'enterUnlockInteraction' | 'resumeMethodInteraction'
@@ -20,7 +26,7 @@ type UiInteractionCoordinator = Pick<
 
 export async function runMethodWithUnlockRetry(
   method: RunnableMethod,
-  device: UnlockableDevice,
+  device: Device,
   uiCoordinator?: UiInteractionCoordinator
 ) {
   const shouldEmitUi = isProtocolV2UiEnabled(method);
@@ -59,6 +65,17 @@ export async function runMethodWithUnlockRetry(
     }
     await device.unlockDevice();
     Log.debug('Protocol V2 unlock completed', { method: method.name });
+    const expectedPassphraseState = method.payload?.useEmptyPassphrase
+      ? undefined
+      : method.payload?.passphraseState ?? device.passphraseState;
+    if (
+      method.useDevicePassphraseState &&
+      typeof expectedPassphraseState === 'string' &&
+      expectedPassphraseState.length > 0
+    ) {
+      await restoreProtocolV2WalletSession(device, expectedPassphraseState);
+      Log.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
+    }
     if (shouldEmitUi) {
       uiCoordinator?.resumeMethodInteraction();
     }

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

@@ -1,10 +1,11 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { DEVICE } from '../../events';
 import { assertCompleteDeviceSession } from './deviceSession';
 import { isDeviceLockedError } from './lockedError';
 
-import type { DeviceSessionOpen } from '@onekeyfe/hd-transport';
+import type { DeviceSessionGet } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
 
 export async function requestProtocolV2DeviceStatus(device: Device) {
@@ -23,15 +24,33 @@ const negotiateEventlessWalletSession = async (device: Device) => {
   });
 };
 
-const openDeviceSession = async (device: Device, request: DeviceSessionOpen) => {
+const getDeviceSession = async (device: Device, request: DeviceSessionGet) => {
   try {
-    return await device.commands.typedCall('DeviceSessionOpen', 'DeviceSession', request);
+    return await device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
   } catch (error) {
     if (!isDeviceLockedError(error)) {
       throw error;
     }
-    await device.unlockDevice();
-    return device.commands.typedCall('DeviceSessionOpen', 'DeviceSession', request);
+    await device.unlockDevice(DeviceSessionPinType.Main);
+    return device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
+  }
+};
+
+const askDevicePassphrase = async (device: Device, passphrase?: string) => {
+  const request = () =>
+    device.commands.typedCall(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      passphrase ? { passphrase } : {}
+    );
+  try {
+    return await request();
+  } catch (error) {
+    if (!isDeviceLockedError(error)) {
+      throw error;
+    }
+    await device.unlockDevice(DeviceSessionPinType.Main);
+    return request();
   }
 };
 
@@ -42,13 +61,16 @@ const selectDeviceSession = async (device: Device) => {
     reason: 'open-wallet' as const,
   };
   const response = await device.commands.promptPassphrase(
-    { existsAttachPinUser, ...metadata },
+    {
+      existsAttachPinUser,
+      ...metadata,
+    },
     { cancelDeviceOnReject: false }
   );
-  const hostPassphrase =
-    typeof response.passphrase === 'string' ? response.passphrase.normalize('NFKD') : undefined;
+  const hasHostPassphrase =
+    typeof response.passphrase === 'string' && response.passphrase.length > 0;
   const selections = [
-    !!hostPassphrase,
+    hasHostPassphrase,
     response.passphraseOnDevice === true,
     response.attachPinOnDevice === true,
   ].filter(Boolean).length;
@@ -68,17 +90,18 @@ const selectDeviceSession = async (device: Device) => {
       );
     }
     device.emit(DEVICE.ATTACH_PIN_ON_DEVICE, device, metadata);
-    return openDeviceSession(device, { select: { attach_pin_on_device: {} } });
+    await device.unlockDevice(DeviceSessionPinType.AttachToPin);
+    return getDeviceSession(device, {});
   }
 
-  if (response.passphraseOnDevice) {
-    device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
-    return openDeviceSession(device, { select: { passphrase_on_device: {} } });
+  if (hasHostPassphrase) {
+    await askDevicePassphrase(device, response.passphrase);
+    return getDeviceSession(device, {});
   }
 
-  return openDeviceSession(device, {
-    select: { host_passphrase: { passphrase: hostPassphrase as string } },
-  });
+  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
+  await askDevicePassphrase(device);
+  return getDeviceSession(device, {});
 };
 
 export async function getProtocolV2WalletSession(
@@ -87,10 +110,12 @@ export async function getProtocolV2WalletSession(
     initSession?: boolean;
     expectedPassphraseState?: string;
     onlyMainPin?: boolean;
+    resumeOnly?: boolean;
   }
 ) {
   if (options?.initSession) {
     device.clearInternalState();
+    device.passphraseState = undefined;
   }
 
   await negotiateEventlessWalletSession(device);
@@ -103,7 +128,7 @@ export async function getProtocolV2WalletSession(
     : options?.expectedPassphraseState ?? device.passphraseState;
 
   if (device.features?.unlocked === false) {
-    await device.unlockDevice();
+    await device.unlockDevice(DeviceSessionPinType.Main);
   }
 
   if (options?.onlyMainPin || device.getCurrentPassphraseProtection() === false) {
@@ -122,7 +147,7 @@ export async function getProtocolV2WalletSession(
 
   if (cachedSessionId && expectedPassphraseState) {
     try {
-      response = await openDeviceSession(device, { resume: { session_id: cachedSessionId } });
+      response = await getDeviceSession(device, { session_id: cachedSessionId });
       resumed = true;
     } catch (error) {
       device.clearInternalState();
@@ -131,6 +156,10 @@ export async function getProtocolV2WalletSession(
   }
 
   if (!response) {
+    if (options?.resumeOnly) {
+      device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+    }
     response = await selectDeviceSession(device);
   }
 
@@ -161,3 +190,13 @@ export async function getProtocolV2WalletSession(
     resumed,
   };
 }
+
+export async function restoreProtocolV2WalletSession(
+  device: Device,
+  expectedPassphraseState: string
+) {
+  return getProtocolV2WalletSession(device, {
+    expectedPassphraseState,
+    resumeOnly: true,
+  });
+}

package/src/topLevelInject.ts

@@ -1,7 +1,6 @@
 import EventEmitter from 'events';
 
 import { createCoreApi } from './inject';
-import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { ConnectSettings } from './types/settings';
 import type { CoreApi } from './types/api';
@@ -47,10 +46,7 @@ export const topLevelInject = () => {
       lowLevelApi?.removeAllListeners(type);
     },
 
-    dispose: async () => {
-      unregisterFirmwareUpdateHostBinding();
-      await lowLevelApi?.dispose();
-    },
+    dispose: () => lowLevelApi?.dispose(),
 
     uiResponse: response => lowLevelApi?.uiResponse(response),
 

package/src/types/api/checkAllFirmwareRelease.ts

@@ -2,7 +2,6 @@ import type { IBLEFirmwareReleaseInfo } from '../settings';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
 import type { Features, IDeviceBLEFirmwareStatus, IDeviceFirmwareStatus } from '../device';
-import type { FirmwareUpdatePlan } from './firmwareUpdatePlan';
 
 export type FirmwareRelease = {
   shouldUpdate?: boolean;
@@ -21,13 +20,11 @@ export type AllFirmwareRelease = {
   bootloader?: FirmwareRelease;
   bridge?: FirmwareRelease;
   features?: Features;
-  firmwareUpdatePlan?: FirmwareUpdatePlan;
 };
 
 export type CheckAllFirmwareReleaseParams = {
   checkBridgeRelease?: boolean;
   firmwareType?: EFirmwareType;
-  platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
 };
 
 export declare function checkAllFirmwareRelease(

package/src/types/api/deviceUpdateBootloader.ts

@@ -1,15 +1,9 @@
 import type { Success } from '@onekeyfe/hd-transport';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
-import type { FirmwareArtifactReader, FirmwareArtifactReference } from './firmwareUpdate';
-import type { FirmwareUpdatePreparedPlan } from './firmwareUpdatePreparedPlan';
 import type { Response } from '../params';
 
 export type DeviceUpdateBootloaderParams = {
-  preparedPlan?: FirmwareUpdatePreparedPlan;
-  hostBindingGeneration?: number;
   binary?: ArrayBuffer;
-  artifact?: FirmwareArtifactReference;
-  artifactReader?: FirmwareArtifactReader;
   firmwareType?: EFirmwareType;
 };
 

package/src/types/api/export.ts

@@ -25,29 +25,11 @@ export type {
   DeviceUploadResourceResponse,
 } from './deviceUploadResource';
 export type {
-  FirmwareArtifactReader,
-  FirmwareArtifactReference,
-  FirmwareUpdateHostBinding,
-  FirmwareUpdateArtifactParams,
   FirmwareUpdateParams,
   FirmwareUpdateBinaryParams,
   FirmwareUpdateV3Params,
   FirmwareUpdateV4Params,
-  FirmwareUpdateV4Target,
 } from './firmwareUpdate';
-export type {
-  FirmwareUpdatePlan,
-  FirmwareUpdatePlanArtifact,
-  FirmwareUpdatePlanArtifactRole,
-  FirmwareUpdatePlanTarget,
-} from './firmwareUpdatePlan';
-export type {
-  FirmwareUpdatePreparedArtifact,
-  FirmwareUpdatePreparedArtifactInput,
-  FirmwareUpdatePreparedEntry,
-  FirmwareUpdatePreparedPlan,
-} from './firmwareUpdatePreparedPlan';
-export type { FirmwareUpdateCapabilities } from './firmwareUpdateCapabilities';
 export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
 
 export type { AllNetworkAddressParams, AllNetworkGetAddressParams } from './allNetworkGetAddress';

package/src/types/api/firmwareUpdate.ts

@@ -1,53 +1,14 @@
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { PROTO } from '../../constants';
 import type { Params, Response } from '../params';
-import type { FirmwareUpdatePreparedPlan } from './firmwareUpdatePreparedPlan';
 
 type IUpdateType = 'firmware' | 'ble';
 
-export interface FirmwareArtifactReference {
-  artifactRef: string;
-  size: number;
-  sha256: string;
-}
-
-export interface FirmwareArtifactReader {
-  open(input: { artifactRef: string }): Promise<{
-    readerId: string;
-    size: number;
-  }>;
-  read(input: { readerId: string; offset: number; length: number }): Promise<{
-    data: ArrayBuffer;
-    bytesRead: number;
-    eof: boolean;
-  }>;
-  close(input: { readerId: string }): Promise<void>;
-}
-
-export interface FirmwareUpdateHostBinding {
-  artifactReader: FirmwareArtifactReader;
-}
-
 export interface FirmwareUpdateBinaryParams {
   binary: ArrayBuffer;
   updateType: IUpdateType;
 }
 
-export interface FirmwareUpdateArtifactParams {
-  preparedPlan: FirmwareUpdatePreparedPlan;
-  hostBindingGeneration: number;
-  artifact: FirmwareArtifactReference;
-  resourceArtifact?: FirmwareArtifactReference;
-  resourceEntries?: Array<{
-    entryName: string;
-    artifact: FirmwareArtifactReference;
-  }>;
-  updateType: IUpdateType;
-  forcedUpdateRes?: boolean;
-  isUpdateBootloader?: boolean;
-  firmwareType?: EFirmwareType;
-}
-
 export interface FirmwareUpdateParams {
   version?: number[];
   updateType: IUpdateType;
@@ -76,14 +37,8 @@ export declare function firmwareUpdateV2(
   connectId: string | undefined,
   params: Params<FirmwareUpdateBinaryParams & Platform>
 ): Response<PROTO.Success>;
-export declare function firmwareUpdateV2(
-  connectId: string | undefined,
-  params: Params<FirmwareUpdateArtifactParams & Platform>
-): Response<PROTO.Success>;
 
 export interface FirmwareUpdateV3Params {
-  preparedPlan?: FirmwareUpdatePreparedPlan;
-  hostBindingGeneration?: number;
   bleVersion?: number[];
   bleBinary?: ArrayBuffer;
   chunkSize?: number;
@@ -100,17 +55,6 @@ export interface FirmwareUpdateV3Params {
   firmwareType?: EFirmwareType;
 
   platform: IPlatform;
-
-  artifactReader?: FirmwareArtifactReader;
-  artifacts?: {
-    ble?: FirmwareArtifactReference;
-    firmware?: FirmwareArtifactReference;
-    bootloader?: FirmwareArtifactReference;
-    resourceEntries?: Array<{
-      entryName: string;
-      artifact: FirmwareArtifactReference;
-    }>;
-  };
 }
 
 /**
@@ -129,14 +73,10 @@ export type FirmwareUpdateV4Target =
   | 'se04';
 
 export interface FirmwareUpdateV4Params {
-  preparedPlan?: FirmwareUpdatePreparedPlan;
-  hostBindingGeneration?: number;
   platform: IPlatform;
-  expectedDeviceId?: string;
   chunkSize?: number;
   firmwareType?: EFirmwareType;
   targetsToUpdate?: FirmwareUpdateV4Target[];
-  expectedTargetVersions?: Partial<Record<FirmwareUpdateV4Target, string>>;
 
   /** FW_MGMT_TARGET_ROMLOADER = 2; Pro2 cannot install it through firmwareUpdateV4. */
   romloaderBinary?: ArrayBuffer;
@@ -162,24 +102,8 @@ export interface FirmwareUpdateV4Params {
     binary: ArrayBuffer;
     devicePath: string;
   }>;
-  artifactReader?: FirmwareArtifactReader;
-  componentArtifacts?: Partial<
-    Record<Exclude<FirmwareUpdateV4Target, 'resource'>, FirmwareArtifactReference>
-  >;
-  resourceBundleArtifacts?: Array<{
-    name: string;
-    artifact: FirmwareArtifactReference;
-  }>;
 }
 
-export declare function registerFirmwareUpdateHostBinding(
-  binding: FirmwareUpdateHostBinding
-): number;
-
-export declare function unregisterFirmwareUpdateHostBinding(generation?: number): boolean;
-
-export declare function getFirmwareUpdateHostBindingGeneration(): number;
-
 export declare function firmwareUpdateV3(
   connectId: string | undefined,
   params: Params<FirmwareUpdateV3Params>

package/src/types/api/getPassphraseState.ts

@@ -3,10 +3,11 @@ import type { CommonParams, Response } from '../params';
 export type GetPassphraseStateParams = CommonParams;
 
 /**
- * Legacy Protocol V1 wallet API.
+ * Compatibility wallet-state API for existing App integrations.
  *
- * This remains supported for Protocol V1 integrations. New cross-protocol integrations
- * and all Protocol V2 callers should use `openWalletSession`.
+ * Protocol V1 keeps its parameterless firmware flow. Protocol V2 maps the existing
+ * `useEmptyPassphrase` and `initSession` intent to the device-only wallet-session flow.
+ * New integrations should prefer `openWalletSession` for explicit wallet intent.
  */
 export declare function getPassphraseState(
   connectId?: string,

package/src/types/api/index.ts

@@ -2,6 +2,7 @@ import type {
   deviceGetOnboardingStatus,
   deviceReboot,
   deviceUploadWallpaper,
+  testProtocolV2Ping,
   uploadPortfolio,
 } from './protocolV2';
 import type { off, on, removeAllListeners } from './event';
@@ -29,15 +30,7 @@ import type {
   firmwareUpdateV2,
   firmwareUpdateV3,
   firmwareUpdateV4,
-  getFirmwareUpdateHostBindingGeneration,
-  registerFirmwareUpdateHostBinding,
-  unregisterFirmwareUpdateHostBinding,
 } from './firmwareUpdate';
-import type { getFirmwareUpdateCapabilities } from './firmwareUpdateCapabilities';
-import type {
-  prepareFirmwareUpdatePlan,
-  validateFirmwareUpdatePreparedPlan,
-} from './firmwareUpdatePreparedPlan';
 import type { promptWebDeviceAccess } from './promptWebDeviceAccess';
 import type { deviceReset } from './deviceReset';
 import type { deviceRecovery } from './deviceRecovery';
@@ -157,6 +150,7 @@ export type { DeviceStateScope, GetDeviceStateParams } from './getDeviceState';
 export type { GetPassphraseStateParams } from './getPassphraseState';
 export type { OpenWalletSessionParams, OpenWalletSessionPayload } from './openWalletSession';
 export type { ClearSessionCacheParams, ClearSessionCachePayload } from './sessionCache';
+export type { TestProtocolV2PingParams } from './protocolV2';
 
 export type CoreApi = {
   /**
@@ -180,6 +174,7 @@ export type CoreApi = {
    * Test function
    */
   testInitializeDeviceDuration: typeof testInitializeDeviceDuration;
+  testProtocolV2Ping: typeof testProtocolV2Ping;
   preInitialize: typeof preInitialize;
 
   /**
@@ -227,12 +222,6 @@ export type CoreApi = {
   firmwareUpdateV2: typeof firmwareUpdateV2;
   firmwareUpdateV3: typeof firmwareUpdateV3;
   firmwareUpdateV4: typeof firmwareUpdateV4;
-  registerFirmwareUpdateHostBinding: typeof registerFirmwareUpdateHostBinding;
-  unregisterFirmwareUpdateHostBinding: typeof unregisterFirmwareUpdateHostBinding;
-  getFirmwareUpdateHostBindingGeneration: typeof getFirmwareUpdateHostBindingGeneration;
-  getFirmwareUpdateCapabilities: typeof getFirmwareUpdateCapabilities;
-  prepareFirmwareUpdatePlan: typeof prepareFirmwareUpdatePlan;
-  validateFirmwareUpdatePreparedPlan: typeof validateFirmwareUpdatePreparedPlan;
   cipherKeyValue: typeof cipherKeyValue;
 
   /**

package/src/types/api/openWalletSession.ts

@@ -5,35 +5,16 @@ export type OpenWalletSessionParams =
       mode: 'standard';
       deviceId?: never;
       passphraseState?: never;
-      useEmptyPassphrase?: never;
-      initSession?: never;
     }
   | {
       mode: 'select-hidden';
       deviceId?: never;
       passphraseState?: never;
-      useEmptyPassphrase?: never;
-      initSession?: never;
     }
   | {
       mode: 'resume-hidden';
       deviceId: string;
       passphraseState: string;
-      useEmptyPassphrase?: never;
-      initSession?: never;
-    }
-  | {
-      /**
-       * Compatibility form. `useEmptyPassphrase: true` opens the standard wallet;
-       * otherwise `initSession: true` starts a fresh hidden-wallet selection, a
-       * complete wallet binding resumes a hidden wallet, and no binding starts the
-       * hidden-wallet selection flow.
-       */
-      mode?: undefined;
-      useEmptyPassphrase?: boolean;
-      initSession?: boolean;
-      deviceId?: string;
-      passphraseState?: string;
     };
 
 type OpenWalletSessionPayloadBase = {

package/src/types/api/protocolV2.ts

@@ -27,6 +27,16 @@ export type FileInfo = {
 
 // ── Method signatures ─────────────────────────────────────────────────────
 
+export type TestProtocolV2PingParams = CommonParams & {
+  /** Firmware diagnostic echo payload, limited to 63 UTF-8 bytes. */
+  message?: string;
+};
+
+export declare function testProtocolV2Ping(
+  connectId: string,
+  params?: TestProtocolV2PingParams
+): Response<Success>;
+
 export declare function deviceReboot(
   connectId: string,
   params: CommonParams & DeviceRebootParams

package/src/types/settings.ts

@@ -31,8 +31,6 @@ 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>;
@@ -57,7 +55,6 @@ export type IProtocolV2FirmwareComponent = {
   target: IProtocolV2FirmwareComponentTarget;
   url: string;
   fingerprint?: string;
-  expectedSize?: number;
   version?: IVersionArray;
 };
 
@@ -67,8 +64,6 @@ export type IProtocolV2ResourceBundle = {
   name: string;
   /** Download URL. */
   url: string;
-  fingerprint?: string;
-  expectedSize?: number;
   /** Device target path, such as vol0:/bundles/images/images.okpkg. */
   devicePath: string;
   /** okpkg payload_version used to skip matching content after FileRead. */
@@ -90,16 +85,10 @@ 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;
@@ -112,7 +101,6 @@ export type IFirmwareReleaseInfo = {
     [k in ILocale]: string;
   };
   fingerprint: string;
-  expectedSize?: number;
   version: IVersionArray;
   changelog: {
     [k in ILocale]: string;
@@ -128,7 +116,6 @@ export type IBLEFirmwareReleaseInfo = {
   webUpdate: string;
   fingerprint: string;
   fingerprintWeb: string;
-  expectedSize?: number;
   version: IVersionArray;
   changelog: {
     [k in ILocale]: string;

package/src/utils/deviceInfoUtils.ts

@@ -1,4 +1,3 @@
-import { isEmpty } from 'lodash';
 import { EDeviceType } from '@onekeyfe/hd-shared';
 
 import { DeviceModelToTypes } from '../types';
@@ -64,12 +63,12 @@ export const getDeviceLabel = (features?: DeviceFeaturesInput) => {
   const deviceType = getDeviceType(features);
   if (deviceType == null) return null;
 
-  if ('label' in features && typeof features.label === 'string' && !isEmpty(features.label)) {
+  if ('label' in features && typeof features.label === 'string' && features.label.length > 0) {
     return features.label;
   }
 
   const bleName = getDeviceBleName(features);
-  if (!isEmpty(bleName)) return bleName;
+  if (bleName) return bleName;
 
   if (deviceType === EDeviceType.ClassicPure) {
     return 'OneKey Classic 1S';