@onekeyfe/hd-core 1.2.0-alpha.64 → 1.2.0-alpha.66

package/src/api/CheckAllFirmwareRelease.ts

@@ -1,7 +1,6 @@
-import { EFirmwareType, ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } 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 {
@@ -9,18 +8,13 @@ import {
   getBootloaderReleaseInfo,
   getFirmwareReleaseInfo,
 } from './firmware/releaseHelper';
-import {
-  buildFirmwareUpdatePlan,
-  validateFirmwareUpdatePlanForceTargets,
-} from './firmware/FirmwareUpdatePlan';
 import { getBridgeReleaseInfo } from '../utils/bridgeUpdate';
+import { getDeviceFirmwareVersion, getDeviceType, getFirmwareType } from '../utils';
+import { BaseMethod } from './BaseMethod';
 import {
-  LoggerNames,
-  getDeviceFirmwareVersion,
-  getDeviceType,
-  getFirmwareType,
-  getLogger,
-} from '../utils';
+  buildProtocolV2ResourceUpdatePlan,
+  readProtocolV2ResourceInventory,
+} from '../protocols/protocol-v2/resources';
 
 import type {
   AllFirmwareRelease,
@@ -36,7 +30,6 @@ import type {
   IProtocolV2FirmwareComponent,
   IProtocolV2FirmwareComponentTarget,
 } from '../types';
-import type { FirmwareUpdatePlan } from '../types/api/firmwareUpdatePlan';
 
 const UPDATE_TARGET_BY_COMPONENT_TARGET: Readonly<
   Partial<Record<IProtocolV2FirmwareComponentTarget, FirmwareUpdateV4Target>>
@@ -101,6 +94,7 @@ function buildComponentRelease({
   component,
   currentVersions,
   currentVerification,
+  checkFirmwareHash,
   remotePayloadHash,
   releaseRequired,
 }: {
@@ -108,6 +102,7 @@ function buildComponentRelease({
   component: IProtocolV2FirmwareComponent;
   currentVersions: DeviceStateVersions;
   currentVerification: Partial<DeviceFeaturesVerify>;
+  checkFirmwareHash: boolean;
   remotePayloadHash: string | null | undefined;
   releaseRequired: boolean;
 }): ProtocolV2FirmwareComponentRelease {
@@ -136,7 +131,7 @@ function buildComponentRelease({
       status = 'valid';
     } else {
       const currentHashKey = CURRENT_HASH_BY_COMPONENT_TARGET[componentTarget];
-      if (!currentHashKey) {
+      if (!checkFirmwareHash || !currentHashKey) {
         status = 'valid';
       } else {
         const currentHash = normalizeHex(currentVerification[currentHashKey]);
@@ -175,12 +170,14 @@ type ProtocolV2FirmwareReleasePlan = {
 export function buildProtocolV2FirmwareRelease({
   currentVersions,
   currentVerification = {},
+  checkFirmwareHash = false,
   remotePayloadHashes = {},
   firmwareType,
   release,
 }: {
   currentVersions: DeviceStateVersions;
   currentVerification?: Partial<DeviceFeaturesVerify>;
+  checkFirmwareHash?: boolean;
   remotePayloadHashes?: Readonly<Record<string, string | null>>;
   firmwareType: EFirmwareType;
   release: IFirmwareReleaseInfo | undefined;
@@ -204,6 +201,7 @@ export function buildProtocolV2FirmwareRelease({
       component,
       currentVersions,
       currentVerification,
+      checkFirmwareHash,
       remotePayloadHash: Object.prototype.hasOwnProperty.call(remotePayloadHashes, configKey)
         ? remotePayloadHashes[configKey]
         : normalizeHex(component.payloadHash),
@@ -230,9 +228,6 @@ export function buildProtocolV2FirmwareRelease({
   const targetsToUpdate = components.flatMap(component =>
     component.status === 'outdated' && component.updateTarget ? [component.updateTarget] : []
   );
-  if (targetsToUpdate.length > 0 && release.resourceBundles?.length) {
-    targetsToUpdate.push('resource');
-  }
   const uniqueTargetsToUpdate = Array.from(new Set(targetsToUpdate));
   const hasUpgrade = uniqueTargetsToUpdate.length > 0;
   const required = release.required && hasUpgrade;
@@ -257,8 +252,6 @@ export function buildProtocolV2FirmwareRelease({
   };
 }
 
-const Log = getLogger(LoggerNames.Method);
-
 export default class CheckAllFirmwareRelease extends BaseMethod {
   getSupportedProtocols() {
     return ['V1', 'V2'] as const;
@@ -276,13 +269,8 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
     }
 
     const { features } = this.device;
-    const {
-      checkBridgeRelease,
-      firmwareType: firmwareTypeParams,
-      platform,
-      forceUpdateTargets,
-    } = this.payload as CheckAllFirmwareReleaseParams;
-    const validatedForceUpdateTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
+    const { checkBridgeRelease, firmwareType: firmwareTypeParams } = this
+      .payload as CheckAllFirmwareReleaseParams;
 
     if (!features) {
       return Promise.resolve(null);
@@ -313,32 +301,6 @@ 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,
@@ -353,18 +315,21 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
           }
         : undefined,
       features,
-      firmwareUpdatePlan,
-    } as unknown as AllFirmwareRelease;
+    } as AllFirmwareRelease;
   }
 
   private async runProtocolV2(): Promise<AllFirmwareRelease> {
+    const { checkFirmwareHash = false, firmwareType: firmwareTypeParam } = this
+      .payload as CheckAllFirmwareReleaseParams;
     const state = await this.device.getDeviceState({
-      refreshSections: ['identity', 'versions', 'verification'],
+      refreshSections: checkFirmwareHash
+        ? ['identity', 'versions', 'verification']
+        : ['identity', 'versions'],
     });
-    if (state.identity.deviceType !== 'pro2') {
+    if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
       throw ERRORS.TypedError(
         HardwareErrorCode.DeviceNotSupportMethod,
-        'checkAllFirmwareRelease requires a Pro2 device for Protocol V2'
+        'checkAllFirmwareRelease requires a Pro2 or Neo device for Protocol V2'
       );
     }
 
@@ -376,16 +341,47 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
       );
     }
 
-    const { firmwareType: firmwareTypeParam } = this.payload as CheckAllFirmwareReleaseParams;
     const firmwareType =
       firmwareTypeParam ?? state.identity.firmwareType ?? EFirmwareType.Universal;
     const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
     const plan = buildProtocolV2FirmwareRelease({
       currentVersions: state.versions,
-      currentVerification: state.verification,
+      currentVerification: checkFirmwareHash ? state.verification : undefined,
+      checkFirmwareHash,
       firmwareType,
       release,
     });
+    const resourceDeviceType =
+      state.identity.deviceType === 'neo' ? EDeviceType.Neo : EDeviceType.Pro2;
+    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;
+        }
+      }
+    }
+    const targetsToUpdate = [
+      ...plan.targetsToUpdate,
+      ...(resourceStatus === 'outdated' ? (['resource'] as const) : []),
+    ];
     const firmwareStatus = plan.status === 'unavailable' ? 'unknown' : plan.status;
     const emptyRelease = 'none' as const;
 
@@ -406,8 +402,11 @@ export default class CheckAllFirmwareRelease extends BaseMethod {
       },
       features,
       protocol: 'V2',
-      deviceType: 'pro2',
+      deviceType: state.identity.deviceType,
       ...plan,
+      resourceStatus,
+      hasUpgrade: plan.hasUpgrade || resourceStatus === 'outdated',
+      targetsToUpdate,
     };
   }
 }

package/src/api/DetectDeviceConnectProtocol.ts

@@ -0,0 +1,18 @@
+import { BaseMethod } from './BaseMethod';
+
+export default class DetectDeviceConnectProtocol extends BaseMethod {
+  init() {
+    this.payload.forceProtocolDetection = true;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.unlockPolicy = 'none';
+  }
+
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
+  run() {
+    return Promise.resolve(this.device.getProtocol());
+  }
+}

package/src/api/FirmwareUpdate.ts

@@ -10,7 +10,6 @@ import { UI_REQUEST } from '../constants/ui-request';
 import { BaseMethod } from './BaseMethod';
 import { validateParams } from './helpers/paramsValidator';
 import { getBinary } from './firmware/getBinary';
-import { BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS } from './firmware/FirmwareUpdateBaseMethod';
 import { uploadFirmware } from './firmware/uploadFirmware';
 import { createUiMessage } from '../events';
 import { DeviceModelToTypes, type KnownDevice } from '../types';
@@ -79,10 +78,6 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
     this.checkPromise = createDeferred();
     const env = DataManager.getSettings('env');
     const isBleReconnect = connectId && DataManager.isBleConnect(env);
-    // Tracks the in-flight BLE probe so interval ticks never overlap: a superseded
-    // Initialize left pending on the V1 transport is exactly what later times out
-    // and used to tear down the connection mid-firmware-upload.
-    let bleProbeInFlight = false;
 
     Log.log('FirmwareUpdate [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
 
@@ -90,18 +85,14 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
     const intervalTimer: ReturnType<typeof setInterval> | undefined = setInterval(
       async () => {
         if (isBleReconnect) {
-          if (bleProbeInFlight) return;
-          bleProbeInFlight = true;
           try {
             await this.device.deviceConnector?.acquire(
               this.device.originalDescriptor.id,
               null,
-              true
+              true,
+              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType
             );
-            // Bound each probe so a request the rebooting device never received
-            // frees the slot for the next tick instead of hanging into the
-            // 30s reboot budget.
-            await this.device.initialize({ timeoutMs: BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS });
+            await this.device.initialize();
             if (this.device.isBootloader()) {
               clearInterval(intervalTimer);
               this.checkPromise?.resolve(true);
@@ -109,13 +100,14 @@ export default class FirmwareUpdate extends BaseMethod<Params> {
           } catch (e) {
             // ignore error because of device is not connected
             Log.log('catch Bluetooth error when device is restarting: ', e);
-          } finally {
-            bleProbeInFlight = false;
           }
         } else {
           const deviceDiff = await this.device.deviceConnector?.enumerate();
           const devicesDescriptor = deviceDiff?.descriptors ?? [];
-          const { deviceList } = await DevicePool.getDevices(devicesDescriptor, connectId);
+          const { deviceList } = await DevicePool.getDevices(devicesDescriptor, connectId, {
+            connectProtocol:
+              this.payload.connectProtocol ?? this.device.originalDescriptor.protocolType,
+          });
 
           if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
             // should update current device from cache