@onekeyfe/hd-core 1.2.0-alpha.79 → 1.2.0-alpha.80

package/src/api/CheckFirmwareRelease.ts

@@ -1,10 +1,23 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 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,
@@ -15,16 +28,37 @@ export default class CheckFirmwareRelease extends BaseMethod {
     this.skipForceUpdateCheck = true;
   }
 
-  run() {
+  async run() {
     const payload = this.payload as CheckFirmwareReleaseParams;
 
+    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 });
+    }
+
     if (this.device.features) {
       const deviceFirmwareType = this.device.getCurrentFirmwareType();
       const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
       const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
-      return Promise.resolve(releaseInfo);
+      return releaseInfo;
     }
-    return Promise.resolve(null);
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      'checkFirmwareRelease requires initialized device features'
+    );
   }
 }

package/src/api/FirmwareUpdateV4.ts

@@ -146,6 +146,9 @@ type ProtocolV2ResourceBundleBinary = {
   name: string;
   binary: ArrayBuffer;
   devicePath: string;
+  version?: IVersionArray;
+  payloadHash?: string;
+  headerHash?: string;
 };
 
 type ProtocolV2RemoteComponentBinary = ProtocolV2RemoteComponentTarget & {
@@ -668,10 +671,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       return this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
     }
     const hasExplicitResourceFiles = !!this.params.resourceFiles?.length;
-    const wantsStableResources = !!this.params.targetsToUpdate?.includes('resource');
-    const wantsBootResources = !!this.params.targetsToUpdate?.includes('boot_resources');
-    const needsPreparedResources =
-      !hasExplicitResourceFiles && (wantsStableResources || wantsBootResources);
+    const wantsResources = !!this.params.targetsToUpdate?.includes('resource');
+    const needsPreparedResources = !hasExplicitResourceFiles && wantsResources;
 
     let fwBinaryMap: ProtocolV2TargetBinary[] = [];
     let bootloaderBinary: ArrayBuffer | null = null;
@@ -897,7 +898,19 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     try {
       this.postTipMessage(FirmwareUpdateTipMessage.StartDownloadFirmware);
       const installSources = await this.prepareProtocolV2InstallSources(firmwareType, features);
-      const resourceSources = await this.prepareProtocolV2ResourceSources(firmwareType, features);
+      const explicitResourceBundles = this.prepareExplicitProtocolV2ResourceFiles();
+      const resourceSources = explicitResourceBundles?.length
+        ? await Promise.all(
+            explicitResourceBundles.map(async bundle => ({
+              name: bundle.name,
+              source: await this.openProtocolV2MemorySource(bundle.binary),
+              devicePath: bundle.devicePath,
+              version: bundle.version,
+              payloadHash: bundle.payloadHash,
+              headerHash: bundle.headerHash,
+            }))
+          )
+        : await this.prepareProtocolV2ResourceSources(firmwareType, features);
       if (installSources.length === 0 && resourceSources.length === 0) {
         throw ERRORS.TypedError(
           HardwareErrorCode.FirmwareUpdateDownloadFailed,
@@ -1272,10 +1285,18 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       ) {
         throw new Error(`resourceFiles[${index}] SHA-256 mismatch`);
       }
+      const header = parseProtocolV2OkppHeader(toProtocolV2Bytes(file.binary));
       return {
         name: devicePath.split('/').pop() ?? devicePath,
         binary: file.binary,
         devicePath,
+        ...(header
+          ? {
+              version: header.version,
+              payloadHash: header.payloadHash,
+              headerHash: header.headerHash,
+            }
+          : {}),
       };
     });
     if (new Set(prepared.map(file => file.devicePath)).size !== prepared.length) {
@@ -1335,7 +1356,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return parseProtocolV2OkppHeader(headerBytes);
   }
 
-  /** Compare a prepared okpkg header when its manifest supplies version or hash metadata. */
+  /** Compare the downloaded and installed okpkg headers before transferring a resource. */
   private async isProtocolV2ResourceBundleUpToDate(
     bundle: Pick<
       ProtocolV2ResourceBundleSource,
@@ -1343,7 +1364,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     >
   ): Promise<boolean> {
     if (this.params?.forcedUpdateRes) return false;
-    if (!bundle.version && !bundle.payloadHash) return false;
+    if (!bundle.payloadHash || !bundle.headerHash) return false;
 
     try {
       const header = await this.readProtocolV2DeviceFileHeader(bundle.devicePath);
@@ -1353,14 +1374,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         const cmp = compareProtocolV2Versions(header.version, bundle.version);
         if (cmp === undefined || cmp !== 0) return false;
       }
-      if (bundle.payloadHash) {
-        const expected = normalizeProtocolV2Hex(bundle.payloadHash);
-        if (expected && header.payloadHash !== expected) return false;
-      }
-      if (bundle.headerHash) {
-        const expected = normalizeProtocolV2Hex(bundle.headerHash);
-        if (expected && header.headerHash !== expected) return false;
-      }
+      const expectedPayloadHash = normalizeProtocolV2Hex(bundle.payloadHash);
+      const expectedHeaderHash = normalizeProtocolV2Hex(bundle.headerHash);
+      if (!expectedPayloadHash || header.payloadHash !== expectedPayloadHash) return false;
+      if (!expectedHeaderHash || header.headerHash !== expectedHeaderHash) return false;
       return true;
     } catch (error) {
       Log.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
@@ -1631,6 +1648,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
           name: bundle.name,
           source: await this.openProtocolV2MemorySource(bundle.binary),
           devicePath: bundle.devicePath,
+          version: bundle.version,
+          payloadHash: bundle.payloadHash,
+          headerHash: bundle.headerHash,
         }))
       );
       return await this.executeProtocolV2Phases({

package/src/api/firmware/protocolV2Release.ts

@@ -0,0 +1,166 @@
+import { EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { DataManager } from '../../data-manager';
+
+import type { EDeviceType } from '@onekeyfe/hd-shared';
+import type { Device } from '../../device/Device';
+import type {
+  DeviceState,
+  Features,
+  IFirmwareReleaseInfo,
+  IProtocolV2FirmwareComponentTarget,
+} from '../../types';
+import type {
+  FirmwareReleaseCheckResult,
+  ProtocolV2ComponentReleaseInfo,
+  ProtocolV2FirmwareReleaseStatus,
+} from '../../types/api/checkAllFirmwareRelease';
+import type { ProtocolV2FirmwareReleasePlan } from '../CheckAllFirmwareRelease';
+
+export const PROTOCOL_V2_MAIN_FIRMWARE_TARGETS: readonly IProtocolV2FirmwareComponentTarget[] = [
+  'APPLICATION_P1',
+  'APPLICATION_P2',
+  'SE01',
+  'SE02',
+  'SE03',
+  'SE04',
+];
+
+export const PROTOCOL_V2_BLE_TARGETS: readonly IProtocolV2FirmwareComponentTarget[] = [
+  'COPROCESSOR',
+];
+
+export const PROTOCOL_V2_BOOTLOADER_TARGETS: readonly IProtocolV2FirmwareComponentTarget[] = [
+  'BOOTLOADER',
+];
+
+export type ProtocolV2FirmwareReleaseContext = {
+  state: Omit<DeviceState, 'identity'> & {
+    identity: Omit<DeviceState['identity'], 'deviceType'> & {
+      deviceType: EDeviceType.Pro2 | EDeviceType.Neo;
+    };
+  };
+  features: Features;
+  firmwareType: EFirmwareType;
+  release: IFirmwareReleaseInfo | undefined;
+};
+
+export async function loadProtocolV2FirmwareReleaseContext({
+  device,
+  firmwareType: firmwareTypeParam,
+  checkFirmwareHash = false,
+  methodName,
+}: {
+  device: Device;
+  firmwareType?: EFirmwareType;
+  checkFirmwareHash?: boolean;
+  methodName: string;
+}): Promise<ProtocolV2FirmwareReleaseContext> {
+  const state = await device.getDeviceState({
+    refreshSections: checkFirmwareHash
+      ? ['identity', 'versions', 'verification']
+      : ['identity', 'versions'],
+  });
+  if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.DeviceNotSupportMethod,
+      `${methodName} requires a Pro2 or Neo device for Protocol V2`
+    );
+  }
+
+  const { features } = device;
+  if (!features) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `${methodName} requires initialized device features`
+    );
+  }
+
+  const firmwareType = firmwareTypeParam ?? state.identity.firmwareType ?? EFirmwareType.Universal;
+  return {
+    state: state as ProtocolV2FirmwareReleaseContext['state'],
+    features,
+    firmwareType,
+    release: DataManager.getFirmwareLatestRelease(features, firmwareType),
+  };
+}
+
+export function summarizeProtocolV2FirmwareRelease(
+  plan: ProtocolV2FirmwareReleasePlan,
+  componentTargets: readonly IProtocolV2FirmwareComponentTarget[]
+): ProtocolV2FirmwareReleasePlan {
+  const targetSet = new Set<IProtocolV2FirmwareComponentTarget>(componentTargets);
+  const components = plan.components.filter(component => targetSet.has(component.componentTarget));
+  const targetsToUpdate = Array.from(
+    new Set(
+      components.flatMap(component =>
+        component.status === 'outdated' && component.updateTarget ? [component.updateTarget] : []
+      )
+    )
+  );
+  const hasUpgrade = targetsToUpdate.length > 0;
+  const required = !!plan.release?.required && hasUpgrade;
+  let status: ProtocolV2FirmwareReleaseStatus = 'valid';
+  if (!plan.release || components.length === 0) {
+    status = 'unavailable';
+  } else if (required) {
+    status = 'required';
+  } else if (hasUpgrade) {
+    status = 'outdated';
+  } else if (components.some(component => component.status === 'unknown')) {
+    status = 'unknown';
+  } else if (components.every(component => component.status === 'unsupported')) {
+    status = 'unavailable';
+  }
+
+  return {
+    ...plan,
+    status,
+    hasUpgrade,
+    required,
+    components,
+    targetsToUpdate,
+  };
+}
+
+export function toProtocolV2FirmwareReleaseInfo({
+  plan,
+  state,
+  release,
+}: {
+  plan: ProtocolV2FirmwareReleasePlan;
+  state: DeviceState;
+  release: FirmwareReleaseCheckResult['release'];
+}): FirmwareReleaseCheckResult {
+  return {
+    shouldUpdate: plan.hasUpgrade,
+    status: plan.status === 'unavailable' ? 'unknown' : plan.status,
+    changelog: plan.release ? [plan.release.changelog] : [],
+    release,
+    bootloaderMode: state.status.mode === 'bootloader' || state.status.mode === 'romloader',
+  };
+}
+
+export function getProtocolV2ComponentReleaseInfo(
+  plan: ProtocolV2FirmwareReleasePlan,
+  componentTarget: IProtocolV2FirmwareComponentTarget
+): ProtocolV2ComponentReleaseInfo | undefined {
+  const componentRelease = plan.components.find(
+    component => component.componentTarget === componentTarget
+  );
+  if (!componentRelease || !plan.release) {
+    return undefined;
+  }
+  const component = plan.release.components?.[componentRelease.configKey];
+  if (!component) {
+    return undefined;
+  }
+  return {
+    ...component,
+    protocol: 'V2',
+    configKey: componentRelease.configKey,
+    componentTarget,
+    required: plan.release.required,
+    changelog: plan.release.changelog,
+  };
+}

package/src/index.ts

@@ -24,7 +24,6 @@ export { getMethodSupportedProtocols } from './api/utils';
 export {
   parseProtocolV2ResourceManifest,
   prepareProtocolV2ResourceFiles,
-  resolveProtocolV2ResourceManifestFileUrl,
   selectProtocolV2ResourceManifestFiles,
 } from './protocols/protocol-v2/resources';
 export {

package/src/protocols/protocol-v2/resources.ts

@@ -37,12 +37,26 @@ export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources |
   if (!source || typeof source !== 'object') {
     throw new Error('Invalid Pro2 resources config: source is required');
   }
-  const { manifestUrl } = source as { manifestUrl?: unknown };
-  if (typeof manifestUrl !== 'string' || !manifestUrl.startsWith('https://')) {
-    throw new Error('Invalid Pro2 resources config: source.manifestUrl must use HTTPS');
+  const { archiveUrl, archiveSha256, archiveSize } = source as {
+    archiveUrl?: unknown;
+    archiveSha256?: unknown;
+    archiveSize?: unknown;
+  };
+  if (typeof archiveUrl !== 'string' || !archiveUrl.startsWith('https://')) {
+    throw new Error('Invalid Pro2 resources config: source.archiveUrl must use HTTPS');
+  }
+  if (typeof archiveSha256 !== 'string' || !/^[0-9a-fA-F]{64}$/.test(archiveSha256)) {
+    throw new Error('Invalid Pro2 resources config: source.archiveSha256 must be a SHA-256 digest');
+  }
+  if (!Number.isSafeInteger(archiveSize) || (archiveSize as number) <= 0) {
+    throw new Error('Invalid Pro2 resources config: source.archiveSize must be a positive integer');
   }
   return {
-    source: { manifestUrl },
+    source: {
+      archiveUrl,
+      archiveSha256: archiveSha256.toLowerCase(),
+      archiveSize: archiveSize as number,
+    },
   };
 }
 
@@ -194,27 +208,7 @@ export function selectProtocolV2ResourceManifestFiles({
   manifest: IProtocolV2ResourceManifest;
   targetsToUpdate: readonly FirmwareUpdateV4Target[];
 }): IProtocolV2ResourceManifestFile[] {
-  const targets = new Set(targetsToUpdate);
-  return manifest.files.filter(file => {
-    if (file.device_path.startsWith('vol0:/bundles/')) {
-      return targets.has('resource');
-    }
-    return targets.has('boot_resources');
-  });
-}
-
-export function resolveProtocolV2ResourceManifestFileUrl({
-  manifestUrl,
-  archivePath,
-}: {
-  manifestUrl: string;
-  archivePath: string;
-}): string {
-  const url = new URL(assertManifestRelativePath(archivePath, 'archive_path'), manifestUrl);
-  if (url.protocol !== 'https:') {
-    throw new Error('Invalid Pro2 resource manifest file URL');
-  }
-  return url.toString();
+  return targetsToUpdate.includes('resource') ? [...manifest.files] : [];
 }
 
 export function prepareProtocolV2ResourceFiles({

package/src/types/api/checkAllFirmwareRelease.ts

@@ -1,30 +1,43 @@
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
-import type {
-  DeviceStateVersions,
-  Features,
-  IDeviceBLEFirmwareStatus,
-  IDeviceFirmwareStatus,
-} from '../device';
+import type { DeviceStateVersions, Features, IDeviceFirmwareStatus } from '../device';
 import type {
   IBLEFirmwareReleaseInfo,
   IFirmwareReleaseInfo,
+  IProtocolV2FirmwareComponent,
   IProtocolV2FirmwareComponentTarget,
+  IProtocolV2ResourceSource,
 } from '../settings';
 import type { FirmwareUpdateV4Target } from './firmwareUpdate';
 import type { FirmwareUpdatePlan, FirmwareUpdatePlanForceTarget } from './firmwareUpdatePlan';
 
-export type FirmwareRelease = {
+export type ProtocolV2ComponentReleaseInfo = IProtocolV2FirmwareComponent & {
+  protocol: 'V2';
+  configKey: string;
+  componentTarget: IProtocolV2FirmwareComponentTarget;
+  required: boolean;
+  changelog: IFirmwareReleaseInfo['changelog'];
+};
+
+export type FirmwareReleaseCheckResult = {
   shouldUpdate?: boolean;
   status: IDeviceFirmwareStatus;
   changelog?: {
     'zh-CN': string;
     'en-US': string;
   }[];
-  release: IDeviceBLEFirmwareStatus | IBLEFirmwareReleaseInfo | IFirmwareReleaseInfo;
+  release:
+    | IBLEFirmwareReleaseInfo
+    | IFirmwareReleaseInfo
+    | ProtocolV2ComponentReleaseInfo
+    | undefined;
   bootloaderMode?: boolean;
 };
 
+export type BridgeReleaseCheckResult = Omit<FirmwareReleaseCheckResult, 'release'> & {
+  release: string | undefined;
+};
+
 export type ProtocolV2FirmwareComponentReleaseStatus =
   | 'valid'
   | 'outdated'
@@ -49,10 +62,10 @@ export type ProtocolV2FirmwareComponentRelease = {
 };
 
 export type AllFirmwareRelease = {
-  firmware: FirmwareRelease;
-  ble: FirmwareRelease;
-  bootloader?: FirmwareRelease;
-  bridge?: FirmwareRelease;
+  firmware: FirmwareReleaseCheckResult;
+  ble: FirmwareReleaseCheckResult;
+  bootloader?: FirmwareReleaseCheckResult;
+  bridge?: BridgeReleaseCheckResult;
   features?: Features;
   protocol?: 'V1' | 'V2';
   deviceType?: 'pro2' | 'neo';
@@ -61,7 +74,8 @@ export type AllFirmwareRelease = {
   hasUpgrade?: boolean;
   required?: boolean;
   resourceStatus?: 'valid' | 'outdated' | 'unknown';
-  resourceManifestUrl?: string;
+  resourceArchive?: IProtocolV2ResourceSource;
+  resourcePreparationRequired?: boolean;
   currentVersions?: DeviceStateVersions;
   components?: ProtocolV2FirmwareComponentRelease[];
   targetsToUpdate?: FirmwareUpdateV4Target[];

package/src/types/api/checkBLEFirmwareRelease.ts

@@ -1,15 +1,6 @@
-import type { IBLEFirmwareReleaseInfo } from '../settings';
 import type { Response } from '../params';
-import type { IDeviceBLEFirmwareStatus } from '../device';
+import type { FirmwareReleaseCheckResult } from './checkAllFirmwareRelease';
 
-type BleFirmwareRelease = {
-  status: IDeviceBLEFirmwareStatus;
-  changelog: {
-    'zh-CN': string;
-    'en-US': string;
-  }[];
-  release: IBLEFirmwareReleaseInfo;
-  bootloaderMode: boolean;
-};
-
-export declare function checkBLEFirmwareRelease(connectId?: string): Response<BleFirmwareRelease>;
+export declare function checkBLEFirmwareRelease(
+  connectId?: string
+): Response<FirmwareReleaseCheckResult>;

package/src/types/api/checkBootloaderRelease.ts

@@ -1,12 +1,8 @@
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
+import type { FirmwareReleaseCheckResult } from './checkAllFirmwareRelease';
 
-export type CheckBootloaderReleaseResponse = {
-  shouldUpdate: boolean;
-  status: 'outdated' | 'valid';
-  release: string | undefined;
-  bootloaderMode: boolean;
-} | null;
+export type CheckBootloaderReleaseResponse = FirmwareReleaseCheckResult;
 
 export type CheckBootloaderReleaseParams = {
   willUpdateFirmwareVersion?: string;

package/src/types/api/checkFirmwareRelease.ts

@@ -1,17 +1,6 @@
-import type { IFirmwareReleaseInfo } from '../settings';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Response } from '../params';
-import type { IDeviceFirmwareStatus } from '../device';
-
-type FirmwareRelease = {
-  status: IDeviceFirmwareStatus;
-  changelog: {
-    'en-US': string;
-    'zh-CN': string;
-  }[];
-  release: IFirmwareReleaseInfo;
-  bootloaderMode: boolean;
-};
+import type { FirmwareReleaseCheckResult } from './checkAllFirmwareRelease';
 
 export type CheckFirmwareReleaseParams = {
   firmwareType?: EFirmwareType;
@@ -20,4 +9,4 @@ export type CheckFirmwareReleaseParams = {
 export declare function checkFirmwareRelease(
   connectId?: string,
   params?: CheckFirmwareReleaseParams
-): Response<FirmwareRelease>;
+): Response<FirmwareReleaseCheckResult>;

package/src/types/api/checkFirmwareTypeAvailable.ts

@@ -1,6 +1,6 @@
 import type { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Response } from '../params';
-import type { FirmwareRelease } from './checkAllFirmwareRelease';
+import type { FirmwareReleaseCheckResult } from './checkAllFirmwareRelease';
 
 export type CheckFirmwareTypeAvailableParams = {
   deviceType: EDeviceType;
@@ -9,4 +9,4 @@ export type CheckFirmwareTypeAvailableParams = {
 
 export declare function checkFirmwareTypeAvailable(
   params: CheckFirmwareTypeAvailableParams
-): Response<FirmwareRelease | undefined>;
+): Response<FirmwareReleaseCheckResult | undefined>;

package/src/types/api/export.ts

@@ -54,7 +54,12 @@ export type {
   ProtocolV2ResourceManifestBinary,
 } from './protocolV2ResourceManifest';
 export type { FirmwareUpdateCapabilities } from './firmwareUpdateCapabilities';
-export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
+export type {
+  AllFirmwareRelease,
+  BridgeReleaseCheckResult,
+  FirmwareReleaseCheckResult,
+  ProtocolV2ComponentReleaseInfo,
+} from './checkAllFirmwareRelease';
 export type {
   ProtocolV2FirmwareComponentRelease,
   ProtocolV2FirmwareComponentReleaseStatus,

package/src/types/api/firmwareUpdate.ts

@@ -118,7 +118,6 @@ export interface FirmwareUpdateV3Params {
  */
 export type FirmwareUpdateV4Target =
   | 'boot'
-  | 'boot_resources'
   | 'app_v1'
   | 'app_v2'
   | 'coprocessor'
@@ -156,8 +155,8 @@ export interface FirmwareUpdateV4Params {
   forcedUpdateRes?: boolean;
   /**
    * Arbitrary Protocol V2 resource files written directly with FilesystemFileWrite.
-   * Use this for manifest-driven boot resources and other non-RESC files.
-   * When provided, these files are authoritative for resource and boot_resources targets.
+   * Use this for every file selected from the manifest-driven resource archive.
+   * When provided, these files are authoritative for the resource target.
    */
   resourceFiles?: Array<{
     binary: ArrayBuffer;

package/src/types/settings.ts

@@ -65,7 +65,9 @@ export type IProtocolV2FirmwareComponent = {
 };
 
 export type IProtocolV2ResourceSource = {
-  manifestUrl: string;
+  archiveUrl: string;
+  archiveSha256: string;
+  archiveSize: number;
 };
 
 export type IProtocolV2Resources = {