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

package/__tests__/check-all-firmware-release-protocol-v2.test.ts

@@ -5,6 +5,7 @@ import CheckAllFirmwareRelease, {
 } from '../src/api/CheckAllFirmwareRelease';
 import { DataManager } from '../src/data-manager';
 import { createCoreApi } from '../src/inject';
+import { PROTOCOL_V2_RESOURCE_DEVICE_PATHS } from '../src/protocols/protocol-v2/resources';
 
 import type { CoreApi } from '../src/types/api';
 import type { DeviceStateVersions, IFirmwareReleaseInfo } from '../src/types';
@@ -25,11 +26,6 @@ const currentVersions: DeviceStateVersions = {
   se04: '1.0.0',
 };
 
-const validComponentIntegrity = {
-  expectedSize: 1024,
-  fingerprint: '1'.repeat(64),
-};
-
 const release: IFirmwareReleaseInfo = {
   required: true,
   version: [2, 0, 0],
@@ -45,25 +41,21 @@ const release: IFirmwareReleaseInfo = {
       target: 'BOOTLOADER',
       url: 'https://example.com/bootloader.bin',
       version: [1, 1, 0],
-      ...validComponentIntegrity,
     },
     applicationP1: {
       target: 'APPLICATION_P1',
       url: 'https://example.com/application-p1.bin',
       version: [2, 0, 0],
-      ...validComponentIntegrity,
     },
     se02: {
       target: 'SE02',
       url: 'https://example.com/se02.bin',
       version: [2, 0, 0],
-      ...validComponentIntegrity,
     },
     se03: {
       target: 'SE03',
       url: 'https://example.com/se03.bin',
       version: [1, 0, 0],
-      ...validComponentIntegrity,
     },
     romloader: {
       target: 'ROMLOADER',
@@ -71,12 +63,77 @@ const release: IFirmwareReleaseInfo = {
       version: [2, 0, 0],
     },
   },
+  resourceBundles: [
+    {
+      name: 'images',
+      url: 'https://example.com/images.okpkg',
+      devicePath: 'vol0:/bundles/images/images.okpkg',
+      version: [1, 0, 0],
+    },
+  ],
 };
 
-const resourceSource = {
-  archiveUrl: 'https://example.com/pro2-resource/pro2-resource.zip',
-  archiveSha256: 'a'.repeat(64),
-  archiveSize: 16_815_479,
+const stableResources = ['images', 'animation', 'wallpaper', 'translations', 'roobert', 'noto'].map(
+  (type, index) => ({
+    type,
+    url: `https://example.com/${type}.okpkg`,
+    size: 0x52a0 + index + 1,
+    fileHash: 'a'.repeat(64),
+    headerHash: index.toString(16).padStart(128, '0'),
+  })
+);
+
+const createFilesystemTypedCall = (missingAll = false) => {
+  const resourceByPath = new Map(
+    stableResources.map(resource => [
+      PROTOCOL_V2_RESOURCE_DEVICE_PATHS[
+        resource.type as keyof typeof PROTOCOL_V2_RESOURCE_DEVICE_PATHS
+      ],
+      resource,
+    ])
+  );
+  return jest.fn((requestType: string, _responseType: string, payload: Record<string, any>) => {
+    if (requestType === 'ResourceInventoryGet') {
+      throw new Error('ResourceInventoryGet is unavailable on released firmware');
+    }
+    if (requestType === 'FilesystemPathInfoQuery') {
+      const resource = resourceByPath.get(payload.path);
+      return {
+        message: {
+          exist: Boolean(resource) && !missingAll,
+          directory: false,
+          size: missingAll ? 0 : resource?.size,
+        },
+      };
+    }
+    if (requestType === 'FilesystemFileRead') {
+      const resource = resourceByPath.get(payload.file.path);
+      if (!resource || missingAll) throw new Error('missing resource');
+      const header = new Uint8Array(0x52a0);
+      const view = new DataView(header.buffer);
+      'OKPP'.split('').forEach((char, index) => {
+        header[index] = char.charCodeAt(0);
+      });
+      'RESC'.split('').forEach((char, index) => {
+        header[0x08 + index] = char.charCodeAt(0);
+      });
+      view.setUint32(0x0c, header.byteLength, true);
+      for (let index = 0; index < resource.headerHash.length / 2; index++) {
+        header[0x240 + index] = Number.parseInt(
+          resource.headerHash.slice(index * 2, index * 2 + 2),
+          16
+        );
+      }
+      const offset = Number(payload.file.offset);
+      const chunkLength = Number(payload.chunk_len);
+      return {
+        message: {
+          data: header.slice(offset, offset + chunkLength),
+        },
+      };
+    }
+    throw new Error(`Unexpected request: ${requestType}`);
+  });
 };
 
 describe('checkAllFirmwareRelease Protocol V2 support', () => {
@@ -153,6 +210,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
   test('detects same-version package hotfixes by P1 and P2 payload hash', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
+      resourceBundles: undefined,
       installOrder: ['applicationP1', 'applicationP2'],
       components: {
         applicationP1: {
@@ -203,6 +261,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
       required: false,
+      resourceBundles: undefined,
       installOrder: ['applicationP1'],
       components: {
         applicationP1: {
@@ -233,6 +292,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
       required: false,
+      resourceBundles: undefined,
       installOrder: ['applicationP1'],
       components: {
         applicationP1: {
@@ -263,6 +323,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
   test('updates both application packages when normal mode only reports P1', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
+      resourceBundles: undefined,
       installOrder: ['applicationP1', 'applicationP2'],
       components: {
         applicationP1: {
@@ -309,7 +370,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       status: { mode: 'normal' },
       versions: currentVersions,
     });
-    const typedCall = jest.fn();
+    const typedCall = createFilesystemTypedCall(true);
     method.device = {
       isProtocolV2: () => true,
       features: {
@@ -320,24 +381,14 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       getCommands: () => ({ typedCall }),
     } as unknown as CheckAllFirmwareRelease['device'];
     jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
+    jest.spyOn(DataManager, 'getProtocolV2Resources').mockReturnValue(stableResources as any);
 
     await expect(method.run()).resolves.toMatchObject({
       protocol: 'V2',
       deviceType: 'pro2',
       status: 'required',
       resourceStatus: 'unknown',
-      resourceArchive: resourceSource,
       targetsToUpdate: ['boot', 'app_v1'],
-      firmwareUpdatePlan: {
-        executor: 'v4',
-        platform: 'web',
-        artifacts: [
-          { artifactId: 'component:boot', target: 'boot' },
-          { artifactId: 'component:app_v1', target: 'app_v1' },
-        ],
-        targetsToUpdate: ['boot', 'app_v1'],
-      },
       firmware: {
         status: 'required',
       },
@@ -349,337 +400,11 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
   });
 
-  test('preserves platform and forced firmware targets in the Protocol V2 prepared plan', async () => {
-    const method = new CheckAllFirmwareRelease({
-      id: 1,
-      payload: {
-        method: 'checkAllFirmwareRelease',
-        firmwareType: EFirmwareType.Universal,
-        platform: 'native',
-        forceUpdateTargets: ['firmware'],
-      },
-    });
-    method.init();
-    method.device = {
-      isProtocolV2: () => true,
-      features: {
-        deviceType: 'pro2',
-        serialNo: 'pro2-device-id',
-        firmwareVersion: '1.0.0',
-      },
-      getDeviceState: jest.fn().mockResolvedValue({
-        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
-        status: { mode: 'normal' },
-        versions: currentVersions,
-      }),
-    } as unknown as CheckAllFirmwareRelease['device'];
-    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
-
-    await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03'],
-      firmwareUpdatePlan: {
-        executor: 'v4',
-        deviceIdentity: 'pro2-device-id',
-        platform: 'native',
-        artifacts: [
-          { artifactId: 'component:boot', target: 'boot' },
-          { artifactId: 'component:app_v1', target: 'app_v1' },
-          { artifactId: 'component:se02', target: 'se02' },
-          { artifactId: 'component:se03', target: 'se03' },
-        ],
-        targetsToUpdate: ['boot', 'app_v1', 'se02', 'se03'],
-      },
-    });
-  });
-
-  test('includes exact Protocol V2 developer force targets in the prepared plan', async () => {
-    const currentRelease: IFirmwareReleaseInfo = {
-      ...release,
-      required: false,
-      version: [1, 0, 0],
-      installOrder: ['applicationP1', 'coprocessor'],
-      components: {
-        applicationP1: {
-          target: 'APPLICATION_P1',
-          url: 'https://example.com/application-p1.okpkg',
-          version: [1, 0, 0],
-          ...validComponentIntegrity,
-        },
-        coprocessor: {
-          target: 'COPROCESSOR',
-          url: 'https://example.com/coprocessor.okpkg',
-          version: [1, 0, 0],
-          ...validComponentIntegrity,
-        },
-      },
-    };
-    const method = new CheckAllFirmwareRelease({
-      id: 1,
-      payload: {
-        method: 'checkAllFirmwareRelease',
-        platform: 'desktop',
-        protocolV2ForceUpdateTargets: ['app_v1', 'coprocessor'],
-      },
-    });
-    method.init();
-    method.device = {
-      isProtocolV2: () => true,
-      features: {
-        deviceType: 'pro2',
-        serialNo: 'pro2-device-id',
-        firmwareVersion: '1.0.0',
-      },
-      getDeviceState: jest.fn().mockResolvedValue({
-        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
-        status: { mode: 'normal' },
-        versions: { ...currentVersions, applicationP1: '1.0.0' },
-      }),
-    } as unknown as CheckAllFirmwareRelease['device'];
-    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(currentRelease);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
-
-    await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['app_v1', 'coprocessor'],
-      firmwareUpdatePlan: {
-        executor: 'v4',
-        platform: 'desktop',
-        artifacts: [
-          { artifactId: 'component:app_v1', target: 'app_v1' },
-          { artifactId: 'component:coprocessor', target: 'coprocessor' },
-        ],
-        targetsToUpdate: ['app_v1', 'coprocessor'],
-      },
-    });
-  });
-
-  test('builds a Desktop V4 prepared update without device identity', async () => {
-    const currentRelease: IFirmwareReleaseInfo = {
-      ...release,
-      required: false,
-      version: [1, 0, 0],
-      installOrder: ['applicationP1'],
-      components: {
-        applicationP1: {
-          target: 'APPLICATION_P1',
-          url: 'https://example.com/application-p1.okpkg',
-          version: [1, 0, 0],
-          ...validComponentIntegrity,
-        },
-      },
-    };
-    const method = new CheckAllFirmwareRelease({
-      id: 1,
-      payload: {
-        method: 'checkAllFirmwareRelease',
-        platform: 'desktop',
-        protocolV2ForceUpdateTargets: ['app_v1'],
-      },
-    });
-    method.init();
-    method.device = {
-      isProtocolV2: () => true,
-      features: { deviceType: 'pro2', firmwareVersion: '1.0.0' },
-      getDeviceState: jest.fn().mockResolvedValue({
-        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
-        status: { mode: 'normal' },
-        versions: { ...currentVersions, applicationP1: '1.0.0' },
-      }),
-    } as unknown as CheckAllFirmwareRelease['device'];
-    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(currentRelease);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
-
-    await expect(method.run()).resolves.toMatchObject({
-      firmwareUpdatePlan: {
-        executor: 'v4',
-        deviceIdentity: 'unavailable',
-      },
-    });
-  });
-
-  test('rejects Neo-only unsupported exact secure-element targets', async () => {
-    const neoRelease: IFirmwareReleaseInfo = {
-      ...release,
-      required: false,
-      installOrder: ['se03'],
-      components: {
-        se03: {
-          target: 'SE03',
-          url: 'https://example.com/se03.okpkg',
-          version: [1, 0, 0],
-        },
-      },
-    };
-    const method = new CheckAllFirmwareRelease({
-      id: 1,
-      payload: {
-        method: 'checkAllFirmwareRelease',
-        protocolV2ForceUpdateTargets: ['se03'],
-      },
-    });
-    method.init();
-    method.device = {
-      isProtocolV2: () => true,
-      features: { deviceType: 'neo', firmwareVersion: '1.0.0' },
-      getDeviceState: jest.fn().mockResolvedValue({
-        identity: { deviceType: 'neo', firmwareType: EFirmwareType.Universal },
-        status: { mode: 'normal' },
-        versions: currentVersions,
-      }),
-    } as unknown as CheckAllFirmwareRelease['device'];
-    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(neoRelease);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
-
-    await expect(method.run()).rejects.toMatchObject({
-      params: { firmwareUpdateCode: 'FirmwarePlanInvalid' },
-    });
-  });
-
-  test('builds a V4 plan for Neo and excludes unsupported secure elements when forced', async () => {
-    const neoRelease: IFirmwareReleaseInfo = {
-      ...release,
-      installOrder: ['se01', 'se02', 'se03', 'se04'],
-      components: {
-        se01: {
-          target: 'SE01',
-          url: 'https://example.com/se01.bin',
-          version: [1, 0, 0],
-          ...validComponentIntegrity,
-        },
-        se02: {
-          target: 'SE02',
-          url: 'https://example.com/se02.bin',
-          version: [2, 0, 0],
-          ...validComponentIntegrity,
-        },
-        se03: { target: 'SE03', url: 'https://example.com/se03.bin', version: [1, 0, 0] },
-        se04: { target: 'SE04', url: 'https://example.com/se04.bin', version: [1, 0, 0] },
-      },
-    };
-    const method = new CheckAllFirmwareRelease({
-      id: 1,
-      payload: {
-        method: 'checkAllFirmwareRelease',
-        platform: 'native',
-        forceUpdateTargets: ['firmware'],
-      },
-    });
-    method.init();
-    method.device = {
-      isProtocolV2: () => true,
-      features: {
-        deviceType: 'neo',
-        serialNo: 'neo-device-id',
-        firmwareVersion: '1.0.0',
-      },
-      getDeviceState: jest.fn().mockResolvedValue({
-        identity: { deviceType: 'neo', firmwareType: EFirmwareType.Universal },
-        status: { mode: 'normal' },
-        versions: currentVersions,
-      }),
-    } as unknown as CheckAllFirmwareRelease['device'];
-    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(neoRelease);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
-
-    await expect(method.run()).resolves.toMatchObject({
-      targetsToUpdate: ['se01', 'se02'],
-      firmwareUpdatePlan: {
-        executor: 'v4',
-        deviceModel: 'neo',
-        platform: 'native',
-        targetsToUpdate: ['se01', 'se02'],
-      },
-    });
-  });
-
-  test('rejects a forced Protocol V2 resource target without a configured archive', async () => {
-    const method = new CheckAllFirmwareRelease({
-      id: 1,
-      payload: {
-        method: 'checkAllFirmwareRelease',
-        forceUpdateTargets: ['resource'],
-      },
-    });
-    method.init();
-    method.device = {
-      isProtocolV2: () => true,
-      features: { deviceType: 'pro2', firmwareVersion: '1.0.0' },
-      getDeviceState: jest.fn().mockResolvedValue({
-        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
-        status: { mode: 'normal' },
-        versions: currentVersions,
-      }),
-    } as unknown as CheckAllFirmwareRelease['device'];
-    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(undefined);
-
-    await expect(method.run()).rejects.toMatchObject({
-      params: { firmwareUpdateCode: 'FirmwarePlanInvalid' },
-    });
-  });
-
-  test('adds a Protocol V2 resource target only when explicitly forced', async () => {
-    const currentRelease: IFirmwareReleaseInfo = {
-      ...release,
-      required: false,
-      installOrder: ['applicationP1'],
-      components: {
-        applicationP1: {
-          target: 'APPLICATION_P1',
-          url: 'https://example.com/application-p1.okpkg',
-          version: [1, 0, 0],
-        },
-      },
-    };
-    const method = new CheckAllFirmwareRelease({
-      id: 1,
-      payload: {
-        method: 'checkAllFirmwareRelease',
-        platform: 'desktop',
-        protocolV2ForceUpdateTargets: ['resource'],
-      },
-    });
-    method.init();
-    method.device = {
-      isProtocolV2: () => true,
-      features: {
-        deviceType: 'pro2',
-        serialNo: 'pro2-device-id',
-        firmwareVersion: '1.0.0',
-      },
-      getDeviceState: jest.fn().mockResolvedValue({
-        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
-        status: { mode: 'normal' },
-        versions: { ...currentVersions, applicationP1: '1.0.0' },
-      }),
-    } as unknown as CheckAllFirmwareRelease['device'];
-    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(currentRelease);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
-
-    await expect(method.run()).resolves.toMatchObject({
-      status: 'valid',
-      hasUpgrade: true,
-      targetsToUpdate: ['resource'],
-      firmwareUpdatePlan: {
-        executor: 'v4',
-        platform: 'desktop',
-        artifacts: [
-          {
-            artifactId: 'resource:archive',
-            target: 'resource',
-            role: 'resourceBundle',
-            container: 'zip',
-          },
-        ],
-        targetsToUpdate: ['resource'],
-      },
-    });
-  });
-
   test('requests and compares firmware hashes only when explicitly enabled', async () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,
       required: false,
+      resourceBundles: undefined,
       installOrder: ['applicationP1'],
       components: {
         applicationP1: {
@@ -712,7 +437,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       getCommands: () => ({ typedCall: jest.fn() }),
     } as unknown as CheckAllFirmwareRelease['device'];
     jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(packageSet);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(undefined);
+    jest.spyOn(DataManager, 'getProtocolV2Resources').mockReturnValue(undefined);
 
     await expect(method.run()).resolves.toMatchObject({
       status: 'outdated',
@@ -724,7 +449,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
   });
 
   test.each(['bootloader', 'romloader'] as const)(
-    'does not read vol0 resource inventory in %s mode',
+    'uses filesystem inventory in %s mode instead of forcing all resources',
     async mode => {
       const method = new CheckAllFirmwareRelease({
         id: 1,
@@ -734,7 +459,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         },
       });
       method.init();
-      const typedCall = jest.fn();
+      const typedCall = createFilesystemTypedCall();
       method.device = {
         isProtocolV2: () => true,
         features: { deviceType: 'pro2', firmwareVersion: '1.0.0' },
@@ -746,61 +471,18 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
         getCommands: () => ({ typedCall }),
       } as unknown as CheckAllFirmwareRelease['device'];
       jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
-      jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
+      jest.spyOn(DataManager, 'getProtocolV2Resources').mockReturnValue(stableResources as any);
 
       await expect(method.run()).resolves.toMatchObject({
         protocol: 'V2',
-        resourceStatus: 'unknown',
-        resourceArchive: resourceSource,
+        resourceStatus: 'valid',
         targetsToUpdate: ['boot', 'app_v1'],
       });
-      expect(typedCall).not.toHaveBeenCalled();
+      expect(typedCall.mock.calls.some(call => call[0] === 'ResourceInventoryGet')).toBe(false);
+      expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileRead')).toBe(true);
     }
   );
 
-  test('exposes resource archive availability without reporting an unconfirmed update', async () => {
-    const currentRelease: IFirmwareReleaseInfo = {
-      ...release,
-      required: false,
-      installOrder: ['applicationP1'],
-      components: {
-        applicationP1: {
-          target: 'APPLICATION_P1',
-          url: 'https://example.com/application-p1.okpkg',
-          version: [1, 0, 0],
-        },
-      },
-    };
-    const method = new CheckAllFirmwareRelease({
-      id: 1,
-      payload: {
-        method: 'checkAllFirmwareRelease',
-        firmwareType: EFirmwareType.Universal,
-      },
-    });
-    method.init();
-    method.device = {
-      isProtocolV2: () => true,
-      features: { deviceType: 'pro2', firmwareVersion: '1.0.0' },
-      getDeviceState: jest.fn().mockResolvedValue({
-        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
-        status: { mode: 'normal' },
-        versions: { ...currentVersions, applicationP1: '1.0.0' },
-      }),
-    } as unknown as CheckAllFirmwareRelease['device'];
-    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(currentRelease);
-    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue(resourceSource);
-
-    await expect(method.run()).resolves.toMatchObject({
-      status: 'valid',
-      hasUpgrade: false,
-      resourceStatus: 'unknown',
-      resourceArchive: resourceSource,
-      targetsToUpdate: [],
-      firmwareUpdatePlan: undefined,
-    });
-  });
-
   test('continues forwarding the existing public method', async () => {
     const call = jest.fn().mockResolvedValue({ success: true, payload: {} });
     const api = createCoreApi(call as CoreApi['call']) as CoreApi;
@@ -808,7 +490,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     await api.checkAllFirmwareRelease('pro2-connect-id', {
       checkFirmwareHash: true,
       firmwareType: EFirmwareType.Universal,
-      protocolV2ForceUpdateTargets: ['app_v1'],
       retryCount: 0,
     });
 
@@ -816,7 +497,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
       connectId: 'pro2-connect-id',
       checkFirmwareHash: true,
       firmwareType: EFirmwareType.Universal,
-      protocolV2ForceUpdateTargets: ['app_v1'],
       retryCount: 0,
       method: 'checkAllFirmwareRelease',
     });

package/__tests__/firmware-update/device-update-bootloader.test.ts

@@ -9,7 +9,6 @@ import {
 jest.mock('../../src/api/firmware/FirmwareUpdatePreparedPlan', () => ({
   assertFirmwareUpdatePreparedPlanBinding: jest.fn(),
   assertFirmwareUpdatePreparedPlanDeviceIdentity: jest.fn(),
-  validateFirmwareUpdatePreparedPlan: jest.fn((preparedPlan: unknown) => preparedPlan),
 }));
 
 jest.mock('../../src/data-manager', () => ({
@@ -37,17 +36,14 @@ const createMethod = () => {
     read: jest.fn(),
     close,
   };
-  const hostBindingGeneration = registerFirmwareUpdateHostBinding({
-    artifactReader,
-    preparedPlanDigest: 'a'.repeat(64),
-  });
+  const hostBindingGeneration = registerFirmwareUpdateHostBinding({ artifactReader });
   const method = new DeviceUpdateBootloader({
     id: 1,
     payload: {
       method: 'deviceUpdateBootloader',
       artifact,
       hostBindingGeneration,
-      preparedPlan: { preparedPlanDigest: 'a'.repeat(64) },
+      preparedPlan: {},
     },
   });
   (method as any).device = {

package/__tests__/firmware-update/firmware-host-binding.test.ts

@@ -6,7 +6,6 @@ import {
 } from '../../src/api/firmware/FirmwareHostBinding';
 
 const createBinding = () => ({
-  preparedPlanDigest: 'a'.repeat(64),
   artifactReader: {
     open: jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: 4 })),
     read: jest.fn(() =>
@@ -68,12 +67,4 @@ describe('firmware host binding generation', () => {
       readerId: 'stale-reader',
     });
   });
-
-  test('rejects a prepared plan from another host generation before opening artifacts', () => {
-    const generation = registerFirmwareUpdateHostBinding(createBinding());
-
-    expect(() => resolveFirmwareUpdateHostBinding(generation, 'b'.repeat(64))).toThrow(
-      'does not match the prepared plan'
-    );
-  });
 });