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

package/src/api/FirmwareUpdateV2.ts

@@ -29,10 +29,12 @@ import { DataManager } from '../data-manager';
 import { DEVICE } from '../events';
 import { type FirmwareByteSource, openFirmwareByteSource } from './firmware/FirmwareArtifactSource';
 import { resolveFirmwareUpdateHostBinding } from './firmware/FirmwareHostBinding';
+import { readVerifiedPreparedResourceArchive } from './firmware/FirmwarePreparedResourceArchive';
 import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
-  getFirmwareUpdateResourceName,
+  getFirmwareUpdatePreparedRawArtifact,
+  validateFirmwareUpdatePreparedPlan,
 } from './firmware/FirmwareUpdatePreparedPlan';
 
 import type { Features, KnownDevice } from '../types';
@@ -46,6 +48,7 @@ import type { FirmwareUpdatePreparedPlan } from '../types/api/firmwareUpdatePrep
 type Params = {
   binary?: ArrayBuffer;
   artifact?: FirmwareArtifactReference;
+  hostBindingGeneration?: number;
   resourceEntries?: Array<{
     entryName: string;
     artifact: FirmwareArtifactReference;
@@ -159,15 +162,17 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       { name: 'firmwareType', type: 'string' },
     ]);
 
-    if (
-      'binary' in payload &&
-      payload.binary !== undefined &&
-      'artifact' in payload &&
-      payload.artifact !== undefined
-    ) {
+    const hasPreparedPlan = payload.preparedPlan !== undefined;
+    if (hasPreparedPlan && (payload.binary !== undefined || payload.version !== undefined)) {
       throw ERRORS.TypedError(
         HardwareErrorCode.CallMethodInvalidParameter,
-        'Firmware update binary and artifact are mutually exclusive'
+        'Prepared firmware plans cannot be combined with legacy firmware inputs'
+      );
+    }
+    if (!hasPreparedPlan && payload.artifact !== undefined) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Firmware artifacts require a prepared plan'
       );
     }
 
@@ -184,7 +189,7 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       isUpdateBootloader: payload.isUpdateBootloader,
     };
 
-    if ('version' in payload) {
+    if (!hasPreparedPlan && 'version' in payload) {
       this.params = {
         ...this.params,
         version: payload.version,
@@ -192,16 +197,25 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
       };
     }
 
-    if ('binary' in payload) {
+    if (!hasPreparedPlan && 'binary' in payload) {
       this.params = {
         ...this.params,
         binary: payload.binary,
       };
     }
 
-    if ('artifact' in payload) {
-      const hostBinding = resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration);
+    if (hasPreparedPlan) {
+      const preparedPlan = validateFirmwareUpdatePreparedPlan(payload.preparedPlan);
+      const hostBinding = resolveFirmwareUpdateHostBinding(
+        payload.hostBindingGeneration,
+        preparedPlan.preparedPlanDigest
+      );
       const target = payload.isUpdateBootloader ? 'bootloader' : payload.updateType;
+      const plannedArtifact = getFirmwareUpdatePreparedRawArtifact({
+        preparedPlan,
+        target,
+        role: target,
+      }).artifact;
       const resourceBindings = (payload.resourceEntries ?? []).map(
         (entry: { entryName: string; artifact: FirmwareArtifactReference }) => ({
           target: 'resource' as const,
@@ -210,18 +224,21 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
         })
       );
       assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan: payload.preparedPlan,
+        preparedPlan,
         executor: 'v2',
         platform: payload.platform,
-        scopeTargets: [target, ...(target === 'firmware' ? (['resource'] as const) : [])],
-        bindings: [{ target, artifact: payload.artifact }, ...resourceBindings],
+        scopeTargets: [
+          target,
+          ...(target === 'firmware' && resourceBindings.length ? (['resource'] as const) : []),
+        ],
+        bindings: [{ target, artifact: payload.artifact ?? plannedArtifact }, ...resourceBindings],
       });
       this.params = {
         ...this.params,
-        preparedPlan: payload.preparedPlan,
-        artifact: payload.artifact,
-        resourceEntries: payload.resourceEntries,
+        preparedPlan,
+        artifact: plannedArtifact,
         artifactReader: hostBinding.artifactReader,
+        firmwareType: preparedPlan.firmwareType,
       };
     }
   }
@@ -531,6 +548,18 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
         }
       };
 
+      const preparedResourceRequested =
+        !params.isUpdateBootloader &&
+        params.updateType === 'firmware' &&
+        (params.preparedPlan?.targetsToUpdate.includes('resource') ?? false);
+      if (preparedResourceRequested && device.isBootloader()) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Prepared firmware resources require the device application mode',
+          { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared', artifactName: 'resource' }
+        );
+      }
+
       if (!device.isBootloader() && features) {
         const serialNo = device.getCurrentSerialNo();
         // should go to bootloader mode manually
@@ -541,72 +570,78 @@ export default class FirmwareUpdateV2 extends BaseMethod<Params> {
         // All network-backed input must be ready before the first device mutation.
         await acquireFirmwareSource();
 
-        // check & upgrade firmware resource
-        if (this.isSupportResourceUpdate(params.updateType)) {
+        // PreparedPlan 资源只依赖获批 ZIP；live release 仅保留给非 prepared 旧流程。
+        if (preparedResourceRequested) {
+          if (!this.isSupportResourceUpdate(params.updateType)) {
+            throw ERRORS.TypedError(
+              HardwareErrorCode.RuntimeError,
+              'Prepared firmware resources are not supported by this device',
+              { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared', artifactName: 'resource' }
+            );
+          }
           this.postTipMessage('CheckLatestUiResource');
-          const resourceUrl = DataManager.getSysResourcesLatestRelease({
-            features,
-            forcedUpdateRes: params.forcedUpdateRes,
-            firmwareType,
+          this.postTipMessage('DownloadLatestUiResource');
+          const verifiedEntries = await readVerifiedPreparedResourceArchive({
+            preparedPlan: params.preparedPlan as FirmwareUpdatePreparedPlan,
+            reader: params.artifactReader,
           });
-          if (resourceUrl) {
-            this.postTipMessage('DownloadLatestUiResource');
-            if (params.resourceEntries?.length) {
-              const sources: Array<{
-                entryName: string;
-                source: FirmwareByteSource;
-              }> = [];
-              try {
-                for (const entry of params.resourceEntries) {
-                  const resourceName = getFirmwareUpdateResourceName(entry.entryName);
-                  const source = await openFirmwareByteSource({
-                    artifact: entry.artifact,
-                    reader: params.artifactReader,
-                  });
-                  if (!source) {
-                    throw new Error('Firmware resource entry is not prepared');
-                  }
-                  sources.push({ entryName: resourceName, source });
-                }
-                await updateResourcesFromSources(
-                  this.device.getCommands().typedCall.bind(this.device.getCommands()),
-                  this.postMessage,
-                  device,
-                  sources.map(entry => ({
-                    entryName: entry.entryName,
-                    source: entry.source,
-                  }))
-                );
-              } finally {
-                await Promise.all(
-                  sources.map(entry => entry.source.close().catch(() => undefined))
-                );
-              }
-              this.postTipMessage('DownloadLatestUiResourceSuccess');
-            } else {
-              if (
-                params.artifactReader ||
-                DataManager.getSettings('firmwareManifestMode') === 'external-only'
-              ) {
+          const sources: Array<{ entryName: string; source: FirmwareByteSource }> = [];
+          try {
+            for (const entry of verifiedEntries) {
+              const source = await openFirmwareByteSource({ binary: entry.binary });
+              if (!source) {
                 throw ERRORS.TypedError(
                   HardwareErrorCode.RuntimeError,
-                  'Firmware resource must be prepared by the external firmware host',
+                  `Firmware resource entry ${entry.entryName} is empty`,
                   {
-                    firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+                    firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
                     artifactName: 'resource',
                   }
                 );
               }
-              const resourceBinary: ArrayBuffer | Buffer = (await getSysResourceBinary(resourceUrl))
-                .binary;
-              this.postTipMessage('DownloadLatestUiResourceSuccess');
-              await updateResources(
-                this.device.getCommands().typedCall.bind(this.device.getCommands()),
-                this.postMessage,
-                device,
-                resourceBinary
+              sources.push({ entryName: entry.entryName, source });
+            }
+            await updateResourcesFromSources(
+              this.device.getCommands().typedCall.bind(this.device.getCommands()),
+              this.postMessage,
+              device,
+              sources
+            );
+          } finally {
+            await Promise.all(sources.map(entry => entry.source.close().catch(() => undefined)));
+          }
+          this.postTipMessage('DownloadLatestUiResourceSuccess');
+        } else if (this.isSupportResourceUpdate(params.updateType)) {
+          this.postTipMessage('CheckLatestUiResource');
+          const resourceUrl = DataManager.getSysResourcesLatestRelease({
+            features,
+            forcedUpdateRes: params.forcedUpdateRes,
+            firmwareType,
+          });
+          if (resourceUrl) {
+            this.postTipMessage('DownloadLatestUiResource');
+            if (
+              params.artifactReader ||
+              DataManager.getSettings('firmwareManifestMode') === 'external-only'
+            ) {
+              throw ERRORS.TypedError(
+                HardwareErrorCode.RuntimeError,
+                'Firmware resource must be prepared by the external firmware host',
+                {
+                  firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+                  artifactName: 'resource',
+                }
               );
             }
+            const resourceBinary: ArrayBuffer | Buffer = (await getSysResourceBinary(resourceUrl))
+              .binary;
+            this.postTipMessage('DownloadLatestUiResourceSuccess');
+            await updateResources(
+              this.device.getCommands().typedCall.bind(this.device.getCommands()),
+              this.postMessage,
+              device,
+              resourceBinary
+            );
           }
         }
 

package/src/api/FirmwareUpdateV3.ts

@@ -21,10 +21,12 @@ import { DEVICE } from '../events';
 import { buildProtocolV1FeaturesPayload } from '../deviceProfile';
 import { openFirmwareByteSource } from './firmware/FirmwareArtifactSource';
 import { resolveFirmwareUpdateHostBinding } from './firmware/FirmwareHostBinding';
+import { readVerifiedPreparedResourceArchive } from './firmware/FirmwarePreparedResourceArchive';
 import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
-  getFirmwareUpdateResourceName,
+  getFirmwareUpdatePreparedRawArtifact,
+  validateFirmwareUpdatePreparedPlan,
 } from './firmware/FirmwareUpdatePreparedPlan';
 
 import type {
@@ -77,54 +79,97 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       { name: 'firmwareType', type: 'string' },
       { name: 'platform', type: 'string' },
     ]);
-    const hostBinding =
-      payload.artifacts || payload.preparedPlan
-        ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
-        : undefined;
-    if (hostBinding) {
+    const hasPreparedPlan = payload.preparedPlan !== undefined;
+    if (!hasPreparedPlan && payload.artifacts !== undefined) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Firmware artifacts require a prepared plan'
+      );
+    }
+    const preparedPlan = hasPreparedPlan
+      ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
+      : undefined;
+    const hasLegacyInputs = [
+      payload.bleVersion,
+      payload.bleBinary,
+      payload.firmwareVersion,
+      payload.firmwareBinary,
+      payload.resourceBinary,
+      payload.bootloaderVersion,
+      payload.bootloaderBinary,
+    ].some(input => input !== undefined);
+    if (preparedPlan && hasLegacyInputs) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Prepared firmware plans cannot be combined with legacy firmware inputs'
+      );
+    }
+    const artifactReader = preparedPlan
+      ? resolveFirmwareUpdateHostBinding(
+          payload.hostBindingGeneration,
+          preparedPlan.preparedPlanDigest
+        ).artifactReader
+      : payload.artifactReader;
+    const preparedArtifacts: NonNullable<FirmwareUpdateV3Params['artifacts']> = {};
+    if (preparedPlan) {
+      const componentTargets = ['bootloader', 'firmware', 'ble'] as const;
+      const supportedTargets = new Set<string>([...componentTargets, 'resource']);
+      const unsupportedTarget = preparedPlan.targetsToUpdate.find(
+        target => !supportedTargets.has(target)
+      );
+      if (unsupportedTarget) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          `Firmware prepared plan target ${unsupportedTarget} is not supported by V3`,
+          { firmwareUpdateCode: 'FirmwarePreparedPlanInvalid' }
+        );
+      }
+      for (const target of componentTargets) {
+        if (preparedPlan.targetsToUpdate.includes(target)) {
+          preparedArtifacts[target] = getFirmwareUpdatePreparedRawArtifact({
+            preparedPlan,
+            target,
+            role: target,
+          }).artifact;
+        }
+      }
+      const resourceBindings = (payload.artifacts?.resourceEntries ?? []).map(
+        (entry: { entryName: string; artifact: FirmwareArtifactReference }) => ({
+          target: 'resource' as const,
+          entryName: entry.entryName,
+          artifact: entry.artifact,
+        })
+      );
       assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan: payload.preparedPlan,
+        preparedPlan,
         executor: 'v3',
         platform: payload.platform,
-        scopeTargets: ['bootloader', 'firmware', 'resource', 'ble'],
+        scopeTargets: [
+          'bootloader',
+          'firmware',
+          'ble',
+          ...(resourceBindings.length ? (['resource'] as const) : []),
+        ],
         bindings: [
-          ...(payload.artifacts?.bootloader
-            ? [
-                {
-                  target: 'bootloader' as const,
-                  artifact: payload.artifacts.bootloader,
-                },
-              ]
-            : []),
-          ...(payload.artifacts?.firmware
-            ? [
-                {
-                  target: 'firmware' as const,
-                  artifact: payload.artifacts.firmware,
-                },
-              ]
-            : []),
-          ...(payload.artifacts?.ble
-            ? [
-                {
-                  target: 'ble' as const,
-                  artifact: payload.artifacts.ble,
-                },
-              ]
-            : []),
-          ...(payload.artifacts?.resourceEntries ?? []).map(
-            (entry: { entryName: string; artifact: FirmwareArtifactReference }) => ({
-              target: 'resource' as const,
-              entryName: entry.entryName,
-              artifact: entry.artifact,
-            })
-          ),
+          ...componentTargets.flatMap(target => {
+            const plannedArtifact = preparedArtifacts[target];
+            const suppliedArtifact = payload.artifacts?.[target];
+            return plannedArtifact || suppliedArtifact
+              ? [
+                  {
+                    target,
+                    artifact: suppliedArtifact ?? (plannedArtifact as FirmwareArtifactReference),
+                  },
+                ]
+              : [];
+          }),
+          ...resourceBindings,
         ],
       });
     }
 
     this.params = {
-      preparedPlan: payload.preparedPlan,
+      preparedPlan,
       bleBinary: payload.bleBinary,
       firmwareBinary: payload.firmwareBinary,
       forcedUpdateRes: payload.forcedUpdateRes,
@@ -133,10 +178,10 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
       bootloaderBinary: payload.bootloaderBinary,
       firmwareVersion: payload.firmwareVersion,
       resourceBinary: payload.resourceBinary,
-      firmwareType: payload.firmwareType,
+      firmwareType: preparedPlan?.firmwareType ?? payload.firmwareType,
       platform: payload.platform,
-      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
-      artifacts: payload.artifacts,
+      artifactReader,
+      artifacts: preparedPlan ? preparedArtifacts : undefined,
     };
   }
 
@@ -263,25 +308,25 @@ export default class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod<FirmwareU
   }
 
   private async prepareResourceInput(firmwareType: EFirmwareType) {
-    const preparedEntries = this.params.artifacts?.resourceEntries;
-    if (preparedEntries?.length && this.params.resourceBinary) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        'Firmware resource input must not contain both archive binary and prepared entries'
-      );
-    }
-    if (preparedEntries?.length) {
+    if (this.params.preparedPlan?.targetsToUpdate.includes('resource')) {
+      const verifiedEntries = await readVerifiedPreparedResourceArchive({
+        preparedPlan: this.params.preparedPlan,
+        reader: this.params.artifactReader,
+      });
       const resourceEntries: Array<{ entryName: string; source: FirmwareByteSource }> = [];
-      for (const entry of preparedEntries) {
-        const resourceName = getFirmwareUpdateResourceName(entry.entryName);
-        const source = await this.openArtifactSource(undefined, entry.artifact);
+      for (const entry of verifiedEntries) {
+        const source = await this.openArtifactSource(entry.binary, undefined);
         if (!source) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            `Firmware resource entry ${entry.entryName} is not prepared`
+            `Firmware resource entry ${entry.entryName} is empty`,
+            {
+              firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+              artifactName: 'resource',
+            }
           );
         }
-        resourceEntries.push({ entryName: resourceName, source });
+        resourceEntries.push({ entryName: entry.entryName, source });
       }
       return {
         resourceBinary: null,