@onekeyfe/hd-core 1.2.0-alpha.18 → 1.2.0-alpha.180

package/src/api/CheckAllFirmwareRelease.ts

@@ -1,19 +1,297 @@
+import { HardwareError } from '@onekeyfe/hd-shared';
+import semver from 'semver';
+
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
+import { DataManager } from '../data-manager';
 import {
   getBleFirmwareReleaseInfo,
   getBootloaderReleaseInfo,
   getFirmwareReleaseInfo,
 } from './firmware/releaseHelper';
+import {
+  buildFirmwareUpdatePlan,
+  buildProtocolV2FirmwareUpdatePlan,
+  validateFirmwareUpdatePlanForceTargets,
+  validateProtocolV2FirmwareUpdateTargets,
+} from './firmware/FirmwareUpdatePlan';
+import {
+  PROTOCOL_V2_BLE_TARGETS,
+  PROTOCOL_V2_BOOTLOADER_TARGETS,
+  PROTOCOL_V2_MAIN_FIRMWARE_TARGETS,
+  getProtocolV2ComponentReleaseInfo,
+  loadProtocolV2FirmwareReleaseContext,
+  summarizeProtocolV2FirmwareRelease,
+  toProtocolV2FirmwareReleaseInfo,
+} from './firmware/protocolV2Release';
 import { getBridgeReleaseInfo } from '../utils/bridgeUpdate';
-import { getDeviceFirmwareVersion, getDeviceType, getFirmwareType } from '../utils';
+import {
+  LoggerNames,
+  getDeviceFirmwareVersion,
+  getDeviceType,
+  getFirmwareType,
+  getLogger,
+} from '../utils';
 
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type {
   AllFirmwareRelease,
   CheckAllFirmwareReleaseParams,
+  ProtocolV2FirmwareComponentRelease,
+  ProtocolV2FirmwareReleaseStatus,
 } from '../types/api/checkAllFirmwareRelease';
+import type { FirmwareUpdateV4Target } from '../types/api/firmwareUpdate';
+import type {
+  DeviceFeaturesVerify,
+  DeviceStateVersions,
+  IFirmwareReleaseInfo,
+  IProtocolV2FirmwareComponent,
+  IProtocolV2FirmwareComponentTarget,
+} from '../types';
+import type { FirmwareUpdatePlan } from '../types/api/firmwareUpdatePlan';
+
+const UPDATE_TARGET_BY_COMPONENT_TARGET: Readonly<
+  Partial<Record<IProtocolV2FirmwareComponentTarget, FirmwareUpdateV4Target>>
+> = {
+  BOOTLOADER: 'boot',
+  APPLICATION_P1: 'app_v1',
+  APPLICATION_P2: 'app_v2',
+  COPROCESSOR: 'coprocessor',
+  SE01: 'se01',
+  SE02: 'se02',
+  SE03: 'se03',
+  SE04: 'se04',
+};
+
+const CURRENT_VERSION_BY_COMPONENT_TARGET: Readonly<
+  Record<IProtocolV2FirmwareComponentTarget, keyof DeviceStateVersions | null>
+> = {
+  ROMLOADER: 'board',
+  BOOTLOADER: 'bootloader',
+  APPLICATION_P1: 'applicationP1',
+  APPLICATION_P2: 'applicationP2',
+  COPROCESSOR: 'ble',
+  SE01: 'se01',
+  SE02: 'se02',
+  SE03: 'se03',
+  SE04: 'se04',
+};
+
+const CURRENT_HASH_BY_COMPONENT_TARGET: Readonly<
+  Partial<Record<IProtocolV2FirmwareComponentTarget, keyof DeviceFeaturesVerify>>
+> = {
+  BOOTLOADER: 'bootloaderHash',
+  APPLICATION_P1: 'applicationP1Hash',
+  APPLICATION_P2: 'applicationP2Hash',
+};
+
+function normalizeHex(value: string | undefined): string | undefined {
+  const normalized = value?.replace(/^0x/i, '').toLowerCase();
+  return normalized && /^[0-9a-f]+$/.test(normalized) ? normalized : undefined;
+}
+
+function toVersionString(version: number[] | undefined): string | null {
+  return version?.length ? version.join('.') : null;
+}
+
+function getOrderedComponentEntries(release: IFirmwareReleaseInfo) {
+  const components = release.components ?? {};
+  const orderedKeys = [
+    ...(release.installOrder ?? []),
+    ...Object.keys(components).filter(key => !release.installOrder?.includes(key)),
+  ];
+  return orderedKeys
+    .map(key => {
+      const component = components[key];
+      return component ? ([key, component] as const) : undefined;
+    })
+    .filter((entry): entry is readonly [string, IProtocolV2FirmwareComponent] => !!entry);
+}
+
+function buildComponentRelease({
+  configKey,
+  component,
+  currentVersions,
+  currentVerification,
+  checkFirmwareHash,
+  remotePayloadHash,
+  releaseRequired,
+}: {
+  configKey: string;
+  component: IProtocolV2FirmwareComponent;
+  currentVersions: DeviceStateVersions;
+  currentVerification: Partial<DeviceFeaturesVerify>;
+  checkFirmwareHash: boolean;
+  remotePayloadHash: string | null | undefined;
+  releaseRequired: boolean;
+}): ProtocolV2FirmwareComponentRelease {
+  const componentTarget = component.target.toUpperCase() as IProtocolV2FirmwareComponentTarget;
+  const updateTarget = UPDATE_TARGET_BY_COMPONENT_TARGET[componentTarget] ?? null;
+  const currentVersionKey = CURRENT_VERSION_BY_COMPONENT_TARGET[componentTarget];
+  const currentVersion = currentVersionKey
+    ? currentVersions[currentVersionKey] ??
+      (componentTarget === 'APPLICATION_P1' ? currentVersions.firmware : null) ??
+      null
+    : null;
+  const targetVersion = toVersionString(component.version);
+
+  let status: ProtocolV2FirmwareComponentRelease['status'] = 'unknown';
+  if (!updateTarget) {
+    status = 'unsupported';
+  } else if (
+    currentVersion &&
+    targetVersion &&
+    semver.valid(currentVersion) &&
+    semver.valid(targetVersion)
+  ) {
+    if (semver.lt(currentVersion, targetVersion)) {
+      status = 'outdated';
+    } else if (semver.gt(currentVersion, targetVersion)) {
+      status = 'valid';
+    } else {
+      const currentHashKey = CURRENT_HASH_BY_COMPONENT_TARGET[componentTarget];
+      if (!checkFirmwareHash || !currentHashKey) {
+        status = 'valid';
+      } else {
+        const currentHash = normalizeHex(currentVerification[currentHashKey]);
+        const expectedHash = normalizeHex(remotePayloadHash ?? undefined);
+        if (currentHash && expectedHash) {
+          status = expectedHash.startsWith(currentHash) ? 'valid' : 'outdated';
+        } else {
+          status = 'unknown';
+        }
+      }
+    }
+  }
+
+  return {
+    configKey,
+    componentTarget,
+    updateTarget,
+    currentVersion,
+    targetVersion,
+    status,
+    required: releaseRequired && status === 'outdated',
+  };
+}
+
+export type ProtocolV2FirmwareReleasePlan = {
+  firmwareType: EFirmwareType;
+  status: ProtocolV2FirmwareReleaseStatus;
+  hasUpgrade: boolean;
+  required: boolean;
+  currentVersions: DeviceStateVersions;
+  components: ProtocolV2FirmwareComponentRelease[];
+  targetsToUpdate: FirmwareUpdateV4Target[];
+  release: IFirmwareReleaseInfo | undefined;
+};
+
+export function buildProtocolV2FirmwareRelease({
+  currentVersions,
+  currentVerification = {},
+  checkFirmwareHash = false,
+  remotePayloadHashes = {},
+  firmwareType,
+  release,
+  deviceType,
+}: {
+  currentVersions: DeviceStateVersions;
+  currentVerification?: Partial<DeviceFeaturesVerify>;
+  checkFirmwareHash?: boolean;
+  remotePayloadHashes?: Readonly<Record<string, string | null>>;
+  firmwareType: EFirmwareType;
+  release: IFirmwareReleaseInfo | undefined;
+  deviceType?: 'pro2' | 'neo';
+}): ProtocolV2FirmwareReleasePlan {
+  if (!release) {
+    return {
+      firmwareType,
+      status: 'unavailable' as const,
+      hasUpgrade: false,
+      required: false,
+      currentVersions,
+      components: [],
+      targetsToUpdate: [],
+      release: undefined,
+    };
+  }
+
+  let components = getOrderedComponentEntries(release).map(([configKey, component]) => {
+    const result = buildComponentRelease({
+      configKey,
+      component,
+      currentVersions,
+      currentVerification,
+      checkFirmwareHash,
+      remotePayloadHash: Object.prototype.hasOwnProperty.call(remotePayloadHashes, configKey)
+        ? remotePayloadHashes[configKey]
+        : normalizeHex(component.payloadHash),
+      releaseRequired: release.required,
+    });
+    if (
+      deviceType === 'neo' &&
+      (result.componentTarget === 'SE03' || result.componentTarget === 'SE04')
+    ) {
+      return {
+        ...result,
+        updateTarget: null,
+        status: 'unsupported' as const,
+        required: false,
+      };
+    }
+    return result;
+  });
+  if (!currentVersions.applicationP2) {
+    const applicationP1 = components.find(
+      component => component.componentTarget === 'APPLICATION_P1'
+    );
+    if (applicationP1) {
+      components = components.map(component =>
+        component.componentTarget === 'APPLICATION_P2' && component.status === 'unknown'
+          ? {
+              ...component,
+              currentVersion: currentVersions.applicationP1 ?? currentVersions.firmware,
+              status: applicationP1.status,
+              required: applicationP1.required,
+            }
+          : component
+      );
+    }
+  }
+  const targetsToUpdate = components.flatMap(component =>
+    component.status === 'outdated' && component.updateTarget ? [component.updateTarget] : []
+  );
+  const uniqueTargetsToUpdate = Array.from(new Set(targetsToUpdate));
+  const hasUpgrade = uniqueTargetsToUpdate.length > 0;
+  const required = release.required && hasUpgrade;
+  let status: ProtocolV2FirmwareReleaseStatus = 'valid';
+  if (required) {
+    status = 'required';
+  } else if (hasUpgrade) {
+    status = 'outdated';
+  } else if (components.some(component => component.status === 'unknown')) {
+    status = 'unknown';
+  }
+
+  return {
+    firmwareType,
+    status,
+    hasUpgrade,
+    required,
+    currentVersions,
+    components,
+    targetsToUpdate: uniqueTargetsToUpdate,
+    release,
+  };
+}
+
+const Log = getLogger(LoggerNames.Method);
 
 export default class CheckAllFirmwareRelease extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
     this.useDevicePassphraseState = false;
@@ -21,9 +299,18 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
   }
 
   async run() {
+    if (this.device.isProtocolV2()) {
+      return this.runProtocolV2();
+    }
+
     const { features } = this.device;
-    const { checkBridgeRelease, firmwareType: firmwareTypeParams } = this
-      .payload as CheckAllFirmwareReleaseParams;
+    const {
+      checkBridgeRelease,
+      firmwareType: firmwareTypeParams,
+      platform,
+      forceUpdateTargets,
+    } = this.payload as CheckAllFirmwareReleaseParams;
+    const validatedForceUpdateTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
 
     if (!features) {
       return Promise.resolve(null);
@@ -54,6 +341,32 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
       firmwareType,
     });
     const bleFirmwareReleaseInfo = getBleFirmwareReleaseInfo(features);
+    let firmwareUpdatePlan: FirmwareUpdatePlan | undefined;
+    try {
+      firmwareUpdatePlan = buildFirmwareUpdatePlan({
+        features,
+        firmwareType,
+        platform: platform ?? 'web',
+        firmware: firmwareRelease,
+        ble: bleFirmwareReleaseInfo,
+        bootloader: bootloaderRelease,
+        forceUpdateTargets: validatedForceUpdateTargets,
+      });
+    } catch (error) {
+      if (
+        validatedForceUpdateTargets.length > 0 ||
+        !(error instanceof HardwareError) ||
+        error.params?.firmwareUpdateCode !== 'FirmwarePlanInvalid'
+      ) {
+        throw error;
+      }
+      // A Plan is an optional external-host capability. Release checks remain
+      // available for legacy and recovery flows when a Plan cannot be built.
+      Log.warn(
+        '[CheckAllFirmwareRelease] Optional firmware Plan is unavailable; using the legacy release result'
+      );
+      firmwareUpdatePlan = undefined;
+    }
 
     return {
       firmware: firmwareRelease,
@@ -68,6 +381,129 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
           }
         : undefined,
       features,
-    } as AllFirmwareRelease;
+      firmwareUpdatePlan,
+    } as unknown as AllFirmwareRelease;
+  }
+
+  private async runProtocolV2(): Promise<AllFirmwareRelease> {
+    const {
+      checkFirmwareHash = false,
+      firmwareType: firmwareTypeParam,
+      platform,
+      forceUpdateTargets,
+      protocolV2ForceUpdateTargets,
+    } = this.payload as CheckAllFirmwareReleaseParams;
+    const validatedForceUpdateTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
+    const validatedProtocolV2ForceUpdateTargets = validateProtocolV2FirmwareUpdateTargets(
+      protocolV2ForceUpdateTargets
+    );
+    const { state, features, firmwareType, release } = await loadProtocolV2FirmwareReleaseContext({
+      device: this.device,
+      firmwareType: firmwareTypeParam,
+      checkFirmwareHash,
+      methodName: 'checkAllFirmwareRelease',
+    });
+    const plan = buildProtocolV2FirmwareRelease({
+      currentVersions: state.versions,
+      currentVerification: checkFirmwareHash ? state.verification : undefined,
+      checkFirmwareHash,
+      firmwareType,
+      release,
+      deviceType: state.identity.deviceType,
+    });
+    const resourceSource = DataManager.getProtocolV2ResourceSource(release);
+    const resourceStatus = 'unknown' as const;
+    const detectedComponentTargets = validatedForceUpdateTargets.includes('firmware')
+      ? plan.components.flatMap(component =>
+          component.updateTarget ? [component.updateTarget] : []
+        )
+      : plan.targetsToUpdate;
+    const componentTargetsToUpdate = Array.from(
+      new Set([
+        ...detectedComponentTargets,
+        ...validatedProtocolV2ForceUpdateTargets.filter(target => target !== 'resource'),
+      ])
+    );
+    const forceResourceUpdate =
+      validatedForceUpdateTargets.includes('resource') ||
+      validatedProtocolV2ForceUpdateTargets.includes('resource');
+    // A configured resource archive accompanies a real remote component update,
+    // but its mere availability must not turn an otherwise current device into a
+    // resource-only update. Explicit developer resource forcing remains supported.
+    const includeResourceUpdate =
+      forceResourceUpdate || (resourceSource !== undefined && detectedComponentTargets.length > 0);
+    const targetsToUpdate = Array.from(
+      new Set([
+        ...componentTargetsToUpdate,
+        ...(includeResourceUpdate ? (['resource'] as const) : []),
+      ])
+    );
+    let firmwareUpdatePlan: FirmwareUpdatePlan | undefined;
+    const shouldBuildFirmwareUpdatePlan = targetsToUpdate.length > 0;
+    const requestedPlatform = platform ?? 'web';
+    const requiresPreparedPlan =
+      shouldBuildFirmwareUpdatePlan &&
+      (requestedPlatform === 'native' || requestedPlatform === 'desktop');
+    try {
+      if (shouldBuildFirmwareUpdatePlan) {
+        const validatedPlan = buildProtocolV2FirmwareUpdatePlan({
+          features,
+          firmwareType,
+          platform: requestedPlatform,
+          release,
+          targetsToUpdate,
+          forceUpdateTargets: validatedForceUpdateTargets,
+          resourceArchive: resourceSource,
+        });
+        firmwareUpdatePlan = validatedPlan;
+      } else {
+        firmwareUpdatePlan = undefined;
+      }
+    } catch (error) {
+      if (
+        requiresPreparedPlan ||
+        validatedForceUpdateTargets.length > 0 ||
+        validatedProtocolV2ForceUpdateTargets.length > 0 ||
+        !(error instanceof HardwareError) ||
+        error.params?.firmwareUpdateCode !== 'FirmwarePlanInvalid'
+      ) {
+        throw error;
+      }
+      Log.warn(
+        '[CheckAllFirmwareRelease] Optional Protocol V2 firmware Plan is unavailable; using the release result'
+      );
+      firmwareUpdatePlan = undefined;
+    }
+    const firmwarePlan = summarizeProtocolV2FirmwareRelease(
+      plan,
+      PROTOCOL_V2_MAIN_FIRMWARE_TARGETS
+    );
+    const blePlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_BLE_TARGETS);
+    const bootloaderPlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_BOOTLOADER_TARGETS);
+    const { status } = plan;
+
+    return {
+      firmware: toProtocolV2FirmwareReleaseInfo({ plan: firmwarePlan, state, release }),
+      ble: toProtocolV2FirmwareReleaseInfo({
+        plan: blePlan,
+        state,
+        release: getProtocolV2ComponentReleaseInfo(plan, 'COPROCESSOR'),
+      }),
+      bootloader: toProtocolV2FirmwareReleaseInfo({
+        plan: bootloaderPlan,
+        state,
+        release: getProtocolV2ComponentReleaseInfo(plan, 'BOOTLOADER'),
+      }),
+      features,
+      protocol: 'V2',
+      deviceType: state.identity.deviceType,
+      ...plan,
+      status,
+      resourceStatus,
+      resourceArchive: resourceSource,
+      hasUpgrade: targetsToUpdate.length > 0,
+      targetsToUpdate,
+      firmwareUpdatePlan,
+    };
   }
 }

package/src/api/CheckBLEFirmwareRelease.ts

@@ -1,8 +1,20 @@
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
 import { getBleFirmwareReleaseInfo } from './firmware/releaseHelper';
+import {
+  PROTOCOL_V2_BLE_TARGETS,
+  getProtocolV2ComponentReleaseInfo,
+  loadProtocolV2FirmwareReleaseContext,
+  summarizeProtocolV2FirmwareRelease,
+  toProtocolV2FirmwareReleaseInfo,
+} from './firmware/protocolV2Release';
+import { buildProtocolV2FirmwareRelease } from './CheckAllFirmwareRelease';
 
 export default class CheckBLEFirmwareRelease extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.allowDeviceMode = [
       ...this.allowDeviceMode,
@@ -13,11 +25,31 @@ export default class CheckBLEFirmwareRelease extends BaseMethod {
     this.skipForceUpdateCheck = true;
   }
 
-  run() {
-    if (this.device.features) {
-      const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
-      return Promise.resolve(releaseInfo);
+  async run() {
+    if (this.device.isProtocolV2()) {
+      const { state, firmwareType, release } = await loadProtocolV2FirmwareReleaseContext({
+        device: this.device,
+        methodName: 'checkBLEFirmwareRelease',
+      });
+      const plan = summarizeProtocolV2FirmwareRelease(
+        buildProtocolV2FirmwareRelease({
+          currentVersions: state.versions,
+          firmwareType,
+          release,
+          deviceType: state.identity.deviceType,
+        }),
+        PROTOCOL_V2_BLE_TARGETS
+      );
+      return toProtocolV2FirmwareReleaseInfo({
+        plan,
+        state,
+        release: getProtocolV2ComponentReleaseInfo(plan, 'COPROCESSOR'),
+      });
     }
-    return Promise.resolve(null);
+
+    if (!this.device.features) return null;
+
+    const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
+    return releaseInfo;
   }
 }

package/src/api/CheckBootloaderRelease.ts

@@ -1,11 +1,22 @@
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
 import { getBootloaderReleaseInfo } from './firmware/releaseHelper';
-import { getFirmwareType } from '../utils';
+import {
+  PROTOCOL_V2_BOOTLOADER_TARGETS,
+  getProtocolV2ComponentReleaseInfo,
+  loadProtocolV2FirmwareReleaseContext,
+  summarizeProtocolV2FirmwareRelease,
+  toProtocolV2FirmwareReleaseInfo,
+} from './firmware/protocolV2Release';
+import { buildProtocolV2FirmwareRelease } from './CheckAllFirmwareRelease';
 
 import type { CheckBootloaderReleaseParams } from '../types/api/checkBootloaderRelease';
 
 export default class CheckBootloaderRelease extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
     this.useDevicePassphraseState = false;
@@ -13,13 +24,34 @@ export default class CheckBootloaderRelease extends BaseMethod {
   }
 
   async run() {
-    if (!this.device.features) {
-      return null;
+    const payload = this.payload as CheckBootloaderReleaseParams;
+
+    if (this.device.isProtocolV2()) {
+      const { state, firmwareType, release } = await loadProtocolV2FirmwareReleaseContext({
+        device: this.device,
+        firmwareType: payload.firmwareType,
+        methodName: 'checkBootloaderRelease',
+      });
+      const plan = summarizeProtocolV2FirmwareRelease(
+        buildProtocolV2FirmwareRelease({
+          currentVersions: state.versions,
+          firmwareType,
+          release,
+          deviceType: state.identity.deviceType,
+        }),
+        PROTOCOL_V2_BOOTLOADER_TARGETS
+      );
+      return toProtocolV2FirmwareReleaseInfo({
+        plan,
+        state,
+        release: getProtocolV2ComponentReleaseInfo(plan, 'BOOTLOADER'),
+      });
     }
+
     const { features } = this.device;
-    const payload = this.payload as CheckBootloaderReleaseParams;
+    if (!features) return null;
 
-    const deviceFirmwareType = getFirmwareType(features);
+    const deviceFirmwareType = this.device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     const releaseInfo = getBootloaderReleaseInfo({

package/src/api/CheckFirmwareRelease.ts

@@ -1,11 +1,21 @@
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
 import { getFirmwareReleaseInfo } from './firmware/releaseHelper';
-import { getFirmwareType } from '../utils';
+import {
+  PROTOCOL_V2_MAIN_FIRMWARE_TARGETS,
+  loadProtocolV2FirmwareReleaseContext,
+  summarizeProtocolV2FirmwareRelease,
+  toProtocolV2FirmwareReleaseInfo,
+} from './firmware/protocolV2Release';
+import { buildProtocolV2FirmwareRelease } from './CheckAllFirmwareRelease';
 
 import type { CheckFirmwareReleaseParams } from '../types/api/checkFirmwareRelease';
 
 export default class CheckFirmwareRelease extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.allowDeviceMode = [
       ...this.allowDeviceMode,
@@ -16,16 +26,33 @@ export default class CheckFirmwareRelease extends BaseMethod {
     this.skipForceUpdateCheck = true;
   }
 
-  run() {
+  async run() {
     const payload = this.payload as CheckFirmwareReleaseParams;
 
-    if (this.device.features) {
-      const deviceFirmwareType = getFirmwareType(this.device.features);
-      const firmwareType = payload.firmwareType ?? deviceFirmwareType;
-
-      const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
-      return Promise.resolve(releaseInfo);
+    if (this.device.isProtocolV2()) {
+      const { state, firmwareType, release } = await loadProtocolV2FirmwareReleaseContext({
+        device: this.device,
+        firmwareType: payload.firmwareType,
+        methodName: 'checkFirmwareRelease',
+      });
+      const plan = summarizeProtocolV2FirmwareRelease(
+        buildProtocolV2FirmwareRelease({
+          currentVersions: state.versions,
+          firmwareType,
+          release,
+          deviceType: state.identity.deviceType,
+        }),
+        PROTOCOL_V2_MAIN_FIRMWARE_TARGETS
+      );
+      return toProtocolV2FirmwareReleaseInfo({ plan, state, release });
     }
-    return Promise.resolve(null);
+
+    if (!this.device.features) return null;
+
+    const deviceFirmwareType = this.device.getCurrentFirmwareType();
+    const firmwareType = payload.firmwareType ?? deviceFirmwareType;
+
+    const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
+    return releaseInfo;
   }
 }

package/src/api/CipherKeyValue.ts

@@ -8,6 +8,10 @@ import type { CipheredKeyValue, CipheredKeyValueParams } from '../types';
 import type { CipherKeyValue as HardwareCipherKeyValue } from '@onekeyfe/hd-transport';
 
 export default class CipherKeyValue extends BaseMethod<HardwareCipherKeyValue[]> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {

package/src/api/ClearSessionCache.ts

@@ -1,10 +1,14 @@
 import { BaseMethod } from './BaseMethod';
+import { invalidParameter } from './helpers/paramsValidator';
 import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
 
 import type { ClearSessionCacheParams } from '../types/api/sessionCache';
 
 export default class ClearSessionCache extends BaseMethod<ClearSessionCacheParams> {
   init() {
+    if (this.payload.passphraseState !== undefined && !this.payload.deviceId) {
+      throw invalidParameter('Parameter [deviceId] is required with [passphraseState].');
+    }
     this.useDevice = false;
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;