@onekeyfe/hd-core 1.2.0-alpha.9 → 1.2.0-alpha.90

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

@@ -1,22 +1,33 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType, DeviceSessionSeedDomain } from '@onekeyfe/hd-transport';
 
+import { DEVICE } from '../../events';
+import { assertCompleteDeviceSession } from './deviceSession';
+
+import type { DeviceSessionAskPassphrase, DeviceSessionGet } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
 
-const getErrorText = (error: unknown) => {
-  if (error instanceof Error) return `${error.name} ${error.message}`;
-  if (typeof error === 'string') return error;
-  if (error && typeof error === 'object') {
-    const record = error as Record<string, unknown>;
-    return [record.code, record.errorCode, record.message, record.reason]
-      .filter(value => value !== undefined && value !== null)
-      .join(' ');
+const HOST_PASSPHRASE_MAX_BYTES = 50;
+
+const isWalletSessionInvalidError = (error: unknown) =>
+  typeof error === 'object' &&
+  error !== null &&
+  'errorCode' in error &&
+  (error as { errorCode?: unknown }).errorCode === HardwareErrorCode.WalletSessionInvalid;
+
+const utf8ByteLength = (value: string): number | undefined => {
+  let length = 0;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint >= 0xd800 && codePoint <= 0xdfff) return undefined;
+    if (codePoint <= 0x7f) length += 1;
+    else if (codePoint <= 0x7ff) length += 2;
+    else if (codePoint <= 0xffff) length += 3;
+    else length += 4;
   }
-  return String(error ?? '');
+  return length;
 };
 
-export const isProtocolV2InvalidSessionError = (error: unknown) =>
-  getErrorText(error).toLowerCase().includes('failure_invalidsession');
-
 export async function requestProtocolV2DeviceStatus(device: Device) {
   const { message } = await device.commands.typedCall('DeviceStatusGet', 'DeviceStatus', {});
   return message;
@@ -27,57 +38,426 @@ export async function refreshProtocolV2DeviceStatus(device: Device) {
   return device.updateProtocolV2Status(status);
 }
 
+export async function ensureProtocolV2WalletSessionUnlocked(device: Device) {
+  if (!device.isProtocolV2() || device.isBootloader?.() || device.isRomloader?.()) {
+    return false;
+  }
+
+  await refreshProtocolV2DeviceStatus(device);
+  if (device.state?.status.unlocked !== false) {
+    return false;
+  }
+
+  await device.unlockDevice(DeviceSessionPinType.Main, {
+    source: 'unlock-coordinator',
+    reason: 'device-locked',
+    deviceOnly: true,
+  });
+  return true;
+}
+
+const negotiateEventlessWalletSession = async (device: Device) => {
+  await device.ensureProtocolV2RuntimeContext();
+};
+
+const getDeviceSession = async (device: Device, request: DeviceSessionGet) =>
+  device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
+
+const buildDeviceSessionGetRequest = ({
+  sessionId,
+  expectedPassphraseState,
+  deriveCardano,
+}: {
+  sessionId?: string;
+  expectedPassphraseState?: string;
+  deriveCardano?: boolean;
+} = {}): DeviceSessionGet => ({
+  ...(sessionId ? { session_id: sessionId } : {}),
+  ...(expectedPassphraseState ? { btc_test_address: expectedPassphraseState } : {}),
+  seed_domains:
+    deriveCardano === undefined
+      ? []
+      : [
+          DeviceSessionSeedDomain.SeedDomain_Standard,
+          ...(deriveCardano ? [DeviceSessionSeedDomain.SeedDomain_Cardano] : []),
+        ],
+});
+
+const askDevicePassphrase = async (device: Device, requestPayload: DeviceSessionAskPassphrase) => {
+  await device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', requestPayload);
+  await refreshProtocolV2DeviceStatus(device);
+};
+
+const selectDeviceSession = async (
+  device: Device,
+  expectedPassphraseState?: string,
+  deriveCardano?: boolean
+) => {
+  const existsAttachPinUser = device.features?.attachToPinEnabled === true;
+  const metadata = {
+    source: 'wallet-session-coordinator' as const,
+    reason: expectedPassphraseState ? ('session-recovery' as const) : ('open-wallet' as const),
+    ...(expectedPassphraseState ? { expectedPassphraseState } : {}),
+  };
+  const passphraseInteraction = device.createProtocolV2UiPhaseMetadata?.('passphrase', 'start');
+  const response = await device.commands.promptPassphrase(
+    {
+      existsAttachPinUser,
+      deviceOnly: false,
+      ...metadata,
+      ...(passphraseInteraction ? { interaction: passphraseInteraction } : {}),
+    },
+    { cancelDeviceOnReject: false }
+  );
+  const hostPassphrase =
+    typeof response.passphrase === 'string' ? response.passphrase.normalize('NFKD') : undefined;
+  const hasHostPassphrase = typeof hostPassphrase === 'string' && hostPassphrase.length > 0;
+  const hostPassphraseByteLength = hasHostPassphrase ? utf8ByteLength(hostPassphrase) : undefined;
+  if (
+    hasHostPassphrase &&
+    (hostPassphrase.includes('\0') ||
+      hostPassphraseByteLength === undefined ||
+      hostPassphraseByteLength > HOST_PASSPHRASE_MAX_BYTES)
+  ) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `Host passphrase must contain 1 to ${HOST_PASSPHRASE_MAX_BYTES} valid UTF-8 bytes without NUL.`
+    );
+  }
+  const selections = [
+    hasHostPassphrase,
+    response.passphraseOnDevice === true,
+    response.attachPinOnDevice === true,
+  ].filter(Boolean).length;
+
+  if (selections !== 1) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Wallet selection must contain exactly one passphrase access mode.'
+    );
+  }
+
+  if (response.attachPinOnDevice) {
+    if (!existsAttachPinUser) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Attach PIN wallet selection is unavailable on this device.'
+      );
+    }
+    const attachPinInteraction = device.createProtocolV2UiPhaseMetadata?.('pin', 'start');
+    device.emit(DEVICE.ATTACH_PIN_ON_DEVICE, device, {
+      ...metadata,
+      ...(attachPinInteraction ? { interaction: attachPinInteraction } : {}),
+    });
+    await device.unlockDevice(DeviceSessionPinType.AttachToPin, {
+      emitUiEvent: false,
+      interaction: attachPinInteraction,
+    });
+    return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+  }
+
+  if (hasHostPassphrase) {
+    await askDevicePassphrase(device, {
+      passphrase: hostPassphrase,
+      on_device: false,
+    });
+    return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+  }
+
+  const passphraseOnDeviceInteraction = device.createProtocolV2UiPhaseMetadata?.(
+    'passphrase-on-device',
+    'start'
+  );
+  device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, {
+    ...metadata,
+    ...(passphraseOnDeviceInteraction ? { interaction: passphraseOnDeviceInteraction } : {}),
+  });
+  await askDevicePassphrase(device, { on_device: true });
+  return getDeviceSession(device, buildDeviceSessionGetRequest({ deriveCardano }));
+};
+
 export async function getProtocolV2WalletSession(
   device: Device,
-  options?: { initSession?: boolean; expectedPassphraseState?: string }
+  options?: {
+    forceWalletSelection?: boolean;
+    /** @deprecated 兼容旧 getPassphraseState；新流程使用 forceWalletSelection。 */
+    initSession?: boolean;
+    expectedPassphraseState?: string;
+    onlyMainPin?: boolean;
+    /** 业务安全校验遇到 Attach PIN 上下文时直接拒绝，不主动切换钱包。 */
+    rejectAttachPinForMainWallet?: boolean;
+    selectMainWalletBeforeRestore?: boolean;
+    resumeOnly?: boolean;
+    deriveCardano?: boolean;
+    /** Read the wallet already selected by Attach PIN without reopening wallet selection. */
+    readCurrentAttachPinSession?: boolean;
+  }
 ) {
-  if (device.features?.unlocked === false) {
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device is locked');
+  const forceWalletSelection =
+    options?.forceWalletSelection === true || options?.initSession === true;
+  const readCurrentAttachPinSession = options?.readCurrentAttachPinSession === true;
+
+  if (forceWalletSelection) {
+    if (options.onlyMainPin) {
+      device.clearStandardInternalState?.();
+    } else {
+      device.clearInternalState();
+    }
+    device.passphraseState = undefined;
   }
 
-  if (options?.initSession) {
-    device.clearInternalState();
+  await negotiateEventlessWalletSession(device);
+
+  if (options?.onlyMainPin || readCurrentAttachPinSession) {
+    device.passphraseState = undefined;
   }
+  let expectedPassphraseState =
+    options?.onlyMainPin || readCurrentAttachPinSession
+      ? undefined
+      : options?.expectedPassphraseState ?? device.passphraseState;
 
+  const cachedStandardSession = options?.onlyMainPin
+    ? device.getStandardInternalState?.()
+    : undefined;
   const cachedSessionId =
-    typeof device.getInternalState === 'function' ? device.getInternalState() : undefined;
+    !options?.onlyMainPin &&
+    !readCurrentAttachPinSession &&
+    typeof device.getInternalState === 'function'
+      ? device.getInternalState()
+      : undefined;
+  let response;
+  let resumed = false;
+  let mainPinSelected =
+    options?.onlyMainPin === true &&
+    device.features?.unlocked === true &&
+    device.features?.unlockedAttachPin === false;
 
-  try {
-    const { message } = await device.commands.typedCall(
-      'DeviceSessionGet',
-      'DeviceSession',
-      cachedSessionId ? { session_id: cachedSessionId } : {}
-    );
+  const clearCurrentWalletSession = () => {
+    if (options?.onlyMainPin) {
+      device.clearStandardInternalState?.();
+    } else {
+      device.clearInternalState();
+    }
+  };
+
+  const rejectMismatchedAttachPinWallet = async () => {
+    const features = await refreshProtocolV2DeviceStatus(device);
+    if (features.unlockedAttachPin !== true) {
+      return;
+    }
+
+    try {
+      await device.lockDevice();
+    } catch {
+      // Reject the mismatched Attach PIN wallet even when older firmware cannot lock.
+    }
+    if (options?.rejectAttachPinForMainWallet) {
+      device.clearStandardInternalState?.();
+      device.clearInternalState();
+    } else {
+      clearCurrentWalletSession();
+    }
+    throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
+  };
+
+  if (options?.onlyMainPin && options.rejectAttachPinForMainWallet) {
+    await rejectMismatchedAttachPinWallet();
+  }
+
+  const selectMainPin = async (force = false) => {
+    if (force || !mainPinSelected) {
+      await device.unlockDevice(DeviceSessionPinType.Main, {
+        source: 'wallet-session-coordinator',
+        reason: expectedPassphraseState ? 'session-recovery' : 'open-wallet',
+        deviceOnly: true,
+      });
+      mainPinSelected = true;
+    }
+  };
+
+  const selectStandardWallet = async () => {
+    // Main PIN authenticates the device; an empty host passphrase selects the standard derivation.
+    await selectMainPin();
+    if (device.features?.passphraseProtection === true) {
+      await askDevicePassphrase(device, {
+        passphrase: '',
+        on_device: false,
+      });
+    }
+  };
 
+  if (readCurrentAttachPinSession) {
+    const status = await requestProtocolV2DeviceStatus(device);
+    device.updateProtocolV2Status(status);
     if (
-      options?.expectedPassphraseState &&
-      options.expectedPassphraseState !== message.btc_test_address
+      status.unlocked !== true ||
+      status.passphrase_enabled !== true ||
+      status.unlocked_by_attach_to_pin !== true
     ) {
       device.clearInternalState();
-      throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError);
+    }
+    response = await getDeviceSession(
+      device,
+      buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
+    );
+  } else if (options?.onlyMainPin) {
+    expectedPassphraseState = cachedStandardSession?.passphraseState;
+    if (cachedStandardSession) {
+      try {
+        if (options?.selectMainWalletBeforeRestore) {
+          await selectMainPin();
+        }
+        response = await getDeviceSession(
+          device,
+          buildDeviceSessionGetRequest({
+            sessionId: cachedStandardSession.sessionId,
+            expectedPassphraseState,
+            deriveCardano: options?.deriveCardano,
+          })
+        );
+        resumed = true;
+      } catch (error) {
+        device.clearStandardInternalState?.();
+        if (!isWalletSessionInvalidError(error)) {
+          throw error;
+        }
+        resumed = false;
+      }
     }
 
-    if (message.btc_test_address && device.getCurrentPassphraseProtection() !== true) {
-      await refreshProtocolV2DeviceStatus(device);
+    if (!response) {
+      await selectStandardWallet();
+      response = await getDeviceSession(
+        device,
+        buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
+      );
+    }
+  } else if (cachedSessionId && expectedPassphraseState) {
+    try {
+      response = await getDeviceSession(
+        device,
+        buildDeviceSessionGetRequest({
+          sessionId: cachedSessionId,
+          expectedPassphraseState,
+          deriveCardano: options?.deriveCardano,
+        })
+      );
+      resumed = true;
+    } catch (error) {
+      device.clearInternalState();
+      if (options?.resumeOnly || !isWalletSessionInvalidError(error)) {
+        throw error;
+      }
+      resumed = false;
+    }
+  } else if (expectedPassphraseState) {
+    try {
+      response = await getDeviceSession(
+        device,
+        buildDeviceSessionGetRequest({
+          expectedPassphraseState,
+          deriveCardano: options?.deriveCardano,
+        })
+      );
+    } catch (error) {
+      if (options?.resumeOnly || !isWalletSessionInvalidError(error)) {
+        throw error;
+      }
     }
+  }
 
-    device.updateInternalState(
-      (device.getCurrentPassphraseProtection() ?? false) || Boolean(message.btc_test_address),
-      message.btc_test_address,
-      device.getCurrentDeviceId(),
-      message.session_id,
-      options?.initSession ? null : device.features?.sessionId
-    );
+  if (!response) {
+    if (options?.resumeOnly) {
+      device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+    }
+    response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
+  }
 
-    return {
-      passphraseState: message.btc_test_address,
-      newSession: message.session_id,
-      unlockedAttachPin: device.features?.unlockedAttachPin ?? undefined,
-    };
+  let { message } = response;
+  try {
+    assertCompleteDeviceSession(message);
   } catch (error) {
-    if (isProtocolV2InvalidSessionError(error)) {
+    if (options?.onlyMainPin) {
+      device.clearStandardInternalState?.();
+    } else {
       device.clearInternalState();
     }
     throw error;
   }
+  if (expectedPassphraseState && expectedPassphraseState !== message.btc_test_address) {
+    resumed = false;
+    await rejectMismatchedAttachPinWallet();
+    if (options?.resumeOnly) {
+      device.clearInternalState();
+      throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+    }
+    if (options?.onlyMainPin) {
+      device.clearStandardInternalState?.();
+      await selectStandardWallet();
+      response = await getDeviceSession(
+        device,
+        buildDeviceSessionGetRequest({ deriveCardano: options?.deriveCardano })
+      );
+    } else {
+      device.clearInternalState();
+      response = await selectDeviceSession(device, expectedPassphraseState, options?.deriveCardano);
+    }
+    message = response.message;
+    try {
+      assertCompleteDeviceSession(message);
+    } catch (error) {
+      if (options?.onlyMainPin) {
+        device.clearStandardInternalState?.();
+      } else {
+        device.clearInternalState();
+      }
+      throw error;
+    }
+    if (expectedPassphraseState !== message.btc_test_address) {
+      await rejectMismatchedAttachPinWallet();
+      clearCurrentWalletSession();
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+    }
+  }
+
+  const internalStateArgs = [
+    true,
+    message.btc_test_address,
+    device.getCurrentDeviceId(),
+    message.session_id,
+    forceWalletSelection ? null : cachedSessionId ?? null,
+  ] as const;
+  if (options?.onlyMainPin) {
+    device.updateInternalState(...internalStateArgs, 'standard');
+  } else {
+    device.updateInternalState(...internalStateArgs);
+  }
+
+  let unlockedAttachPin: boolean | undefined;
+  if (readCurrentAttachPinSession) {
+    unlockedAttachPin = true;
+  } else if (mainPinSelected) {
+    unlockedAttachPin = false;
+  }
+
+  return {
+    passphraseState: message.btc_test_address,
+    newSession: message.session_id,
+    unlockedAttachPin,
+    resumed,
+  };
+}
+
+export async function restoreProtocolV2WalletSession(
+  device: Device,
+  expectedPassphraseState: string,
+  deriveCardano?: boolean
+) {
+  return getProtocolV2WalletSession(device, {
+    expectedPassphraseState,
+    resumeOnly: true,
+    deriveCardano,
+  });
 }

package/src/topLevelInject.ts

@@ -1,6 +1,7 @@
 import EventEmitter from 'events';
 
-import { createCoreApi } from './inject';
+import { createCoreApi, createProtocolAwareCall } from './inject';
+import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { ConnectSettings } from './types/settings';
 import type { CoreApi } from './types/api';
@@ -19,6 +20,7 @@ export const topLevelInject = () => {
     if (!lowLevelApi) return Promise.resolve(undefined);
     return lowLevelApi.call(params);
   };
+  const protocolAwareCall = createProtocolAwareCall(call);
   const api: CoreApi = {
     on: <T extends string, P extends (...args: any[]) => any>(type: T, fn: P) => {
       eventEmitter.on(type, fn);
@@ -37,16 +39,21 @@ export const topLevelInject = () => {
       return lowLevelApi?.init(settings) ?? Promise.resolve(false);
     },
 
-    call,
+    call: protocolAwareCall.call,
 
-    ...createCoreApi(call),
+    setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
+
+    ...createCoreApi(protocolAwareCall.call),
 
     removeAllListeners: type => {
       eventEmitter.removeAllListeners(type);
       lowLevelApi?.removeAllListeners(type);
     },
 
-    dispose: () => lowLevelApi?.dispose(),
+    dispose: async () => {
+      unregisterFirmwareUpdateHostBinding();
+      await lowLevelApi?.dispose();
+    },
 
     uiResponse: response => lowLevelApi?.uiResponse(response),
 

package/src/types/api/checkAllFirmwareRelease.ts

@@ -1,31 +1,94 @@
-import type { IBLEFirmwareReleaseInfo } from '../settings';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
-import type { Features } from '@onekeyfe/hd-transport';
 import type { CommonParams, Response } from '../params';
-import type { IDeviceBLEFirmwareStatus, IDeviceFirmwareStatus } from '../device';
+import type { DeviceStateVersions, Features, IDeviceFirmwareStatus } from '../device';
+import type {
+  IBLEFirmwareReleaseInfo,
+  IFirmwareReleaseInfo,
+  IProtocolV2FirmwareComponent,
+  IProtocolV2FirmwareComponentTarget,
+  IProtocolV2ResourceSource,
+} from '../settings';
+import type { FirmwareUpdateV4Target } from './firmwareUpdate';
+import type { FirmwareUpdatePlan, FirmwareUpdatePlanForceTarget } from './firmwareUpdatePlan';
 
-export type FirmwareRelease = {
+export type ProtocolV2ComponentReleaseInfo = IProtocolV2FirmwareComponent & {
+  protocol: 'V2';
+  configKey: string;
+  componentTarget: IProtocolV2FirmwareComponentTarget;
+  required: boolean;
+  changelog: IFirmwareReleaseInfo['changelog'];
+};
+
+export type FirmwareReleaseCheckResult = {
   shouldUpdate?: boolean;
   status: IDeviceFirmwareStatus;
   changelog?: {
     'zh-CN': string;
     'en-US': string;
   }[];
-  release: IDeviceBLEFirmwareStatus | IBLEFirmwareReleaseInfo;
+  release:
+    | IBLEFirmwareReleaseInfo
+    | IFirmwareReleaseInfo
+    | ProtocolV2ComponentReleaseInfo
+    | undefined;
   bootloaderMode?: boolean;
 };
 
+export type BridgeReleaseCheckResult = Omit<FirmwareReleaseCheckResult, 'release'> & {
+  release: string | undefined;
+};
+
+export type ProtocolV2FirmwareComponentReleaseStatus =
+  | 'valid'
+  | 'outdated'
+  | 'unknown'
+  | 'unsupported';
+
+export type ProtocolV2FirmwareReleaseStatus =
+  | 'unavailable'
+  | 'valid'
+  | 'unknown'
+  | 'outdated'
+  | 'required';
+
+export type ProtocolV2FirmwareComponentRelease = {
+  configKey: string;
+  componentTarget: IProtocolV2FirmwareComponentTarget;
+  updateTarget: FirmwareUpdateV4Target | null;
+  currentVersion: string | null;
+  targetVersion: string | null;
+  status: ProtocolV2FirmwareComponentReleaseStatus;
+  required: boolean;
+};
+
 export type AllFirmwareRelease = {
-  firmware: FirmwareRelease;
-  ble: FirmwareRelease;
-  bootloader?: FirmwareRelease;
-  bridge?: FirmwareRelease;
+  firmware: FirmwareReleaseCheckResult;
+  ble: FirmwareReleaseCheckResult;
+  bootloader?: FirmwareReleaseCheckResult;
+  bridge?: BridgeReleaseCheckResult;
   features?: Features;
+  protocol?: 'V1' | 'V2';
+  deviceType?: 'pro2' | 'neo';
+  firmwareType?: EFirmwareType;
+  status?: ProtocolV2FirmwareReleaseStatus;
+  hasUpgrade?: boolean;
+  required?: boolean;
+  resourceStatus?: 'valid' | 'outdated' | 'unknown';
+  resourceArchive?: IProtocolV2ResourceSource;
+  currentVersions?: DeviceStateVersions;
+  components?: ProtocolV2FirmwareComponentRelease[];
+  targetsToUpdate?: FirmwareUpdateV4Target[];
+  release?: IFirmwareReleaseInfo;
+  firmwareUpdatePlan?: FirmwareUpdatePlan;
 };
 
 export type CheckAllFirmwareReleaseParams = {
   checkBridgeRelease?: boolean;
+  checkFirmwareHash?: boolean;
   firmwareType?: EFirmwareType;
+  platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
+  forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
+  protocolV2ForceUpdateTargets?: FirmwareUpdateV4Target[];
 };
 
 export declare function checkAllFirmwareRelease(

package/src/types/api/checkBLEFirmwareRelease.ts

@@ -1,15 +1,6 @@
-import type { IBLEFirmwareReleaseInfo } from '../settings';
 import type { Response } from '../params';
-import type { IDeviceBLEFirmwareStatus } from '../device';
+import type { FirmwareReleaseCheckResult } from './checkAllFirmwareRelease';
 
-type BleFirmwareRelease = {
-  status: IDeviceBLEFirmwareStatus;
-  changelog: {
-    'zh-CN': string;
-    'en-US': string;
-  }[];
-  release: IBLEFirmwareReleaseInfo;
-  bootloaderMode: boolean;
-};
-
-export declare function checkBLEFirmwareRelease(connectId?: string): Response<BleFirmwareRelease>;
+export declare function checkBLEFirmwareRelease(
+  connectId?: string
+): Response<FirmwareReleaseCheckResult | null>;

package/src/types/api/checkBootloaderRelease.ts

@@ -1,12 +1,8 @@
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
+import type { FirmwareReleaseCheckResult } from './checkAllFirmwareRelease';
 
-export type CheckBootloaderReleaseResponse = {
-  shouldUpdate: boolean;
-  status: 'outdated' | 'valid';
-  release: string | undefined;
-  bootloaderMode: boolean;
-} | null;
+export type CheckBootloaderReleaseResponse = FirmwareReleaseCheckResult | null;
 
 export type CheckBootloaderReleaseParams = {
   willUpdateFirmwareVersion?: string;