@onekeyfe/hd-core 1.1.34-alpha.2 → 1.1.34-alpha.3

package/src/api/firmware/FirmwareUpdatePlan.ts

@@ -0,0 +1,729 @@
+import { bytesToHex } from '@noble/hashes/utils';
+import { sha256 } from '@noble/hashes/sha256';
+import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import semver from 'semver';
+
+import { getDeviceType, getDeviceUUID } from '../../utils/deviceInfoUtils';
+import {
+  getDeviceBootloaderVersion,
+  getDeviceFirmwareVersion,
+} from '../../utils/deviceVersionUtils';
+
+import type {
+  FirmwareUpdatePlan,
+  FirmwareUpdatePlanArtifact,
+  FirmwareUpdatePlanEpoch,
+  FirmwareUpdatePlanEpochKind,
+  FirmwareUpdatePlanTarget,
+} from '../../types/api/firmwareUpdatePlan';
+import type { Features } from '../../types';
+
+type FirmwareUpdatePlatform = 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
+
+type ReleaseRecord = {
+  url?: unknown;
+  webUpdate?: unknown;
+  resource?: unknown;
+  fullResource?: unknown;
+  fullResourceRange?: unknown;
+  bootloaderResource?: unknown;
+  version?: unknown;
+  components?: unknown;
+  installOrder?: unknown;
+  resourceBundles?: unknown;
+  fingerprint?: unknown;
+  fingerprintWeb?: unknown;
+  expectedSize?: unknown;
+  resourceFingerprint?: unknown;
+  resourceExpectedSize?: unknown;
+  fullResourceFingerprint?: unknown;
+  fullResourceExpectedSize?: unknown;
+  bootloaderFingerprint?: unknown;
+  bootloaderExpectedSize?: unknown;
+  bootloaderVersion?: unknown;
+};
+
+type ReleaseSelection = {
+  shouldUpdate?: boolean;
+  status?: unknown;
+  release?: unknown;
+};
+
+const PROTOCOL_V2_TARGETS: Readonly<
+  Record<string, Exclude<FirmwareUpdatePlanTarget, 'firmware' | 'ble' | 'bootloader' | 'resource'>>
+> = {
+  BOOTLOADER: 'boot',
+  APPLICATION_P1: 'app_v1',
+  APPLICATION_P2: 'app_v2',
+  COPROCESSOR: 'coprocessor',
+  SE01: 'se01',
+  SE02: 'se02',
+  SE03: 'se03',
+  SE04: 'se04',
+};
+
+const asRecord = (value: unknown): Record<string, unknown> | undefined =>
+  value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+
+const asRelease = (release: ReleaseSelection | undefined): ReleaseRecord | undefined =>
+  asRecord(release?.release) as ReleaseRecord | undefined;
+
+const asString = (value: unknown): string | undefined =>
+  typeof value === 'string' && value.length > 0 ? value : undefined;
+
+const asVersion = (value: unknown): string | undefined => {
+  if (
+    !Array.isArray(value) ||
+    value.length !== 3 ||
+    value.some(part => typeof part !== 'number' || !Number.isSafeInteger(part) || part < 0)
+  ) {
+    return undefined;
+  }
+  return value.join('.');
+};
+
+const asIntegrity = ({
+  size,
+  sha256: value,
+}: {
+  size: unknown;
+  sha256: unknown;
+}): Pick<FirmwareUpdatePlanArtifact, 'expectedSize' | 'expectedSha256'> => {
+  const sha256Value =
+    typeof value === 'string' && /^[a-f0-9]{64}$/iu.test(value) ? value.toLowerCase() : undefined;
+  return {
+    ...(Number.isSafeInteger(size) && (size as number) > 0 ? { expectedSize: size as number } : {}),
+    ...(sha256Value ? { expectedSha256: sha256Value } : {}),
+  };
+};
+
+const isUpgrade = (release: ReleaseSelection | undefined): boolean =>
+  release?.status === 'required' ||
+  release?.status === 'outdated' ||
+  release?.shouldUpdate === true;
+
+const assertArtifactUrl = (value: unknown, label: string): string => {
+  const raw = asString(value);
+  if (!raw) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `${label} has no downloadable artifact`,
+      { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+    );
+  }
+  const parsed = new URL(raw);
+  if (
+    parsed.protocol !== 'https:' ||
+    parsed.port !== '' ||
+    parsed.username ||
+    parsed.password ||
+    parsed.hash
+  ) {
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `${label} URL is not canonical HTTPS`, {
+      firmwareUpdateCode: 'FirmwarePlanInvalid',
+    });
+  }
+  return raw;
+};
+
+const canonicalizeFirmwareUpdateContract = (value: unknown): unknown => {
+  if (Array.isArray(value)) {
+    return value.map(canonicalizeFirmwareUpdateContract);
+  }
+  if (value && typeof value === 'object') {
+    return Object.keys(value as Record<string, unknown>)
+      .sort()
+      .reduce<Record<string, unknown>>((result, key) => {
+        const item = (value as Record<string, unknown>)[key];
+        if (item !== undefined) {
+          result[key] = canonicalizeFirmwareUpdateContract(item);
+        }
+        return result;
+      }, {});
+  }
+  return value;
+};
+
+export const digestFirmwareUpdateContract = (value: unknown): string =>
+  bytesToHex(
+    sha256(new TextEncoder().encode(JSON.stringify(canonicalizeFirmwareUpdateContract(value))))
+  );
+
+export const digestFirmwareUpdatePlan = (plan: Omit<FirmwareUpdatePlan, 'planDigest'>): string =>
+  digestFirmwareUpdateContract(plan);
+
+const planError = (message: string): never => {
+  throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, message, {
+    firmwareUpdateCode: 'FirmwarePlanInvalid',
+  });
+};
+
+const assertExactKeys = (
+  value: Record<string, unknown>,
+  required: readonly string[],
+  optional: readonly string[] = []
+) => {
+  const allowed = new Set([...required, ...optional]);
+  if (
+    required.some(key => !Object.prototype.hasOwnProperty.call(value, key)) ||
+    Object.keys(value).some(key => !allowed.has(key))
+  ) {
+    planError('Firmware update plan contains an invalid field set');
+  }
+};
+
+const assertBoundedString = (value: unknown, label: string, maxLength = 256): string => {
+  if (typeof value !== 'string' || value.length === 0 || value.length > maxLength) {
+    return planError(`Firmware update plan ${label} is invalid`);
+  }
+  return value;
+};
+
+export const FIRMWARE_UPDATE_PLAN_TARGETS = new Set<FirmwareUpdatePlanTarget>([
+  'firmware',
+  'ble',
+  'bootloader',
+  'resource',
+  'boot',
+  'app_v1',
+  'app_v2',
+  'coprocessor',
+  'se01',
+  'se02',
+  'se03',
+  'se04',
+]);
+
+export const FIRMWARE_UPDATE_PLAN_ROLES = new Set([
+  'firmware',
+  'ble',
+  'bootloader',
+  'resource',
+  'component',
+  'resourceBundle',
+]);
+
+const PLAN_CONTAINERS = new Set(['raw', 'zip']);
+
+export const FIRMWARE_UPDATE_PLAN_EPOCH_KINDS = new Set<FirmwareUpdatePlanEpochKind>([
+  'legacy-update',
+  'resource-sync',
+  'bootloader-install',
+  'bootloader-verify',
+  'component-install',
+  'final-verify',
+]);
+
+const PLAN_PLATFORMS = new Set<FirmwareUpdatePlatform>([
+  'native',
+  'desktop',
+  'ext',
+  'web',
+  'web-embed',
+]);
+
+export const assertFirmwareUpdatePlan = (value: unknown): FirmwareUpdatePlan => {
+  const plan = asRecord(value);
+  if (!plan) {
+    return planError('Firmware update plan must be an object');
+  }
+  assertExactKeys(plan, [
+    'schemaVersion',
+    'planDigest',
+    'executor',
+    'deviceIdentity',
+    'deviceModel',
+    'firmwareType',
+    'platform',
+    'artifacts',
+    'epochs',
+    'targetsToUpdate',
+  ]);
+  if (
+    plan.schemaVersion !== 1 ||
+    typeof plan.planDigest !== 'string' ||
+    !/^[a-f0-9]{64}$/u.test(plan.planDigest) ||
+    (plan.executor !== 'v2' && plan.executor !== 'v3' && plan.executor !== 'v4') ||
+    !PLAN_PLATFORMS.has(plan.platform as FirmwareUpdatePlatform) ||
+    (plan.firmwareType !== EFirmwareType.Universal &&
+      plan.firmwareType !== EFirmwareType.BitcoinOnly)
+  ) {
+    return planError('Firmware update plan header is invalid');
+  }
+  assertBoundedString(plan.deviceIdentity, 'device identity');
+  assertBoundedString(plan.deviceModel, 'device model', 64);
+  if (!Array.isArray(plan.artifacts) || plan.artifacts.length > 128) {
+    return planError('Firmware update plan artifact set is invalid');
+  }
+  const artifactIds = new Set<string>();
+  const artifactTargets = new Set<FirmwareUpdatePlanTarget>();
+  for (const item of plan.artifacts) {
+    const artifact = asRecord(item);
+    if (!artifact) {
+      return planError('Firmware update plan artifact is invalid');
+    }
+    assertExactKeys(
+      artifact,
+      ['artifactId', 'role', 'target', 'url', 'container'],
+      ['logicalName', 'expectedSize', 'expectedSha256', 'targetVersion']
+    );
+    const artifactId = assertBoundedString(artifact.artifactId, 'artifact id', 160);
+    if (artifactIds.has(artifactId)) {
+      return planError('Firmware update plan contains duplicate artifact ids');
+    }
+    artifactIds.add(artifactId);
+    if (
+      !FIRMWARE_UPDATE_PLAN_ROLES.has(artifact.role as string) ||
+      !FIRMWARE_UPDATE_PLAN_TARGETS.has(artifact.target as FirmwareUpdatePlanTarget) ||
+      !PLAN_CONTAINERS.has(artifact.container as string)
+    ) {
+      return planError('Firmware update plan artifact contract is invalid');
+    }
+    artifactTargets.add(artifact.target as FirmwareUpdatePlanTarget);
+    assertArtifactUrl(artifact.url, `Firmware artifact ${artifactId}`);
+    if (artifact.logicalName !== undefined) {
+      assertBoundedString(artifact.logicalName, 'logical name', 256);
+    }
+    if (
+      artifact.expectedSize !== undefined &&
+      (!Number.isSafeInteger(artifact.expectedSize) || (artifact.expectedSize as number) <= 0)
+    ) {
+      return planError('Firmware update plan artifact size is invalid');
+    }
+    if (
+      artifact.expectedSha256 !== undefined &&
+      (typeof artifact.expectedSha256 !== 'string' ||
+        !/^[a-f0-9]{64}$/u.test(artifact.expectedSha256))
+    ) {
+      return planError('Firmware update plan artifact digest is invalid');
+    }
+    if (artifact.targetVersion !== undefined) {
+      assertBoundedString(artifact.targetVersion, 'target version', 64);
+    }
+  }
+  if (!Array.isArray(plan.epochs) || plan.epochs.length > 32) {
+    return planError('Firmware update plan epochs are invalid');
+  }
+  for (const [index, item] of plan.epochs.entries()) {
+    const epoch = asRecord(item);
+    if (!epoch) {
+      return planError('Firmware update plan epoch is invalid');
+    }
+    assertExactKeys(epoch, ['epoch', 'kind', 'artifactIds', 'targets']);
+    if (
+      epoch.epoch !== index ||
+      !FIRMWARE_UPDATE_PLAN_EPOCH_KINDS.has(epoch.kind as FirmwareUpdatePlanEpochKind) ||
+      !Array.isArray(epoch.artifactIds) ||
+      !Array.isArray(epoch.targets) ||
+      epoch.artifactIds.some(
+        artifactId => typeof artifactId !== 'string' || !artifactIds.has(artifactId)
+      ) ||
+      new Set(epoch.artifactIds).size !== epoch.artifactIds.length ||
+      epoch.targets.some(
+        target => !FIRMWARE_UPDATE_PLAN_TARGETS.has(target as FirmwareUpdatePlanTarget)
+      ) ||
+      new Set(epoch.targets).size !== epoch.targets.length
+    ) {
+      return planError('Firmware update plan epoch contract is invalid');
+    }
+  }
+  if (
+    !Array.isArray(plan.targetsToUpdate) ||
+    plan.targetsToUpdate.some(
+      target => !FIRMWARE_UPDATE_PLAN_TARGETS.has(target as FirmwareUpdatePlanTarget)
+    ) ||
+    new Set(plan.targetsToUpdate).size !== plan.targetsToUpdate.length ||
+    plan.targetsToUpdate.length !== artifactTargets.size ||
+    plan.targetsToUpdate.some(target => !artifactTargets.has(target as FirmwareUpdatePlanTarget))
+  ) {
+    return planError('Firmware update plan targets are invalid');
+  }
+  const legacyTargets = new Set<FirmwareUpdatePlanTarget>([
+    'firmware',
+    'ble',
+    'bootloader',
+    'resource',
+  ]);
+  const legacyOnlyTargets = new Set<FirmwareUpdatePlanTarget>(['firmware', 'ble', 'bootloader']);
+  if (
+    ((plan.executor === 'v2' || plan.executor === 'v3') &&
+      plan.targetsToUpdate.some(
+        target => !legacyTargets.has(target as FirmwareUpdatePlanTarget)
+      )) ||
+    (plan.executor === 'v4' &&
+      plan.targetsToUpdate.some(target =>
+        legacyOnlyTargets.has(target as FirmwareUpdatePlanTarget)
+      )) ||
+    (plan.artifacts.length > 0 &&
+      (plan.platform === 'native' || plan.platform === 'desktop') &&
+      plan.deviceIdentity === 'unavailable')
+  ) {
+    return planError('Firmware update plan executor contract is invalid');
+  }
+  const expectedEpochKinds = compileFirmwareUpdateEpochKinds({
+    executor: plan.executor,
+    targets: plan.targetsToUpdate as FirmwareUpdatePlanTarget[],
+  });
+  if (
+    plan.epochs.length !== expectedEpochKinds.length ||
+    plan.epochs.some((epoch, index) => epoch.kind !== expectedEpochKinds[index])
+  ) {
+    return planError('Firmware update plan epoch order is invalid');
+  }
+  const { planDigest, ...withoutDigest } = plan as unknown as FirmwareUpdatePlan;
+  if (digestFirmwareUpdatePlan(withoutDigest) !== planDigest) {
+    return planError('Firmware update plan digest is invalid');
+  }
+  return plan as unknown as FirmwareUpdatePlan;
+};
+
+const selectResourceUrl = ({
+  release,
+  features,
+  platform,
+}: {
+  release: ReleaseRecord;
+  features: Features;
+  platform: FirmwareUpdatePlatform;
+}): string | undefined => {
+  const resource = asString(release.resource);
+  const fullResource = asString(release.fullResource);
+  const range = release.fullResourceRange;
+  const currentVersion = getDeviceFirmwareVersion(features).join('.');
+  const targetVersion = asVersion(release.version);
+  if (
+    platform === 'desktop' &&
+    fullResource &&
+    targetVersion &&
+    Array.isArray(range) &&
+    range.length === 2 &&
+    typeof range[0] === 'string' &&
+    typeof range[1] === 'string' &&
+    semver.valid(currentVersion) &&
+    semver.valid(targetVersion) &&
+    semver.valid(range[0]) &&
+    semver.valid(range[1]) &&
+    semver.lt(currentVersion, range[0]) &&
+    semver.gte(targetVersion, range[1])
+  ) {
+    return fullResource;
+  }
+  return resource;
+};
+
+const getExecutor = (features: Features): FirmwareUpdatePlan['executor'] => {
+  const deviceType = getDeviceType(features);
+  if (deviceType === EDeviceType.Pro2) {
+    return 'v4';
+  }
+  if (
+    deviceType === EDeviceType.Pro &&
+    semver.gte(getDeviceBootloaderVersion(features).join('.'), '2.8.0')
+  ) {
+    return 'v3';
+  }
+  return 'v2';
+};
+
+export const compileFirmwareUpdateEpochKinds = ({
+  executor,
+  targets,
+}: {
+  executor: FirmwareUpdatePlan['executor'];
+  targets: readonly FirmwareUpdatePlanTarget[];
+}): FirmwareUpdatePlanEpochKind[] => {
+  if (executor !== 'v4') {
+    return ['legacy-update', 'final-verify'];
+  }
+  const targetSet = new Set(targets);
+  const kinds: FirmwareUpdatePlanEpochKind[] = [];
+  if (targetSet.has('resource')) kinds.push('resource-sync');
+  if (targetSet.has('boot')) {
+    kinds.push('bootloader-install', 'bootloader-verify');
+  }
+  if (targets.some(target => target !== 'resource' && target !== 'boot')) {
+    kinds.push('component-install');
+  }
+  kinds.push('final-verify');
+  return kinds;
+};
+
+const compileFirmwareUpdateEpochs = ({
+  executor,
+  artifacts,
+}: {
+  executor: FirmwareUpdatePlan['executor'];
+  artifacts: readonly FirmwareUpdatePlanArtifact[];
+}): FirmwareUpdatePlanEpoch[] => {
+  const targets = [...new Set(artifacts.map(artifact => artifact.target))];
+  return compileFirmwareUpdateEpochKinds({ executor, targets }).map((kind, epoch) => {
+    let epochArtifacts: readonly FirmwareUpdatePlanArtifact[] = [];
+    if (kind === 'legacy-update') {
+      epochArtifacts = artifacts;
+    } else if (kind === 'resource-sync') {
+      epochArtifacts = artifacts.filter(artifact => artifact.target === 'resource');
+    } else if (kind === 'bootloader-install') {
+      epochArtifacts = artifacts.filter(artifact => artifact.target === 'boot');
+    } else if (kind === 'component-install') {
+      epochArtifacts = artifacts.filter(
+        artifact => artifact.target !== 'resource' && artifact.target !== 'boot'
+      );
+    }
+    let epochTargets = [...new Set(epochArtifacts.map(artifact => artifact.target))];
+    if (kind === 'final-verify') {
+      epochTargets = targets;
+    } else if (kind === 'bootloader-verify') {
+      epochTargets = ['boot'];
+    }
+    return {
+      epoch,
+      kind,
+      artifactIds: epochArtifacts.map(artifact => artifact.artifactId),
+      targets: epochTargets,
+    };
+  });
+};
+
+const buildProtocolV2Artifacts = (
+  release: ReleaseRecord
+): {
+  artifacts: FirmwareUpdatePlanArtifact[];
+  targets: FirmwareUpdatePlanTarget[];
+} => {
+  const components = asRecord(release.components);
+  if (!components) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Protocol V2 release has no component set',
+      { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+    );
+  }
+  const installOrder = Array.isArray(release.installOrder)
+    ? release.installOrder.filter((key): key is string => typeof key === 'string')
+    : [];
+  const componentKeys = [
+    ...installOrder,
+    ...Object.keys(components).filter(key => !installOrder.includes(key)),
+  ];
+  const artifacts: FirmwareUpdatePlanArtifact[] = [];
+  const targets: FirmwareUpdatePlanTarget[] = [];
+  const componentTargets = new Set<FirmwareUpdatePlanTarget>();
+  for (const key of componentKeys) {
+    const component = asRecord(components[key]);
+    const targetName = asString(component?.target)?.toUpperCase();
+    if (targetName === 'ROMLOADER') {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Protocol V2 ROMLOADER requires its dedicated loader flow',
+        { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+      );
+    }
+    const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
+    if (!component || !target) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 component ${key} has an unsupported target`,
+        { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+      );
+    }
+    if (componentTargets.has(target)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Protocol V2 component ${key} duplicates target ${target}`,
+        { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+      );
+    }
+    componentTargets.add(target);
+    artifacts.push({
+      artifactId: `component:${target}`,
+      role: 'component',
+      target,
+      url: assertArtifactUrl(component.url, `Protocol V2 component ${key}`),
+      container: 'raw',
+      logicalName: key,
+      ...asIntegrity({
+        size: component.expectedSize,
+        sha256: component.fingerprint,
+      }),
+      ...(asVersion(component.version) ? { targetVersion: asVersion(component.version) } : {}),
+    });
+    targets.push(target);
+  }
+
+  const bundles = 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)] };
+};
+
+export const buildFirmwareUpdatePlan = ({
+  features,
+  firmwareType,
+  platform,
+  firmware,
+  ble,
+  bootloader,
+}: {
+  features: Features;
+  firmwareType: EFirmwareType;
+  platform: FirmwareUpdatePlatform;
+  firmware: ReleaseSelection;
+  ble: ReleaseSelection;
+  bootloader?: ReleaseSelection;
+}): FirmwareUpdatePlan => {
+  const executor = getExecutor(features);
+  let artifacts: FirmwareUpdatePlanArtifact[] = [];
+  let targetsToUpdate: FirmwareUpdatePlanTarget[] = [];
+  const firmwareRelease = asRelease(firmware);
+
+  if (executor === 'v4' && isUpgrade(firmware)) {
+    const protocolV2 = buildProtocolV2Artifacts(firmwareRelease ?? {});
+    artifacts = protocolV2.artifacts;
+    targetsToUpdate = protocolV2.targets;
+  } else {
+    if (isUpgrade(bootloader)) {
+      artifacts.push({
+        artifactId: 'bootloader',
+        role: 'bootloader',
+        target: 'bootloader',
+        url: assertArtifactUrl(asRelease(bootloader)?.bootloaderResource, 'Bootloader release'),
+        container: 'raw',
+        ...asIntegrity({
+          size: asRelease(bootloader)?.bootloaderExpectedSize,
+          sha256: asRelease(bootloader)?.bootloaderFingerprint,
+        }),
+        ...(asVersion(asRelease(bootloader)?.bootloaderVersion)
+          ? {
+              targetVersion: asVersion(asRelease(bootloader)?.bootloaderVersion),
+            }
+          : {}),
+      });
+    }
+    if (isUpgrade(firmware)) {
+      if (!firmwareRelease) {
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Firmware release is invalid', {
+          firmwareUpdateCode: 'FirmwarePlanInvalid',
+        });
+      }
+      artifacts.push({
+        artifactId: 'firmware',
+        role: 'firmware',
+        target: 'firmware',
+        url: assertArtifactUrl(firmwareRelease.url, 'Firmware release'),
+        container: 'raw',
+        ...asIntegrity({
+          size: firmwareRelease.expectedSize,
+          sha256: firmwareRelease.fingerprint,
+        }),
+        ...(asVersion(firmwareRelease.version)
+          ? { targetVersion: asVersion(firmwareRelease.version) }
+          : {}),
+      });
+      const resourceUrl = selectResourceUrl({
+        release: firmwareRelease,
+        features,
+        platform,
+      });
+      if (resourceUrl) {
+        artifacts.push({
+          artifactId: 'resource',
+          role: 'resource',
+          target: 'resource',
+          url: assertArtifactUrl(resourceUrl, 'Firmware resource release'),
+          container: 'zip',
+          ...asIntegrity({
+            size:
+              resourceUrl === asString(firmwareRelease.fullResource)
+                ? firmwareRelease.fullResourceExpectedSize
+                : firmwareRelease.resourceExpectedSize,
+            sha256:
+              resourceUrl === asString(firmwareRelease.fullResource)
+                ? firmwareRelease.fullResourceFingerprint
+                : firmwareRelease.resourceFingerprint,
+          }),
+        });
+      }
+    }
+    if (isUpgrade(ble)) {
+      const bleRelease = asRelease(ble);
+      artifacts.push({
+        artifactId: 'ble',
+        role: 'ble',
+        target: 'ble',
+        url: assertArtifactUrl(bleRelease?.webUpdate ?? bleRelease?.url, 'BLE release'),
+        container: 'raw',
+        ...asIntegrity({
+          size: bleRelease?.expectedSize,
+          sha256: bleRelease?.fingerprintWeb ?? bleRelease?.fingerprint,
+        }),
+        ...(asVersion(bleRelease?.version)
+          ? { targetVersion: asVersion(bleRelease?.version) }
+          : {}),
+      });
+    }
+    targetsToUpdate = [...new Set(artifacts.map(artifact => artifact.target))];
+  }
+
+  const deviceIdentity = getDeviceUUID(features);
+  if (
+    artifacts.length > 0 &&
+    (platform === 'native' || platform === 'desktop') &&
+    !deviceIdentity
+  ) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'Prepared firmware update requires a stable device identity',
+      { firmwareUpdateCode: 'FirmwarePlanInvalid' }
+    );
+  }
+  const planWithoutDigest: Omit<FirmwareUpdatePlan, 'planDigest'> = {
+    schemaVersion: 1,
+    executor,
+    deviceIdentity: deviceIdentity || 'unavailable',
+    deviceModel: String(getDeviceType(features)),
+    firmwareType,
+    platform,
+    artifacts,
+    epochs: compileFirmwareUpdateEpochs({ executor, artifacts }),
+    targetsToUpdate,
+  };
+  return {
+    ...planWithoutDigest,
+    planDigest: digestFirmwareUpdatePlan(planWithoutDigest),
+  };
+};