@onekeyfe/hd-core 1.2.0-alpha.57 → 1.2.0-alpha.59

package/__tests__/protocol-v2.test.ts

@@ -14,9 +14,6 @@ import DirList from '../src/api/DirList';
 import FileRead from '../src/api/FileRead';
 import FileWrite from '../src/api/FileWrite';
 import UploadPortfolio from '../src/api/UploadPortfolio';
-import DeviceFactoryCertificateRead from '../src/api/protocol-v2/DeviceFactoryCertificateRead';
-import DeviceFactoryCertificateWrite from '../src/api/protocol-v2/DeviceFactoryCertificateWrite';
-import DeviceFactoryChallengeSign from '../src/api/protocol-v2/DeviceFactoryChallengeSign';
 import DeviceFactoryInfoGet from '../src/api/protocol-v2/DeviceFactoryInfoGet';
 import DeviceFactoryInfoSet from '../src/api/protocol-v2/DeviceFactoryInfoSet';
 import DeviceFirmwareUpdate from '../src/api/protocol-v2/DeviceFirmwareUpdate';
@@ -592,7 +589,7 @@ describe('Protocol V2 feature adapter', () => {
     } as any);
     const protocolV2 = buildProtocolV2FeaturesPayload({
       deviceInfo: {
-        hw: { serial_no: 'P2-001' },
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'P2-001' },
         coprocessor: { bt_adv_name: 'Pro 2 BLE' },
       },
       deviceStatus: {
@@ -2699,8 +2696,10 @@ describe('Protocol V2 feature adapter', () => {
     ).rejects.toThrow('DeviceInfo not supported');
   });
 
-  test('does not inherit Pro or Pro model fallback ranges for Protocol V2 devices', () => {
-    const features = normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any);
+  test('does not inherit Pro or model_touch ranges for Protocol V2 devices', () => {
+    const features = normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
+      hw: { Device_type: DeviceType.PRO2 },
+    });
     const checkedTypes: string[] = [];
 
     const versionRange = getMethodVersionRange(features, type => {
@@ -2712,11 +2711,13 @@ describe('Protocol V2 feature adapter', () => {
     });
 
     expect(versionRange).toBeUndefined();
-    expect(checkedTypes).toEqual(['pro2']);
+    expect(checkedTypes).toEqual(['pro2', 'model_pro2']);
   });
 
   test('uses firmware-v1 as the Pro2 remote firmware config field', () => {
-    const features = normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any);
+    const features = normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
+      hw: { Device_type: DeviceType.PRO2 },
+    });
 
     expect(
       getFirmwareUpdateField({
@@ -3626,71 +3627,77 @@ describe('API compatibility handling', () => {
     });
   });
 
-  test('allows Pro2 Solana signing methods through Protocol V2 version checks', () => {
-    const features = {
-      deviceType: 'pro2',
-    } as Features;
+  test.each(['pro2', 'neo'] as const)(
+    'allows %s Solana signing methods through Protocol V2 version checks',
+    deviceType => {
+      const features = {
+        deviceType,
+      } as Features;
 
-    const solSignMessageMethod = new SolSignMessage({
-      id: 1,
-      payload: {
-        method: 'solSignMessage',
-        path: "m/44'/501'/0'/0'",
-        messageHex: '48656c6c6f',
-      },
-    });
-    const solSignOffchainMessageMethod = new SolSignOffchainMessage({
-      id: 2,
-      payload: {
-        method: 'solSignOffchainMessage',
-        path: "m/44'/501'/0'/0'",
-        messageHex: '48656c6c6f',
-      },
-    });
-    const solSignTransactionMethod = new SolSignTransaction({
-      id: 3,
-      payload: {
-        method: 'solSignTransaction',
-        path: "m/44'/501'/0'/0'",
-        rawTx: '00',
-      },
-    });
-    const solSignVersionedTransactionMethod = new SolSignTransaction({
-      id: 4,
-      payload: {
-        method: 'solSignTransaction',
-        path: "m/44'/501'/0'/0'",
-        rawTx: '80',
-      },
-    });
+      const solSignMessageMethod = new SolSignMessage({
+        id: 1,
+        payload: {
+          method: 'solSignMessage',
+          path: "m/44'/501'/0'/0'",
+          messageHex: '48656c6c6f',
+        },
+      });
+      const solSignOffchainMessageMethod = new SolSignOffchainMessage({
+        id: 2,
+        payload: {
+          method: 'solSignOffchainMessage',
+          path: "m/44'/501'/0'/0'",
+          messageHex: '48656c6c6f',
+        },
+      });
+      const solSignTransactionMethod = new SolSignTransaction({
+        id: 3,
+        payload: {
+          method: 'solSignTransaction',
+          path: "m/44'/501'/0'/0'",
+          rawTx: '00',
+        },
+      });
+      const solSignVersionedTransactionMethod = new SolSignTransaction({
+        id: 4,
+        payload: {
+          method: 'solSignTransaction',
+          path: "m/44'/501'/0'/0'",
+          rawTx: '80',
+        },
+      });
 
-    solSignTransactionMethod.init();
-    solSignVersionedTransactionMethod.init();
+      solSignTransactionMethod.init();
+      solSignVersionedTransactionMethod.init();
 
-    expect(
-      getMethodVersionRange(features, type => solSignMessageMethod.getVersionRange()[type])
-    ).toEqual({
-      min: '0.0.0',
-    });
-    expect(
-      getMethodVersionRange(features, type => solSignOffchainMessageMethod.getVersionRange()[type])
-    ).toEqual({
-      min: '0.0.0',
-    });
-    expect(
-      getMethodVersionRange(features, type => solSignTransactionMethod.getVersionRange()[type])
-    ).toEqual({
-      min: '0.0.0',
-    });
-    expect(
-      getMethodVersionRange(
-        features,
-        type => solSignVersionedTransactionMethod.getVersionRange()[type]
-      )
-    ).toEqual({
-      min: '0.0.0',
-    });
-  });
+      expect(
+        getMethodVersionRange(features, type => solSignMessageMethod.getVersionRange()[type])
+      ).toEqual({
+        min: '0.0.0',
+      });
+      expect(
+        getMethodVersionRange(
+          features,
+          type => solSignOffchainMessageMethod.getVersionRange()[type]
+        )
+      ).toEqual({
+        min: '0.0.0',
+      });
+      expect(
+        getMethodVersionRange(features, type => solSignTransactionMethod.getVersionRange()[type])
+      ).toEqual({
+        min: '0.0.0',
+      });
+      expect(
+        getMethodVersionRange(
+          features,
+          type => solSignVersionedTransactionMethod.getVersionRange()[type]
+        )
+      ).toEqual({
+        min: '0.0.0',
+      });
+    }
+  );
 
   test('uses chunk transfer for large Sui transactions on Protocol V2', async () => {
     const rawTx = '0x'.concat('ab'.repeat(5000));
@@ -3786,7 +3793,7 @@ describe('API compatibility handling', () => {
 
 describe('Protocol V2 firmware update targets', () => {
   const OKPP_HEADER_SIZE = 0x52a0;
-  let forceReloadDataSpy: jest.SpyInstance<Promise<void>, []>;
+  let forceReloadDataSpy: jest.SpyInstance;
 
   beforeEach(() => {
     forceReloadDataSpy = jest.spyOn(DataManager, 'forceReloadData').mockResolvedValue(undefined);
@@ -4057,6 +4064,10 @@ describe('Protocol V2 firmware update targets', () => {
       originalDescriptor: { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
       features: { bootloader_mode: false, capabilities: [] },
       isBootloader: () => false,
+      probeProtocolV2RuntimeState: jest.fn().mockResolvedValue({
+        mode: 'bootloader',
+        bootloaderMode: true,
+      }),
     });
     (method as any).protocolV2Reboot = jest.fn().mockResolvedValue({
       message: 'Device rebooted successfully',
@@ -4084,6 +4095,7 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
     (method as any).device.getCommands = () => ({ typedCall });
     (method as any).protocolV2ExpectedSerialNumber = 'PR9999999999';
+    (method as any).protocolV2ExpectedPath = 'usb-path';
     method.postTipMessage = jest.fn();
 
     await (method as any).enterProtocolV2BootloaderMode();
@@ -4095,6 +4107,38 @@ describe('Protocol V2 firmware update targets', () => {
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
   });
 
+  test('announces bootloader success only after Protocol V2 bootloader mode is confirmed', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    (method as any).device = stubDevice({
+      features: { bootloader_mode: false, capabilities: [] },
+      isBootloader: () => false,
+      isRomloader: () => false,
+    });
+    (method as any).protocolV2Reboot = jest.fn().mockResolvedValue({
+      message: 'Device rebooted successfully',
+    });
+
+    const tipMessages: string[] = [];
+    method.postTipMessage = jest.fn((message: string) => {
+      tipMessages.push(message);
+    });
+    let successWasAnnouncedBeforeConfirmation = false;
+    (method as any).waitForProtocolV2BootloaderMode = jest.fn().mockImplementation(() => {
+      successWasAnnouncedBeforeConfirmation = tipMessages.includes('GoToBootloaderSuccess');
+      return Promise.resolve({ mode: 'bootloader' });
+    });
+
+    await (method as any).enterProtocolV2BootloaderMode();
+
+    expect(successWasAnnouncedBeforeConfirmation).toBe(false);
+    expect(tipMessages).toEqual(['AutoRebootToBootloader', 'GoToBootloaderSuccess']);
+  });
+
   test('keeps Protocol V2 bootloader active before firmware transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4120,6 +4164,7 @@ describe('Protocol V2 firmware update targets', () => {
 
     expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
     expect(method.postTipMessage).not.toHaveBeenCalledWith('AutoRebootToBootloader');
+    expect(method.postTipMessage).toHaveBeenCalledWith('GoToBootloaderSuccess');
   });
 
   test('keeps Protocol V2 romloader active before firmware transfer', async () => {
@@ -4209,6 +4254,10 @@ describe('Protocol V2 firmware update targets', () => {
       originalDescriptor: { id: 'usb-id', path: 'app-path', protocolType: 'V2' },
       features: { bootloader_mode: false, capabilities: [] },
       isBootloader: () => false,
+      probeProtocolV2RuntimeState: jest.fn().mockResolvedValue({
+        mode: 'bootloader',
+        bootloaderMode: true,
+      }),
     });
     const typedCall = jest.fn().mockImplementation((requestType: string) => {
       if (requestType === 'DeviceInfoGet') {
@@ -4236,15 +4285,13 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
     (method as any).device.getCommands = () => ({ typedCall });
     (method as any).protocolV2ExpectedSerialNumber = 'PR9999999999';
+    (method as any).protocolV2ExpectedPath = 'app-path';
 
     await (method as any).waitForProtocolV2BootloaderMode(60 * 1000, 0);
 
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(3);
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceInfoGet',
-      'ProtocolInfoRequest',
-    ]);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceInfoGet']);
   });
 
   test('does not run generic initialize during Protocol V2 USB firmware reconnect', async () => {
@@ -4281,6 +4328,7 @@ describe('Protocol V2 firmware update targets', () => {
       deviceList: [cachedDevice],
     } as any);
     (method as any).device = device;
+    (method as any).protocolV2ExpectedPath = 'usb-path';
 
     try {
       await (method as any).reconnectProtocolV2Device();
@@ -4331,6 +4379,7 @@ describe('Protocol V2 firmware update targets', () => {
       deviceList: [otherDevice, expectedDevice],
     } as any);
     (method as any).device = device;
+    (method as any).protocolV2ExpectedPath = 'usb-path';
     (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-B';
 
     try {
@@ -4387,7 +4436,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(updateFromCache).not.toHaveBeenCalled();
   });
 
-  test('allows a single Protocol V2 USB reconnect candidate when its physical serial is unavailable', async () => {
+  test('allows a Protocol V2 USB reconnect candidate without a serial only when its path matches', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -4397,7 +4446,7 @@ describe('Protocol V2 firmware update targets', () => {
     const commands = { disposed: true, mainId: '' };
     const updateFromCache = jest.fn();
     const device = stubDevice({
-      originalDescriptor: { id: 'old-usb-id', path: 'old-usb-path', protocolType: 'V2' },
+      originalDescriptor: { id: 'usb-a', path: 'usb-a', protocolType: 'V2' },
       deviceConnector: {
         enumerate: jest.fn().mockResolvedValue({
           descriptors: [{ id: 'usb-a', path: 'usb-a', protocolType: 'V2' }],
@@ -4420,6 +4469,7 @@ describe('Protocol V2 firmware update targets', () => {
     } as any);
     (method as any).device = device;
     (method as any).protocolV2ExpectedSerialNumber = 'PRO2-PHYSICAL-A';
+    (method as any).protocolV2ExpectedPath = 'usb-a';
 
     try {
       await (method as any).reconnectProtocolV2Device();
@@ -4509,6 +4559,7 @@ describe('Protocol V2 firmware update targets', () => {
       deviceList: [{ getConnectId: () => 'usb-path' }],
     } as any);
     (method as any).device = device;
+    (method as any).protocolV2ExpectedPath = 'usb-path';
 
     try {
       await (method as any).reconnectProtocolV2Device();
@@ -4539,6 +4590,7 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).protocolV2ExpectedSerialNumber = 'expected-serial';
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
     (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
       getCommands: () => ({ typedCall }),
       probeProtocolV2RuntimeState: jest.fn().mockResolvedValue({
         deviceId: 'changed-device',
@@ -5783,14 +5835,14 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('treats manual resource bundles as explicit payload without remote firmware auto-fill', async () => {
+  test('treats manual resource files as explicit payload without remote firmware auto-fill', async () => {
     const resourceBundle = new Uint8Array([1, 2, 3]).buffer;
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
-        resourceBundleFiles: [
+        resourceFiles: [
           {
             binary: resourceBundle,
             devicePath: '  VOL0:/resource/images/images.okpkg  ',
@@ -5838,7 +5890,7 @@ describe('Protocol V2 firmware update targets', () => {
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
-        resourceBundleFiles: [
+        resourceFiles: [
           {
             binary: new Uint8Array([1, 2, 3]).buffer,
             devicePath: 'vol2:/resource/images/images.okpkg',
@@ -5857,7 +5909,7 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).enterProtocolV2BootloaderMode = jest.fn();
     method.postTipMessage = jest.fn();
 
-    await expect(method.run()).rejects.toThrow('resourceBundleFiles[0].devicePath');
+    await expect(method.run()).rejects.toThrow('resourceFiles[0].devicePath');
     expect((method as any).prepareRemoteProtocolV2Binaries).not.toHaveBeenCalled();
     expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
   });
@@ -5916,8 +5968,10 @@ describe('Protocol V2 firmware update targets', () => {
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
+      getCurrentDeviceType: () => 'pro2',
+      toMessageObject: () => ({ connectId: 'firmware-device' }),
     });
-    method.postProgressMessage = jest.fn();
+    method.postMessage = jest.fn();
 
     await (method as any).protocolV2CommonUpdateProcess({
       payload: new Uint8Array(4097).buffer,
@@ -5932,6 +5986,17 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.overwrite)).toEqual([true, false]);
     expect(writePayloads.every(payload => payload.append === false)).toBe(true);
     expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 100]);
+    expect(method.postMessage).toHaveBeenLastCalledWith({
+      event: 'UI_EVENT',
+      type: UI_REQUEST.FIRMWARE_PROGRESS,
+      payload: expect.objectContaining({
+        progress: 99,
+        progressType: 'transferData',
+        transferredBytes: 4097,
+        totalBytes: 4097,
+        elapsedMs: expect.any(Number),
+      }),
+    });
   });
 
   test('restarts the whole file from offset zero after an ambiguous chunk write failure', async () => {
@@ -6245,7 +6310,7 @@ describe('Protocol V2 firmware update method', () => {
     expect(typedCall).not.toHaveBeenCalled();
   });
 
-  test.each([0, 2])(
+  test.each([0, 1, 2])(
     'rejects firmware target %s because the Pro2 bootloader cannot install it',
     async targetId => {
       const typedCall = jest.fn();
@@ -6278,8 +6343,8 @@ describe('Protocol V2 firmware update method', () => {
         targets: [
           {
             target_id: undefined,
-            targetId: 1,
-            path: 'vol0:resource.crate.okpkg',
+            targetId: 3,
+            path: 'vol0:bootloader.okpkg',
           },
         ],
       } as any,
@@ -6291,7 +6356,7 @@ describe('Protocol V2 firmware update method', () => {
 
     await method.run();
     expect(typedCall.mock.calls[0][2]).toEqual({
-      targets: [{ target_id: 1, path: 'vol0:resource.crate.okpkg' }],
+      targets: [{ target_id: 3, path: 'vol0:bootloader.okpkg' }],
     });
   });
 
@@ -6423,10 +6488,16 @@ describe('Protocol V2 firmware reconnect identity', () => {
     ).not.toThrow();
   });
 
-  test('allows reconnect when either physical serial is unavailable', () => {
-    expect(() => assertProtocolV2ReconnectIdentity('expected-serial', undefined)).not.toThrow();
-    expect(() => assertProtocolV2ReconnectIdentity(undefined, 'actual-serial')).not.toThrow();
-    expect(() => assertProtocolV2ReconnectIdentity(undefined, undefined)).not.toThrow();
+  test('requires the same descriptor path when either physical serial is unavailable', () => {
+    expect(() =>
+      assertProtocolV2ReconnectIdentity('expected-serial', undefined, 'usb-path', 'usb-path')
+    ).not.toThrow();
+    expect(() =>
+      assertProtocolV2ReconnectIdentity(undefined, 'actual-serial', 'usb-path', 'other-path')
+    ).toThrow('identity unavailable');
+    expect(() => assertProtocolV2ReconnectIdentity(undefined, undefined)).toThrow(
+      'identity unavailable'
+    );
   });
 
   test('captures physical identity from active DeviceInfo instead of wallet deviceId', async () => {
@@ -6444,6 +6515,7 @@ describe('Protocol V2 firmware reconnect identity', () => {
       },
     });
     (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
       features: { deviceId: 'wallet-derived-id' },
       getCommands: () => ({ typedCall }),
     });
@@ -6469,11 +6541,13 @@ describe('Protocol V2 firmware reconnect identity', () => {
       message: { protocol_version: 1, hw: {} },
     });
     (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
       getCommands: () => ({ typedCall }),
     });
 
     await expect((method as any).captureProtocolV2PhysicalIdentity()).resolves.toBeUndefined();
     expect((method as any).protocolV2ExpectedSerialNumber).toBeUndefined();
+    expect((method as any).protocolV2ExpectedPath).toBeDefined();
   });
 
   test('uses filesystem reads instead of ResourceInventoryGet for resource comparison', async () => {
@@ -6498,6 +6572,7 @@ describe('Protocol V2 firmware reconnect identity', () => {
     const typedCall = createResourceFilesystemTypedCall(stable);
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
+      getCurrentDeviceType: () => 'pro2',
     });
     const resourcesSpy = jest
       .spyOn(DataManager, 'getProtocolV2Resources')
@@ -6527,7 +6602,10 @@ describe('Protocol V2 firmware reconnect identity', () => {
       })
     );
     const typedCall = createResourceFilesystemTypedCall(stable, ['images']);
-    (method as any).device = stubDevice({ getCommands: () => ({ typedCall }) });
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      getCurrentDeviceType: () => 'pro2',
+    });
     const resourcesSpy = jest
       .spyOn(DataManager, 'getProtocolV2Resources')
       .mockReturnValue(stable as any);
@@ -6562,7 +6640,10 @@ describe('Protocol V2 firmware reconnect identity', () => {
       })
     );
     const typedCall = createResourceFilesystemTypedCall(stable, ['images']);
-    (method as any).device = stubDevice({ getCommands: () => ({ typedCall }) });
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      getCurrentDeviceType: () => 'pro2',
+    });
     const resourcesSpy = jest
       .spyOn(DataManager, 'getProtocolV2Resources')
       .mockReturnValue(stable as any);
@@ -6583,34 +6664,6 @@ describe('Protocol V2 firmware reconnect identity', () => {
     resourcesSpy.mockRestore();
   });
 
-  const buildBootResourcesHeader = ({
-    type = 'CRAT',
-    payloadHash = 'ab'.repeat(64),
-    headerHash = 'cd'.repeat(64),
-  }: {
-    type?: string;
-    payloadHash?: string;
-    headerHash?: string;
-  } = {}) => {
-    const header = new Uint8Array(0x52a0);
-    const view = new DataView(header.buffer);
-    'OKPP'.split('').forEach((char, index) => {
-      header[index] = char.charCodeAt(0);
-    });
-    type.split('').forEach((char, index) => {
-      header[0x08 + index] = char.charCodeAt(0);
-    });
-    view.setUint32(0x0c, header.byteLength, true);
-    const writeHex = (offset: number, hex: string) => {
-      for (let index = 0; index < hex.length / 2; index++) {
-        header[offset + index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
-      }
-    };
-    writeHex(0x200, payloadHash);
-    writeHex(0x240, headerHash);
-    return header;
-  };
-
   test('does not resolve boot resources unless the optional target is selected', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -6626,20 +6679,22 @@ describe('Protocol V2 firmware reconnect identity', () => {
     expect(downloadSpy).not.toHaveBeenCalled();
   });
 
-  test('downloads and maps the selected boot resources CRATE target', async () => {
-    const payloadHash = 'ab'.repeat(64);
-    const headerHash = 'cd'.repeat(64);
-    const bytes = buildBootResourcesHeader({ payloadHash, headerHash });
+  test('downloads and maps selected boot resources as direct RES files', async () => {
+    const bytes = new Uint8Array([1, 2, 3, 4]);
     const binary = bytes.buffer as ArrayBuffer;
     const fileHash = Array.from(sha256(bytes), byte => byte.toString(16).padStart(2, '0')).join('');
     const resource = {
       required: false as const,
-      target: 'CRATE' as const,
-      url: 'https://example.com/boot-resources.crate.okpkg',
-      size: bytes.byteLength,
-      fileHash,
-      payloadHash,
-      headerHash,
+      target: 'RES' as const,
+      files: [
+        {
+          name: 'bootloader_crest.bin',
+          url: 'https://example.com/bootloader_crest.bin',
+          devicePath: 'vol0:/assets/loaders/boot.staging/graphics/bootloader_crest.bin',
+          size: bytes.byteLength,
+          fileHash,
+        },
+      ],
     };
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -6650,30 +6705,39 @@ describe('Protocol V2 firmware reconnect identity', () => {
       },
     });
     method.init();
+    (method as any).device = stubDevice({ getCurrentDeviceType: () => 'pro2' });
     jest.spyOn(DataManager, 'getProtocolV2BootResources').mockReturnValue(resource);
     jest.spyOn(firmwareBinaryApi, 'getSysResourceBinary').mockResolvedValue({ binary });
 
-    await expect((method as any).prepareProtocolV2BootResources()).resolves.toEqual({
-      fileName: 'boot_resources.crate.okpkg',
-      binary,
-      targetId: 1,
-      kind: 'boot_resources',
-    });
+    await expect((method as any).prepareProtocolV2BootResources()).resolves.toEqual([
+      {
+        name: 'bootloader_crest.bin',
+        binary,
+        devicePath: 'vol0:/assets/loaders/boot.staging/graphics/bootloader_crest.bin',
+      },
+    ]);
   });
 
-  test('rejects a non-CRATE manual boot resources package', async () => {
+  test('rejects a manually supplied resource file when its manifest hash does not match', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
-        bootResourcesBinary: buildBootResourcesHeader({ type: 'RESC' }).buffer,
+        resourceFiles: [
+          {
+            binary: new Uint8Array([1, 2, 3]).buffer,
+            devicePath: 'vol0:/assets/loaders/boot.staging/graphics/bootloader_crest.bin',
+            size: 3,
+            fileHash: '00'.repeat(32),
+          },
+        ],
       },
     });
     method.init();
 
-    await expect((method as any).prepareProtocolV2BootResources()).rejects.toThrow(
-      'Invalid Pro2 boot resources CRATE header'
+    expect(() => (method as any).prepareExplicitProtocolV2ResourceFiles()).toThrow(
+      'SHA-256 mismatch'
     );
   });
 });
@@ -7228,39 +7292,26 @@ describe('Protocol V2 current low-level methods', () => {
 
   test('sends DeviceFactoryInfoSet and DeviceFactoryInfoGet', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: {} });
-    const manufactureTime = {
-      year: 2026,
-      month: 8,
-      day: 1,
-      hour: 10,
-      minute: 20,
-      second: 30,
-    };
     const setMethod = new DeviceFactoryInfoSet({
       id: 1,
       payload: {
         method: 'deviceFactoryInfoSet',
-        version: 1,
         serial_number: 'PR2SERIAL',
         burn_in_completed: true,
-        factory_test_completed: true,
-        manufacture_time: manufactureTime,
       },
     });
     setMethod.init();
-    expect(setMethod.getSupportedProtocols()).toEqual(['V2']);
-    expect(setMethod.requireDeviceMode).toEqual([UI_REQUEST.BOOTLOADER]);
     (setMethod as any).device = stubDevice({ commands: { typedCall } });
 
     await setMethod.run();
 
     expect(typedCall).toHaveBeenCalledWith('DeviceFactoryInfoSet', 'Success', {
       info: {
-        version: 1,
+        version: undefined,
         serial_number: 'PR2SERIAL',
         burn_in_completed: true,
-        factory_test_completed: true,
-        manufacture_time: manufactureTime,
+        factory_test_completed: undefined,
+        manufacture_time: undefined,
       },
     });
 
@@ -7270,7 +7321,6 @@ describe('Protocol V2 current low-level methods', () => {
       payload: { method: 'deviceFactoryInfoGet' },
     });
     getMethod.init();
-    expect(getMethod.getSupportedProtocols()).toEqual(['V2']);
     (getMethod as any).device = stubDevice({ commands: { typedCall } });
 
     await getMethod.run();
@@ -7278,111 +7328,6 @@ describe('Protocol V2 current low-level methods', () => {
     expect(typedCall).toHaveBeenLastCalledWith('DeviceFactoryInfoGet', 'DeviceFactoryInfo', {});
   });
 
-  test('validates the write-once DeviceFactoryInfoSet payload before sending', () => {
-    expect(() =>
-      new DeviceFactoryInfoSet({
-        id: 1,
-        payload: {
-          method: 'deviceProvisionFactoryInfo',
-          serial_number: 'PR2SERIAL',
-        },
-      }).init()
-    ).toThrow('Parameter [manufacture_time] is required.');
-
-    expect(() =>
-      new DeviceFactoryInfoSet({
-        id: 1,
-        payload: {
-          method: 'deviceProvisionFactoryInfo',
-          version: 1,
-          serial_number: 'P'.repeat(25),
-          burn_in_completed: true,
-          factory_test_completed: true,
-          manufacture_time: {
-            year: 2026,
-            month: 8,
-            day: 1,
-            hour: 0,
-            minute: 0,
-            second: 0,
-          },
-        },
-      }).init()
-    ).toThrow('must not exceed 24 UTF-8 bytes');
-  });
-
-  test('writes, reads and signs with the Protocol V2 factory certificate API', async () => {
-    const typedCall = jest.fn().mockResolvedValue({ message: {} });
-    const write = new DeviceFactoryCertificateWrite({
-      id: 1,
-      payload: {
-        method: 'deviceWriteFactoryCertificate',
-        certificate: 'aabbcc',
-      },
-    });
-    write.init();
-    expect(write.getSupportedProtocols()).toEqual(['V2']);
-    expect(write.requireDeviceMode).toEqual([UI_REQUEST.BOOTLOADER]);
-    (write as any).device = stubDevice({ commands: { typedCall } });
-    await write.run();
-
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceCertificateWrite', 'Success', {
-      cert: {
-        cert_and_pubkey: 'aabbcc',
-        private_key: undefined,
-      },
-    });
-
-    const read = new DeviceFactoryCertificateRead({
-      id: 2,
-      payload: { method: 'deviceReadFactoryCertificate' },
-    });
-    read.init();
-    expect(read.getSupportedProtocols()).toEqual(['V2']);
-    (read as any).device = stubDevice({ commands: { typedCall } });
-    await read.run();
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceCertificateRead', 'DeviceCertificate', {});
-
-    const sign = new DeviceFactoryChallengeSign({
-      id: 3,
-      payload: {
-        method: 'deviceSignFactoryChallenge',
-        digest: '22'.repeat(32),
-      },
-    });
-    sign.init();
-    expect(sign.getSupportedProtocols()).toEqual(['V2']);
-    (sign as any).device = stubDevice({ commands: { typedCall } });
-    await sign.run();
-    expect(typedCall).toHaveBeenLastCalledWith(
-      'DeviceCertificateSign',
-      'DeviceCertificateSignature',
-      { data: '22'.repeat(32) }
-    );
-  });
-
-  test('rejects malformed Protocol V2 factory certificate fields', () => {
-    expect(() =>
-      new DeviceFactoryCertificateWrite({
-        id: 1,
-        payload: {
-          method: 'deviceWriteFactoryCertificate',
-          certificate: 'xyz',
-        },
-      }).init()
-    ).toThrow('even-length hexadecimal string');
-
-    expect(() =>
-      new DeviceFactoryChallengeSign({
-        id: 2,
-        payload: {
-          method: 'deviceSignFactoryChallenge',
-          digest: '11',
-        },
-      }).init()
-    ).toThrow('exactly 32 bytes');
-  });
-
   test('marks explicit Protocol V2 unlock as an on-device PIN interaction', () => {
     const method = new DeviceUnlock({
       id: 1,