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

package/src/api/UploadPortfolio.ts

@@ -1,6 +1,3 @@
-import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
-
-import { supportsProtocolV2Message } from '../protocols/protocol-v2/features';
 import FileWrite from './FileWrite';
 
 export type UploadPortfolioParams = {
@@ -10,8 +7,6 @@ export type UploadPortfolioParams = {
 
 const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.okpkg.pending';
 const PORTFOLIO_CHUNK_SIZE = 2048;
-const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
-const PORTFOLIO_UPDATE_MESSAGE_TYPE = 61400;
 
 export default class UploadPortfolio extends FileWrite {
   init() {
@@ -34,19 +29,6 @@ export default class UploadPortfolio extends FileWrite {
   }
 
   async run() {
-    const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
-    const hasFileWrite = supportsProtocolV2Message(
-      protocolInfo,
-      FILESYSTEM_FILE_WRITE_MESSAGE_TYPE
-    );
-    const hasPortfolioUpdate = supportsProtocolV2Message(
-      protocolInfo,
-      PORTFOLIO_UPDATE_MESSAGE_TYPE
-    );
-    if (!hasFileWrite || !hasPortfolioUpdate) {
-      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
-    }
-
     const stagedFile = await super.run();
     this.throwIfAborted();
     await this.device.commands.typedCall('PortfolioUpdate', 'Success', {});

package/src/api/device/DeviceUpdateBootloader.ts

@@ -14,7 +14,6 @@ import { resolveFirmwareUpdateHostBinding } from '../firmware/FirmwareHostBindin
 import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
-  validateFirmwareUpdatePreparedPlan,
 } from '../firmware/FirmwareUpdatePreparedPlan';
 import { getDeviceType, getDeviceUUID } from '../../utils';
 import { resolveDeviceBootloaderMode } from '../../utils/deviceFeaturesCompat';
@@ -158,42 +157,22 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     const { features } = device;
 
     const payload = this.payload as DeviceUpdateBootloaderParams;
-    const hasPreparedPlan = payload.preparedPlan !== undefined;
-    const hasPreparedArtifact = payload.artifact !== undefined;
-    if (hasPreparedPlan !== hasPreparedArtifact) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.CallMethodInvalidParameter,
-        'Prepared bootloader plans require exactly one prepared artifact'
-      );
-    }
-    if (payload.binary !== undefined && hasPreparedArtifact) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.CallMethodInvalidParameter,
-        'Bootloader binary and prepared artifact are mutually exclusive'
-      );
-    }
-    const preparedPlan = hasPreparedArtifact
-      ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
+    const hostBinding = payload.artifact
+      ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
       : undefined;
-    const artifactReader = preparedPlan
-      ? resolveFirmwareUpdateHostBinding(
-          payload.hostBindingGeneration,
-          preparedPlan.preparedPlanDigest
-        ).artifactReader
-      : payload.artifactReader;
     const executionParams = {
       ...payload,
-      artifactReader,
+      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
     };
     if (payload.artifact) {
       assertFirmwareUpdatePreparedPlanDeviceIdentity({
-        preparedPlan,
+        preparedPlan: payload.preparedPlan,
         deviceIdentity: getDeviceUUID(features) || undefined,
         bootloaderMode: resolveDeviceBootloaderMode(features),
         deviceModel: String(getDeviceType(features)),
       });
       assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan,
+        preparedPlan: payload.preparedPlan,
         executor: 'v2',
         scopeTargets: ['bootloader'],
         bindings: [

package/src/api/firmware/FirmwareHostBinding.ts

@@ -16,8 +16,6 @@ class FirmwareHostBindingRegistry {
   register(binding: FirmwareUpdateHostBinding): number {
     if (
       !binding ||
-      typeof binding.preparedPlanDigest !== 'string' ||
-      !/^[0-9a-f]{64}$/i.test(binding.preparedPlanDigest) ||
       typeof binding.artifactReader?.open !== 'function' ||
       typeof binding.artifactReader.read !== 'function' ||
       typeof binding.artifactReader.close !== 'function'
@@ -42,7 +40,7 @@ class FirmwareHostBindingRegistry {
     return this.generation;
   }
 
-  resolve(generation: number, preparedPlanDigest?: string): FirmwareUpdateHostBinding {
+  resolve(generation: number): FirmwareUpdateHostBinding {
     if (
       !Number.isSafeInteger(generation) ||
       generation <= 0 ||
@@ -52,21 +50,12 @@ class FirmwareHostBindingRegistry {
       return bindingError(`Firmware host binding generation ${generation} is stale`);
     }
     const { binding } = this;
-    if (
-      preparedPlanDigest !== undefined &&
-      binding.preparedPlanDigest.toLowerCase() !== preparedPlanDigest.toLowerCase()
-    ) {
-      return bindingError(
-        `Firmware host binding generation ${generation} does not match the prepared plan`
-      );
-    }
     const assertCurrent = () => {
       if (generation !== this.generation || binding !== this.binding) {
         bindingError(`Firmware host binding generation ${generation} is stale`);
       }
     };
     return {
-      preparedPlanDigest: binding.preparedPlanDigest,
       artifactReader: {
         open: async input => {
           assertCurrent();
@@ -107,7 +96,5 @@ export const getFirmwareUpdateHostBindingGeneration = (): number =>
   firmwareHostBindingRegistry.getGeneration();
 
 export const resolveFirmwareUpdateHostBinding = (
-  generation: number | undefined,
-  preparedPlanDigest?: string
-): FirmwareUpdateHostBinding =>
-  firmwareHostBindingRegistry.resolve(generation ?? Number.NaN, preparedPlanDigest);
+  generation: number | undefined
+): FirmwareUpdateHostBinding => firmwareHostBindingRegistry.resolve(generation ?? Number.NaN);

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -191,6 +191,8 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
           !hasPromptedWebDevice &&
           !isPromptingWebDevice
         ) {
+          clearInterval(intervalTimer);
+          clearTimeout(timeoutTimer);
           isPromptingWebDevice = true;
           try {
             this.postTipMessage(FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);

package/src/api/firmware/FirmwareUpdatePlan.ts

@@ -10,14 +10,13 @@ import {
   getDeviceFirmwareVersion,
 } from '../../utils/deviceVersionUtils';
 
-import type { FirmwareUpdateV4Target } from '../../types/api/firmwareUpdate';
 import type {
   FirmwareUpdatePlan,
   FirmwareUpdatePlanArtifact,
   FirmwareUpdatePlanForceTarget,
   FirmwareUpdatePlanTarget,
 } from '../../types/api/firmwareUpdatePlan';
-import type { Features, IProtocolV2ResourceSource } from '../../types';
+import type { Features } from '../../types';
 
 type FirmwareUpdatePlatform = 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
 
@@ -31,6 +30,7 @@ type ReleaseRecord = {
   version?: unknown;
   components?: unknown;
   installOrder?: unknown;
+  resourceBundles?: unknown;
   fingerprint?: unknown;
   fingerprintWeb?: unknown;
   expectedSize?: unknown;
@@ -62,11 +62,6 @@ const PROTOCOL_V2_TARGETS: Readonly<
   SE04: 'se04',
 };
 
-const PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS = new Set<FirmwareUpdateV4Target>([
-  ...Object.values(PROTOCOL_V2_TARGETS),
-  'resource',
-]);
-
 const asRecord = (value: unknown): Record<string, unknown> | undefined =>
   value && typeof value === 'object' && !Array.isArray(value)
     ? (value as Record<string, unknown>)
@@ -196,23 +191,6 @@ export const validateFirmwareUpdatePlanForceTargets = (
   return [...value] as FirmwareUpdatePlanForceTarget[];
 };
 
-export const validateProtocolV2FirmwareUpdateTargets = (
-  value: unknown
-): FirmwareUpdateV4Target[] => {
-  if (value === undefined) {
-    return [];
-  }
-  if (
-    !Array.isArray(value) ||
-    value.length > PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.size ||
-    value.some(target => !PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.has(target)) ||
-    new Set(value).size !== value.length
-  ) {
-    return planError('Protocol V2 firmware update targets are invalid');
-  }
-  return [...value] as FirmwareUpdateV4Target[];
-};
-
 const assertExactKeys = (
   value: Record<string, unknown>,
   required: readonly string[],
@@ -373,11 +351,13 @@ export const assertFirmwareUpdatePlan = (value: unknown): FirmwareUpdatePlan =>
       plan.targetsToUpdate.some(target =>
         legacyOnlyTargets.has(target as FirmwareUpdatePlanTarget)
       )) ||
-    // V2 仅在 bootloader 恢复时允许缺少身份；V4 设备在尚未写入序列号时也可升级。
-    // 这类 Plan 仍通过设备型号、目标、工件摘要与 preparedPlanDigest 进行约束。
+    // Only executor v2 services identity-less bootloader recovery (classic family);
+    // Pro (v3) and Pro2 (v4) report a serial even in bootloader mode, so their plans
+    // must always carry a real identity. Degraded v2 plans are bound to the live
+    // device at install time instead.
     (plan.artifacts.length > 0 &&
       (plan.platform === 'native' || plan.platform === 'desktop') &&
-      plan.executor === 'v3' &&
+      plan.executor !== 'v2' &&
       plan.deviceIdentity === 'unavailable')
   ) {
     return planError('Firmware update plan executor contract is invalid');
@@ -425,7 +405,7 @@ const selectResourceUrl = ({
 
 const getExecutor = (features: Features): FirmwareUpdatePlan['executor'] => {
   const deviceType = getDeviceType(features);
-  if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) {
+  if (deviceType === EDeviceType.Pro2) {
     return 'v4';
   }
   if (
@@ -441,10 +421,10 @@ const buildProtocolV2Artifacts = (
   release: ReleaseRecord,
   {
     includeComponents = true,
-    componentTargets: selectedComponentTargets,
+    includeResources = true,
   }: {
     includeComponents?: boolean;
-    componentTargets?: ReadonlySet<FirmwareUpdatePlanTarget>;
+    includeResources?: boolean;
   } = {}
 ): {
   artifacts: FirmwareUpdatePlanArtifact[];
@@ -465,21 +445,12 @@ const buildProtocolV2Artifacts = (
     includeComponents && components
       ? [...installOrder, ...Object.keys(components).filter(key => !installOrder.includes(key))]
       : [];
-  const selectedComponentKeys = selectedComponentTargets
-    ? componentKeys.filter(key => {
-        const component = asRecord(components?.[key]);
-        const targetName = asString(component?.target)?.toUpperCase();
-        const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
-        return !!target && selectedComponentTargets.has(target);
-      })
-    : componentKeys;
   const artifacts: FirmwareUpdatePlanArtifact[] = [];
   const targets: FirmwareUpdatePlanTarget[] = [];
-  const componentTargetSet = new Set<FirmwareUpdatePlanTarget>();
-  for (const key of selectedComponentKeys) {
+  const componentTargets = new Set<FirmwareUpdatePlanTarget>();
+  for (const key of componentKeys) {
     const component = asRecord(components?.[key]);
     const targetName = asString(component?.target)?.toUpperCase();
-    const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
     if (targetName === 'ROMLOADER') {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
@@ -487,6 +458,7 @@ const buildProtocolV2Artifacts = (
         { firmwareUpdateCode: 'FirmwarePlanInvalid' }
       );
     }
+    const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
     if (!component || !target) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
@@ -494,21 +466,14 @@ const buildProtocolV2Artifacts = (
         { firmwareUpdateCode: 'FirmwarePlanInvalid' }
       );
     }
-    if (componentTargetSet.has(target)) {
+    if (componentTargets.has(target)) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
         `Protocol V2 component ${key} duplicates target ${target}`,
         { firmwareUpdateCode: 'FirmwarePlanInvalid' }
       );
     }
-    componentTargetSet.add(target);
-    const integrity = asIntegrity({
-      size: component.expectedSize,
-      sha256: component.fingerprint,
-    });
-    if (integrity.expectedSize === undefined || integrity.expectedSha256 === undefined) {
-      planError(`Protocol V2 component ${key} integrity metadata is invalid`);
-    }
+    componentTargets.add(target);
     artifacts.push({
       artifactId: `component:${target}`,
       role: 'component',
@@ -516,12 +481,52 @@ const buildProtocolV2Artifacts = (
       url: assertArtifactUrl(component.url, `Protocol V2 component ${key}`),
       container: 'raw',
       logicalName: key,
-      ...integrity,
+      ...asIntegrity({
+        size: component.expectedSize,
+        sha256: component.fingerprint,
+      }),
       ...(asVersion(component.version) ? { targetVersion: asVersion(component.version) } : {}),
     });
     targets.push(target);
   }
 
+  const bundles =
+    includeResources && Array.isArray(release.resourceBundles) ? release.resourceBundles : [];
+  const resourceBundleNames = new Set<string>();
+  for (const value of bundles) {
+    const bundle = asRecord(value);
+    const name = asString(bundle?.name);
+    if (!bundle || !name) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 resource bundle is invalid',
+        { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+      );
+    }
+    if (resourceBundleNames.has(name)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 resource bundle duplicates name ${name}`,
+        { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+      );
+    }
+    resourceBundleNames.add(name);
+    artifacts.push({
+      artifactId: `resourceBundle:${name}`,
+      role: 'resourceBundle',
+      target: 'resource',
+      url: assertArtifactUrl(bundle.url, `Protocol V2 resource bundle ${name}`),
+      container: 'raw',
+      logicalName: name,
+      ...asIntegrity({
+        size: bundle.expectedSize,
+        sha256: bundle.fingerprint,
+      }),
+    });
+  }
+  if (bundles.length > 0) {
+    targets.push('resource');
+  }
   return { artifacts, targets: [...new Set(targets)] };
 };
 
@@ -582,179 +587,6 @@ const assertForcedTargetsRepresented = ({
   }
 };
 
-const finalizeFirmwareUpdatePlan = ({
-  features,
-  firmwareType,
-  platform,
-  artifacts,
-  targetsToUpdate,
-}: {
-  features: Features;
-  firmwareType: EFirmwareType;
-  platform: FirmwareUpdatePlatform;
-  artifacts: FirmwareUpdatePlanArtifact[];
-  targetsToUpdate: FirmwareUpdatePlanTarget[];
-}): FirmwareUpdatePlan => {
-  const executor = getExecutor(features);
-  const bootloaderMode = resolveDeviceBootloaderMode(features);
-  // 'unavailable' is the reserved degraded-identity sentinel; a device-reported
-  // serial must never be able to collide with it.
-  const reportedIdentity = getDeviceUUID(features);
-  const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
-  // Classic 系列仅在 bootloader 恢复时允许缺少身份；部分尚未完成产线写号的
-  // Pro2/Neo（V4）在正常模式下也可能没有序列号，因此允许使用降级身份。
-  const allowsUnavailableIdentity = (bootloaderMode && executor === 'v2') || executor === 'v4';
-  if (
-    artifacts.length > 0 &&
-    (platform === 'native' || platform === 'desktop') &&
-    !deviceIdentity &&
-    !allowsUnavailableIdentity
-  ) {
-    throw ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      'Prepared firmware update requires a stable device identity',
-      { firmwareUpdateCode: 'FirmwarePlanInvalid' }
-    );
-  }
-  const planWithoutDigest: Omit<FirmwareUpdatePlan, 'planDigest'> = {
-    schemaVersion: 2,
-    executor,
-    deviceIdentity: deviceIdentity || 'unavailable',
-    deviceModel: String(getDeviceType(features)),
-    firmwareType,
-    platform,
-    artifacts,
-    targetsToUpdate,
-  };
-  return assertFirmwareUpdatePlan({
-    ...planWithoutDigest,
-    planDigest: digestFirmwareUpdatePlan(planWithoutDigest),
-  });
-};
-
-export type ProtocolV2LocalFirmwareUpdatePlanArtifact = {
-  artifactId: string;
-  target: Exclude<FirmwareUpdateV4Target, 'boot_resources'>;
-  container: 'raw' | 'zip';
-  logicalName: string;
-  expectedSize: number;
-  expectedSha256: string;
-  targetVersion?: string;
-};
-
-export const buildProtocolV2LocalFirmwareUpdatePlan = ({
-  features,
-  firmwareType,
-  platform,
-  artifacts,
-}: {
-  features: Features;
-  firmwareType: EFirmwareType;
-  platform: FirmwareUpdatePlatform;
-  artifacts: ProtocolV2LocalFirmwareUpdatePlanArtifact[];
-}): FirmwareUpdatePlan => {
-  if (artifacts.length === 0) {
-    return planError('Protocol V2 local firmware plan has no artifacts');
-  }
-  const plan = finalizeFirmwareUpdatePlan({
-    features,
-    firmwareType,
-    platform,
-    artifacts: artifacts.map(artifact => ({
-      ...artifact,
-      role: artifact.target === 'resource' ? 'resourceBundle' : 'component',
-      url: `https://local-firmware.invalid/${encodeURIComponent(artifact.artifactId)}`,
-    })),
-    targetsToUpdate: artifacts.map(artifact => artifact.target),
-  });
-  if (plan.executor !== 'v4') {
-    return planError('Protocol V2 local firmware plan requires executor v4');
-  }
-  return plan;
-};
-
-export const buildProtocolV2FirmwareUpdatePlan = ({
-  features,
-  firmwareType,
-  platform,
-  release,
-  targetsToUpdate,
-  forceUpdateTargets,
-  resourceArchive,
-}: {
-  features: Features;
-  firmwareType: EFirmwareType;
-  platform: FirmwareUpdatePlatform;
-  release: ReleaseRecord | undefined;
-  targetsToUpdate: readonly FirmwareUpdateV4Target[];
-  forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
-  resourceArchive: IProtocolV2ResourceSource | undefined;
-}): FirmwareUpdatePlan => {
-  const validatedForceTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
-  if (validatedForceTargets.some(target => target === 'ble' || target === 'bootloader')) {
-    planError('Protocol V2 does not support forced BLE or legacy bootloader targets');
-  }
-
-  const requestedComponentTargets = new Set<FirmwareUpdatePlanTarget>(
-    targetsToUpdate.filter(target => target !== 'resource')
-  );
-  if (
-    getDeviceType(features) === EDeviceType.Neo &&
-    (requestedComponentTargets.has('se03') || requestedComponentTargets.has('se04'))
-  ) {
-    planError('Neo does not support Protocol V2 targets se03 or se04');
-  }
-  const protocolV2 = buildProtocolV2Artifacts(release ?? {}, {
-    includeComponents: requestedComponentTargets.size > 0,
-    componentTargets: requestedComponentTargets,
-  });
-  const resourceRequested = targetsToUpdate.includes('resource');
-  if (resourceRequested) {
-    const archive = resourceArchive;
-    if (!archive) {
-      return planError('Protocol V2 resource target has no resource archive');
-    }
-    const integrity = asIntegrity({
-      size: archive.archiveSize,
-      sha256: archive.archiveSha256,
-    });
-    if (integrity.expectedSize === undefined || integrity.expectedSha256 === undefined) {
-      planError('Protocol V2 resource archive integrity metadata is invalid');
-    }
-    protocolV2.artifacts.push({
-      artifactId: 'resource:archive',
-      role: 'resourceBundle',
-      target: 'resource',
-      url: assertArtifactUrl(archive.archiveUrl, 'Protocol V2 resource archive'),
-      container: 'zip',
-      logicalName: 'protocol-v2-resource-archive',
-      ...integrity,
-    });
-    protocolV2.targets.push('resource');
-  }
-  const representedTargets = new Set(protocolV2.targets);
-  const missingTarget = Array.from(requestedComponentTargets).find(
-    target => !representedTargets.has(target)
-  );
-  if (missingTarget) {
-    planError(`Protocol V2 release does not contain requested target ${missingTarget}`);
-  }
-  if (validatedForceTargets.includes('firmware') && protocolV2.targets.length === 0) {
-    planError('Forced firmware update target firmware is not represented by the plan');
-  }
-  if (validatedForceTargets.includes('resource') && !resourceArchive) {
-    planError('Forced firmware update target resource has no Protocol V2 resource archive');
-  }
-
-  return finalizeFirmwareUpdatePlan({
-    features,
-    firmwareType,
-    platform,
-    artifacts: protocolV2.artifacts,
-    targetsToUpdate: protocolV2.targets,
-  });
-};
-
 export const buildFirmwareUpdatePlan = ({
   features,
   firmwareType,
@@ -803,6 +635,7 @@ export const buildFirmwareUpdatePlan = ({
   if (executor === 'v4' && (shouldUpdateFirmware || shouldUpdateResource)) {
     const protocolV2 = buildProtocolV2Artifacts(firmwareRelease ?? {}, {
       includeComponents: shouldUpdateFirmware,
+      includeResources: shouldUpdateResource,
     });
     artifacts = protocolV2.artifacts;
     targetsToUpdate = protocolV2.targets;
@@ -900,11 +733,40 @@ export const buildFirmwareUpdatePlan = ({
     artifacts,
     targetsToUpdate,
   });
-  return finalizeFirmwareUpdatePlan({
-    features,
+
+  // 'unavailable' is the reserved degraded-identity sentinel; a device-reported
+  // serial must never be able to collide with it.
+  const reportedIdentity = getDeviceUUID(features);
+  const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
+  // Bootloader-mode classic-family devices (executor v2, e.g. classic1s) cannot report
+  // a serial number, so their recovery plans fall back to the degraded 'unavailable'
+  // identity. Binding is then enforced against the live device at install time instead
+  // (assertFirmwareUpdatePreparedPlanDeviceIdentity), and plan integrity by the digest.
+  // Pro (v3) and Pro2 (v4) report a serial even in bootloader mode and stay strict.
+  if (
+    artifacts.length > 0 &&
+    (platform === 'native' || platform === 'desktop') &&
+    !deviceIdentity &&
+    !(bootloaderMode && executor === 'v2')
+  ) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Prepared firmware update requires a stable device identity',
+      { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+    );
+  }
+  const planWithoutDigest: Omit<FirmwareUpdatePlan, 'planDigest'> = {
+    schemaVersion: 2,
+    executor,
+    deviceIdentity: deviceIdentity || 'unavailable',
+    deviceModel: String(getDeviceType(features)),
     firmwareType,
     platform,
     artifacts,
     targetsToUpdate,
+  };
+  return assertFirmwareUpdatePlan({
+    ...planWithoutDigest,
+    planDigest: digestFirmwareUpdatePlan(planWithoutDigest),
   });
 };

package/src/api/firmware/FirmwareUpdatePreparedPlan.ts

@@ -278,14 +278,7 @@ export const validateFirmwareUpdatePreparedPlan = (value: unknown): FirmwareUpda
     artifactIds.add(artifact.artifactId);
     artifactTargets.add(artifact.target);
     assertFirmwareArtifactReference(artifact.artifact);
-    const materializedEntryNames =
-      artifact.materializedEntries?.map(entry => {
-        assertPreparedEntry(entry);
-        return getFirmwareUpdateResourceName(entry.entryName).toLowerCase();
-      }) ?? [];
-    if (new Set(materializedEntryNames).size !== materializedEntryNames.length) {
-      return preparedPlanError('Firmware prepared plan contains duplicate entry names');
-    }
+    artifact.materializedEntries?.forEach(assertPreparedEntry);
   }
   if (
     preparedPlan.targetsToUpdate.some(target => !FIRMWARE_UPDATE_PLAN_TARGETS.has(target)) ||
@@ -349,8 +342,8 @@ export const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({
     }
     const pinnedIdentity = degradedPlanIdentityPins.get(preparedPlan.leaseRef);
     if (!deviceIdentity) {
-      // V4 设备可能尚未写入序列号；V2 则只允许 bootloader 恢复流程缺少身份。
-      if (preparedPlan.executor !== 'v4' && bootloaderMode !== true) {
+      // Still identity-less: only legitimate while the device sits in bootloader.
+      if (bootloaderMode !== true) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
       }
       return preparedPlan;