@onekeyfe/hd-core 1.2.0-alpha.95 → 1.2.0-alpha.97

package/src/api/CheckAllFirmwareRelease.ts

@@ -1,4 +1,10 @@
-import { EDeviceType, HardwareError } from '@onekeyfe/hd-shared';
+import {
+  EDeviceType,
+  EFirmwareType,
+  ERRORS,
+  HardwareError,
+  HardwareErrorCode,
+} from '@onekeyfe/hd-shared';
 import semver from 'semver';
 
 import { BaseMethod } from './BaseMethod';
@@ -11,20 +17,13 @@ import {
 } 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 {
+  buildProtocolV2ResourceUpdatePlan,
+  readProtocolV2ResourceInventory,
+} from '../protocols/protocol-v2/resources';
 import {
   LoggerNames,
   getDeviceFirmwareVersion,
@@ -33,7 +32,6 @@ import {
   getLogger,
 } from '../utils';
 
-import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type {
   AllFirmwareRelease,
   CheckAllFirmwareReleaseParams,
@@ -175,7 +173,7 @@ function buildComponentRelease({
   };
 }
 
-export type ProtocolV2FirmwareReleasePlan = {
+type ProtocolV2FirmwareReleasePlan = {
   firmwareType: EFirmwareType;
   status: ProtocolV2FirmwareReleaseStatus;
   hasUpgrade: boolean;
@@ -386,23 +384,31 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
   }
 
   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 { checkFirmwareHash = false, firmwareType: firmwareTypeParam } = this
+      .payload as CheckAllFirmwareReleaseParams;
+    const state = await this.device.getDeviceState({
+      refreshSections: checkFirmwareHash
+        ? ['identity', 'versions', 'verification']
+        : ['identity', 'versions'],
     });
+    if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceNotSupportMethod,
+        'checkAllFirmwareRelease requires a Pro2 or Neo device for Protocol V2'
+      );
+    }
+
+    const { features } = this.device;
+    if (!features) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'checkAllFirmwareRelease requires initialized device features'
+      );
+    }
+
+    const firmwareType =
+      firmwareTypeParam ?? state.identity.firmwareType ?? EFirmwareType.Universal;
+    const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
     const plan = buildProtocolV2FirmwareRelease({
       currentVersions: state.versions,
       currentVerification: checkFirmwareHash ? state.verification : undefined,
@@ -413,94 +419,60 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
     });
     const resourceDeviceType =
       state.identity.deviceType === 'neo' ? EDeviceType.Neo : EDeviceType.Pro2;
-    const resourceSource = DataManager.getProtocolV2ResourceSource(resourceDeviceType);
-    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');
-    const targetsToUpdate = Array.from(
-      new Set([
-        ...componentTargetsToUpdate,
-        ...(forceResourceUpdate ? (['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;
+    const resources = DataManager.getProtocolV2Resources(resourceDeviceType);
+    let resourceStatus: 'valid' | 'outdated' | 'unknown' = 'unknown';
+    if (resources?.length) {
+      const loaderMode = state.status.mode === 'bootloader' || state.status.mode === 'romloader';
+      // Application mode rejects host access to vol0:/bundles. Resource inventory is
+      // resolved after FirmwareUpdateV4 enters a loader instead of probing here.
+      if (loaderMode) {
+        try {
+          const inventory = await readProtocolV2ResourceInventory({
+            commands: this.device.getCommands(),
+            resources,
+          });
+          resourceStatus = buildProtocolV2ResourceUpdatePlan({
+            resources,
+            inventory,
+            mode: 'bootloader-recovery',
+          }).status;
+        } catch {
+          resourceStatus = buildProtocolV2ResourceUpdatePlan({
+            resources,
+            mode: 'bootloader-recovery',
+          }).status;
+        }
       }
-      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;
+    const targetsToUpdate = [
+      ...plan.targetsToUpdate,
+      ...(resourceStatus === 'outdated' ? (['resource'] as const) : []),
+    ];
+    const firmwareStatus = plan.status === 'unavailable' ? 'unknown' : plan.status;
+    const emptyRelease = 'none' as const;
 
     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'),
-      }),
+      firmware: {
+        status: firmwareStatus,
+        changelog: release ? [release.changelog] : [],
+        release: release ?? emptyRelease,
+        bootloaderMode: state.status.mode === 'bootloader' || state.status.mode === 'romloader',
+      },
+      ble: {
+        status: 'valid',
+        release: emptyRelease,
+      },
+      bootloader: {
+        status: 'valid',
+        release: emptyRelease,
+      },
       features,
       protocol: 'V2',
       deviceType: state.identity.deviceType,
       ...plan,
-      status,
       resourceStatus,
-      resourceArchive: resourceSource,
-      hasUpgrade: targetsToUpdate.length > 0,
+      hasUpgrade: plan.hasUpgrade || resourceStatus === 'outdated',
       targetsToUpdate,
-      firmwareUpdatePlan,
     };
   }
 }

package/src/api/CheckBLEFirmwareRelease.ts

@@ -1,20 +1,8 @@
 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,
@@ -25,31 +13,11 @@ export default class CheckBLEFirmwareRelease extends BaseMethod {
     this.skipForceUpdateCheck = true;
   }
 
-  async run() {
-    if (!this.device.features) return null;
-
-    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'),
-      });
+  run() {
+    if (this.device.features) {
+      const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
+      return Promise.resolve(releaseInfo);
     }
-
-    const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
-    return releaseInfo;
+    return Promise.resolve(null);
   }
 }

package/src/api/CheckBootloaderRelease.ts

@@ -1,22 +1,10 @@
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
 import { getBootloaderReleaseInfo } from './firmware/releaseHelper';
-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;
@@ -24,32 +12,12 @@ export default class CheckBootloaderRelease extends BaseMethod {
   }
 
   async run() {
-    if (!this.device.features) return null;
+    if (!this.device.features) {
+      return null;
+    }
     const { features } = this.device;
     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 deviceFirmwareType = this.device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 

package/src/api/CheckFirmwareRelease.ts

@@ -1,21 +1,10 @@
 import { BaseMethod } from './BaseMethod';
 import { UI_REQUEST } from '../constants/ui-request';
 import { getFirmwareReleaseInfo } from './firmware/releaseHelper';
-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,
@@ -26,33 +15,16 @@ export default class CheckFirmwareRelease extends BaseMethod {
     this.skipForceUpdateCheck = true;
   }
 
-  async run() {
+  run() {
     const payload = this.payload as CheckFirmwareReleaseParams;
 
-    if (!this.device.features) return null;
+    if (this.device.features) {
+      const deviceFirmwareType = this.device.getCurrentFirmwareType();
+      const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
-    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 });
+      const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
+      return Promise.resolve(releaseInfo);
     }
-
-    const deviceFirmwareType = this.device.getCurrentFirmwareType();
-    const firmwareType = payload.firmwareType ?? deviceFirmwareType;
-
-    const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
-    return releaseInfo;
+    return Promise.resolve(null);
   }
 }

package/src/api/FirmwareUpdateV2.ts

@@ -33,7 +33,6 @@ import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
   getFirmwareUpdateResourceName,
-  validateFirmwareUpdatePreparedPlan,
 } from './firmware/FirmwareUpdatePreparedPlan';
 
 import type { Features, KnownDevice } from '../types';
@@ -47,7 +46,6 @@ import type { FirmwareUpdatePreparedPlan } from '../types/api/firmwareUpdatePrep
 type Params = {
   binary?: ArrayBuffer;
   artifact?: FirmwareArtifactReference;
-  hostBindingGeneration?: number;
   resourceEntries?: Array<{
     entryName: string;
     artifact: FirmwareArtifactReference;
@@ -172,12 +170,6 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
         'Firmware update binary and artifact are mutually exclusive'
       );
     }
-    if (payload.preparedPlan !== undefined && payload.artifact === undefined) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.CallMethodInvalidParameter,
-        'Prepared firmware plans require a prepared artifact'
-      );
-    }
 
     if (!payload.updateType) {
       throw ERRORS.TypedError(
@@ -208,11 +200,7 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
     }
 
     if ('artifact' in payload) {
-      const preparedPlan = validateFirmwareUpdatePreparedPlan(payload.preparedPlan);
-      const hostBinding = resolveFirmwareUpdateHostBinding(
-        payload.hostBindingGeneration,
-        preparedPlan.preparedPlanDigest
-      );
+      const hostBinding = resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration);
       const target = payload.isUpdateBootloader ? 'bootloader' : payload.updateType;
       const resourceBindings = (payload.resourceEntries ?? []).map(
         (entry: { entryName: string; artifact: FirmwareArtifactReference }) => ({
@@ -222,7 +210,7 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
         })
       );
       assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan,
+        preparedPlan: payload.preparedPlan,
         executor: 'v2',
         platform: payload.platform,
         scopeTargets: [target, ...(target === 'firmware' ? (['resource'] as const) : [])],
@@ -230,7 +218,7 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       });
       this.params = {
         ...this.params,
-        preparedPlan,
+        preparedPlan: payload.preparedPlan,
         artifact: payload.artifact,
         resourceEntries: payload.resourceEntries,
         artifactReader: hostBinding.artifactReader,

package/src/api/FirmwareUpdateV3.ts

@@ -25,7 +25,6 @@ import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
   getFirmwareUpdateResourceName,
-  validateFirmwareUpdatePreparedPlan,
 } from './firmware/FirmwareUpdatePreparedPlan';
 
 import type {
@@ -78,19 +77,13 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'firmwareType', type: 'string' },
       { name: 'platform', type: 'string' },
     ]);
-    const preparedPlan =
+    const hostBinding =
       payload.artifacts || payload.preparedPlan
-        ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
+        ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
         : undefined;
-    const artifactReader = preparedPlan
-      ? resolveFirmwareUpdateHostBinding(
-          payload.hostBindingGeneration,
-          preparedPlan.preparedPlanDigest
-        ).artifactReader
-      : payload.artifactReader;
-    if (preparedPlan) {
+    if (hostBinding) {
       assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan,
+        preparedPlan: payload.preparedPlan,
         executor: 'v3',
         platform: payload.platform,
         scopeTargets: ['bootloader', 'firmware', 'resource', 'ble'],
@@ -131,7 +124,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
     }
 
     this.params = {
-      preparedPlan,
+      preparedPlan: payload.preparedPlan,
       bleBinary: payload.bleBinary,
       firmwareBinary: payload.firmwareBinary,
       forcedUpdateRes: payload.forcedUpdateRes,
@@ -142,7 +135,7 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       resourceBinary: payload.resourceBinary,
       firmwareType: payload.firmwareType,
       platform: payload.platform,
-      artifactReader,
+      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
       artifacts: payload.artifacts,
     };
   }