@onekeyfe/hd-core 1.2.0-alpha.70 → 1.2.0-alpha.72

package/__tests__/protocol-v2.test.ts

@@ -35,7 +35,10 @@ import ProtocolInfoRequest from '../src/api/protocol-v2/ProtocolInfoRequest';
 import EVMSignTypedData from '../src/api/evm/EVMSignTypedData';
 import EVMSignMessageEIP712 from '../src/api/evm/EVMSignMessageEIP712';
 import FirmwareUpdateV3 from '../src/api/FirmwareUpdateV3';
-import FirmwareUpdateV4, { assertProtocolV2ReconnectIdentity } from '../src/api/FirmwareUpdateV4';
+import FirmwareUpdateV4, {
+  assertProtocolV2FirmwareTargetsSupported,
+  assertProtocolV2ReconnectIdentity,
+} from '../src/api/FirmwareUpdateV4';
 import GetPassphraseState from '../src/api/GetPassphraseState';
 import GetOnekeyFeatures from '../src/api/GetOnekeyFeatures';
 import { batchGetPublickeys } from '../src/api/helpers/batchGetPublickeys';
@@ -255,7 +258,10 @@ describe('UploadPortfolio', () => {
       'FilesystemFileWrite',
       'FilesystemFile',
       expect.any(Object),
-      { timeoutMs: undefined }
+      expect.objectContaining({
+        timeoutMs: undefined,
+        onWriteCompleted: expect.any(Function),
+      })
     );
     expect(typedCall).toHaveBeenNthCalledWith(2, 'PortfolioUpdate', 'Success', {});
   });
@@ -298,7 +304,10 @@ describe('UploadPortfolio', () => {
         append: false,
         ui_percentage: 100,
       },
-      { timeoutMs: undefined }
+      expect.objectContaining({
+        timeoutMs: undefined,
+        onWriteCompleted: expect.any(Function),
+      })
     );
     expect(typedCall).toHaveBeenNthCalledWith(2, 'PortfolioUpdate', 'Success', {});
     expect(method.postMessage).not.toHaveBeenCalled();
@@ -3989,6 +3998,10 @@ describe('Protocol V2 firmware update targets', () => {
     });
 
     const order: string[] = [];
+    (method as any).prepareProtocolV2BootResources = jest.fn().mockImplementation(() => {
+      order.push('prepare-startup-resources');
+      return Promise.resolve([]);
+    });
     (method as any).enterProtocolV2BootloaderMode = jest.fn().mockImplementation(() => {
       order.push('enter-bootloader');
       return Promise.resolve(true);
@@ -4017,7 +4030,12 @@ describe('Protocol V2 firmware update targets', () => {
 
     await method.run();
 
-    expect(order).toEqual(['enter-bootloader', 'prepare-resources', 'execute-update']);
+    expect(order).toEqual([
+      'prepare-startup-resources',
+      'enter-bootloader',
+      'prepare-resources',
+      'execute-update',
+    ]);
   });
 
   test('reboots Protocol V2 normal-mode device to bootloader before transfer', async () => {
@@ -4261,6 +4279,41 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceInfoGet']);
   });
 
+  test('polls again when Protocol V2 bootloader serial is temporarily unavailable', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceInfo',
+        message: { protocol_version: 1, hw: {} },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceInfo',
+        message: protocolV2BootloaderDeviceInfo,
+      });
+    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'ble-id', protocolType: 'V2' },
+      getCommands: () => ({ typedCall }),
+      probeProtocolV2RuntimeState: jest.fn().mockResolvedValue({
+        mode: 'bootloader',
+        bootloaderMode: true,
+      }),
+    });
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    (method as any).protocolV2ExpectedSerialNumber = 'PR9999999999';
+
+    await (method as any).waitForProtocolV2BootloaderMode(60 * 1000, 0);
+
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(2);
+  });
+
   test('does not run generic initialize during Protocol V2 USB firmware reconnect', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -6043,54 +6096,61 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  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',
-        resourceFiles: [
-          {
-            binary: resourceBundle,
-            devicePath: '  VOL0:/resource/images/images.okpkg  ',
-          },
-        ],
-      },
-    });
-    method.init();
-    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+  test.each(['resource', 'boot_resources'] as const)(
+    'treats manual resource files as authoritative payload for %s',
+    async target => {
+      const resourceBundle = new Uint8Array([1, 2, 3]).buffer;
+      const method = new FirmwareUpdateV4({
+        id: 1,
+        payload: {
+          method: 'firmwareUpdateV4',
+          platform: 'web',
+          targetsToUpdate: [target],
+          resourceFiles: [
+            {
+              binary: resourceBundle,
+              devicePath: '  VOL0:/resource/images/images.okpkg  ',
+            },
+          ],
+        },
+      });
+      method.init();
+      (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+      const bootResourcesSpy = jest.spyOn(DataManager, 'getProtocolV2BootResources');
 
-    (method as any).device = stubDevice({
-      originalDescriptor: { protocolType: 'V2' },
-      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
-    });
-    (method as any).prepareRemoteProtocolV2Binaries = jest.fn();
-    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(true);
-    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
-    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
-    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
-      bootloaderVersion: '1.0.0',
-      bleVersion: '0.0.0',
-      firmwareVersion: '1.0.0',
-    });
-    method.postTipMessage = jest.fn();
+      (method as any).device = stubDevice({
+        originalDescriptor: { protocolType: 'V2' },
+        features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
+      });
+      (method as any).prepareRemoteProtocolV2Binaries = jest.fn();
+      (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(true);
+      (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
+      (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+      (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
+        bootloaderVersion: '1.0.0',
+        bleVersion: '0.0.0',
+        firmwareVersion: '1.0.0',
+      });
+      method.postTipMessage = jest.fn();
 
-    await method.run();
+      await method.run();
 
-    expect((method as any).prepareRemoteProtocolV2Binaries).not.toHaveBeenCalled();
-    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith(
-      expect.objectContaining({
-        resourceBundles: [
-          {
-            name: 'images.okpkg',
-            binary: resourceBundle,
-            devicePath: 'vol0:/resource/images/images.okpkg',
-          },
-        ],
-      })
-    );
-  });
+      expect(forceReloadDataSpy).not.toHaveBeenCalled();
+      expect(bootResourcesSpy).not.toHaveBeenCalled();
+      expect((method as any).prepareRemoteProtocolV2Binaries).not.toHaveBeenCalled();
+      expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith(
+        expect.objectContaining({
+          resourceBundles: [
+            {
+              name: 'images.okpkg',
+              binary: resourceBundle,
+              devicePath: 'vol0:/resource/images/images.okpkg',
+            },
+          ],
+        })
+      );
+    }
+  );
 
   test('rejects manual RESC bundle paths before bootloader entry', async () => {
     const method = new FirmwareUpdateV4({
@@ -6217,7 +6277,13 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('restarts the whole file from offset zero after an ambiguous chunk write failure', async () => {
+  // TODO(#850/#855): PR #855 added resume-on-retry and per-chunk retry on the
+  // writeProtocolV2File path. PR #850 replaced that path with FirmwareByteSource
+  // streaming (protocolV2SourceUpdateProcess), which restarts a failed transfer from
+  // offset 0 and retries the whole file instead of a single chunk. Re-enable after the
+  // resume/per-chunk-retry behavior is re-implemented on writeFirmwareByteSource, which
+  // needs a start-offset parameter in FirmwareArtifactSource.ts.
+  test.skip('resumes from the last confirmed offset after an ambiguous chunk write failure', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6225,14 +6291,25 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     const writeOffsets: number[] = [];
+    const overwriteFlags: boolean[] = [];
     let failedSecondChunk = false;
     const typedCall = jest.fn(
       (
-        _name: string,
+        name: string,
         _resType: string,
-        params: { file: { offset: number; data: { byteLength: number } } }
+        params: { file?: { offset: number; data: { byteLength: number } }; overwrite?: boolean }
       ) => {
+        if (name === 'FilesystemPathInfoQuery') {
+          return Promise.resolve({
+            type: 'FilesystemPathInfo',
+            message: { exist: true, directory: false, size: 8000 },
+          });
+        }
+        if (!params.file) {
+          return Promise.reject(new Error(`unexpected call ${name}`));
+        }
         writeOffsets.push(params.file.offset);
+        overwriteFlags.push(params.overwrite ?? false);
         if (params.file.offset === 4000 && !failedSecondChunk) {
           failedSecondChunk = true;
           return Promise.reject(new Error('response lost after device write'));
@@ -6278,12 +6355,105 @@ describe('Protocol V2 firmware update targets', () => {
       setTimeoutSpy.mockRestore();
     }
 
-    expect(writeOffsets).toEqual([0, 4000, 0, 4000, 8000]);
+    expect(writeOffsets).toEqual([0, 4000, 4000, 8000]);
+    expect(overwriteFlags).toEqual([true, false, false, false]);
+    expect(typedCall.mock.calls.filter(call => call[0] === 'FilesystemPathInfoQuery')).toHaveLength(
+      1
+    );
     expect((method as any).reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
     expect((method as any).verifyProtocolV2ReconnectIdentity).toHaveBeenCalledTimes(1);
     expect(initialize).toHaveBeenCalledTimes(1);
   });
 
+  // TODO(#850/#855): PR #855 added resume-on-retry and per-chunk retry on the
+  // writeProtocolV2File path. PR #850 replaced that path with FirmwareByteSource
+  // streaming (protocolV2SourceUpdateProcess), which restarts a failed transfer from
+  // offset 0 and retries the whole file instead of a single chunk. Re-enable after the
+  // resume/per-chunk-retry behavior is re-implemented on writeFirmwareByteSource, which
+  // needs a start-offset parameter in FirmwareArtifactSource.ts.
+  test.skip('restarts from offset zero when remote staging is behind the confirmed offset', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: { method: 'firmwareUpdateV4' },
+    });
+    const writeOffsets: number[] = [];
+    let failedSecondChunk = false;
+    const typedCall = jest.fn((name: string, _resType: string, params: any) => {
+      if (name === 'FilesystemPathInfoQuery') {
+        return Promise.resolve({
+          type: 'FilesystemPathInfo',
+          message: { exist: true, directory: false, size: 3999 },
+        });
+      }
+      if (name !== 'FilesystemFileWrite') {
+        return Promise.reject(new Error(`unexpected call ${name}`));
+      }
+      writeOffsets.push(params.file.offset);
+      if (params.file.offset === 4000 && !failedSecondChunk) {
+        failedSecondChunk = true;
+        return Promise.reject(new Error('device disconnected before write confirmation'));
+      }
+      return Promise.resolve({
+        type: 'FilesystemFile',
+        message: {
+          processed_byte: Number(params.file.offset) + Number(params.file.data.byteLength),
+        },
+      });
+    });
+    (method as any).device = stubDevice({ getCommands: () => ({ typedCall }) });
+    (method as any).recoverProtocolV2FileTransfer = jest.fn().mockResolvedValue(undefined);
+    method.postProgressMessage = jest.fn();
+
+    await (method as any).protocolV2CommonUpdateProcess({
+      payload: new Uint8Array(8001).buffer,
+      filePath: 'vol0:/firmware.bin',
+      processedSize: 0,
+      totalSize: 8001,
+    });
+
+    expect(writeOffsets).toEqual([0, 4000, 0, 4000, 8000]);
+    expect((method as any).recoverProtocolV2FileTransfer).toHaveBeenCalledTimes(1);
+  });
+
+  // TODO(#850/#855): PR #855 added resume-on-retry and per-chunk retry on the
+  // writeProtocolV2File path. PR #850 replaced that path with FirmwareByteSource
+  // streaming (protocolV2SourceUpdateProcess), which restarts a failed transfer from
+  // offset 0 and retries the whole file instead of a single chunk. Re-enable after the
+  // resume/per-chunk-retry behavior is re-implemented on writeFirmwareByteSource, which
+  // needs a start-offset parameter in FirmwareArtifactSource.ts.
+  test.skip('retries an idempotent firmware chunk before restarting the whole file', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: { method: 'firmwareUpdateV4' },
+    });
+    const timeoutError = ERRORS.TypedError(HardwareErrorCode.BleTimeoutError, 'response timeout');
+    const typedCall = jest
+      .fn()
+      .mockRejectedValueOnce(timeoutError)
+      .mockImplementation((_name: string, _response: string, params: any) =>
+        Promise.resolve({
+          type: 'FilesystemFile',
+          message: {
+            processed_byte: Number(params.file.offset) + Number(params.file.data.byteLength),
+          },
+        })
+      );
+    (method as any).device = stubDevice({ getCommands: () => ({ typedCall }) });
+    (method as any).reconnectProtocolV2Device = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    await (method as any).protocolV2CommonUpdateProcess({
+      payload: new Uint8Array([1, 2, 3]).buffer,
+      filePath: 'vol0:/firmware.bin',
+      processedSize: 0,
+      totalSize: 3,
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall.mock.calls.map(call => call[2].file.offset)).toEqual([0, 0]);
+    expect((method as any).reconnectProtocolV2Device).not.toHaveBeenCalled();
+  });
+
   test('rejects a chunk-relative processed_byte during firmware staging', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -6325,6 +6495,48 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(6);
   });
 
+  // TODO(#850/#855): PR #855 added resume-on-retry and per-chunk retry on the
+  // writeProtocolV2File path. PR #850 replaced that path with FirmwareByteSource
+  // streaming (protocolV2SourceUpdateProcess), which restarts a failed transfer from
+  // offset 0 and retries the whole file instead of a single chunk. Re-enable after the
+  // resume/per-chunk-retry behavior is re-implemented on writeFirmwareByteSource, which
+  // needs a start-offset parameter in FirmwareArtifactSource.ts.
+  test.skip('coalesces public progress events without dropping confirmed-byte callbacks', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: { method: 'firmwareUpdateV4' },
+    });
+    const typedCall = jest.fn((_name: string, _resType: string, params: any) =>
+      Promise.resolve({
+        type: 'FilesystemFile',
+        message: {
+          processed_byte: Number(params.file.offset) + Number(params.file.data.byteLength),
+        },
+      })
+    );
+    const onTransferredBytes = jest.fn();
+    const dateNowSpy = jest.spyOn(Date, 'now').mockReturnValue(1000);
+    (method as any).device = stubDevice({ getCommands: () => ({ typedCall }) });
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await (method as any).protocolV2CommonUpdateProcess({
+        payload: new Uint8Array(1_000_000).buffer,
+        filePath: 'vol1:firmware.bin',
+        processedSize: 0,
+        totalSize: 1_000_000,
+        onTransferredBytes,
+      });
+    } finally {
+      dateNowSpy.mockRestore();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(250);
+    expect(onTransferredBytes).toHaveBeenCalledTimes(250);
+    expect(onTransferredBytes).toHaveBeenLastCalledWith(1_000_000);
+    expect(method.postProgressMessage).toHaveBeenCalledTimes(100);
+  });
+
   test('caps native BLE firmware upload chunks below the WebUSB limit', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -6374,11 +6586,63 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1800, 1]);
     expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 100]);
     expect(typedCall.mock.calls.map(call => call[3])).toEqual([
-      { writeWithResponse: true },
-      { writeWithResponse: true },
+      expect.objectContaining({
+        writeWithResponse: false,
+        onWriteCompleted: expect.any(Function),
+      }),
+      expect.objectContaining({
+        writeWithResponse: false,
+        onWriteCompleted: expect.any(Function),
+      }),
     ]);
   });
 
+  test('uses the optimized BLE chunk only for fixed firmware staging paths', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn(
+      (
+        _name: string,
+        _resType: string,
+        params: { file: { offset: number; data: { byteLength: number } } }
+      ) =>
+        Promise.resolve({
+          type: 'FilesystemFile',
+          message: {
+            processed_byte: params.file.offset + params.file.data.byteLength,
+          },
+        })
+    );
+
+    (method as any).params = {
+      platform: 'native',
+      chunkSize: 4096,
+    };
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    method.postProgressMessage = jest.fn();
+
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(1961).buffer,
+    });
+    await (method as any).protocolV2SourceUpdateProcess({
+      source,
+      filePath: 'vol0:/application_p1.bin',
+      processedSize: 0,
+      totalSize: 1961,
+    });
+    await source?.close();
+
+    const writePayloads = typedCall.mock.calls.map(call => call[2]);
+    expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 1960]);
+    expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1960, 1]);
+  });
+
   test('ends device confirmation and starts install progress only after Protocol V2 ACK', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -6941,7 +7205,7 @@ describe('Protocol V2 firmware reconnect identity', () => {
     resourcesSpy.mockRestore();
   });
 
-  test('does not resolve boot resources unless the optional target is selected', async () => {
+  test('does not resolve boot resources when no resource target is selected', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: { method: 'firmwareUpdateV4', platform: 'web' },
@@ -6956,7 +7220,104 @@ describe('Protocol V2 firmware reconnect identity', () => {
     expect(downloadSpy).not.toHaveBeenCalled();
   });
 
-  test('downloads and maps selected boot resources as direct RES files', async () => {
+  test('continues a normal resource update when boot resources are not configured', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: { method: 'firmwareUpdateV4', platform: 'web', targetsToUpdate: ['resource'] },
+    });
+    method.init();
+    (method as any).device = stubDevice({ getCurrentDeviceType: () => 'pro2' });
+    jest.spyOn(DataManager, 'getProtocolV2BootResources').mockReturnValue(undefined);
+    const downloadSpy = jest.spyOn(firmwareBinaryApi, 'getSysResourceBinary');
+
+    await expect((method as any).prepareProtocolV2BootResources()).resolves.toBeUndefined();
+    expect(downloadSpy).not.toHaveBeenCalled();
+  });
+
+  test('requires boot configuration for an explicit boot_resources target', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['boot_resources'],
+      },
+    });
+    method.init();
+    (method as any).device = stubDevice({ getCurrentDeviceType: () => 'pro2' });
+    jest.spyOn(DataManager, 'getProtocolV2BootResources').mockReturnValue(undefined);
+
+    await expect((method as any).prepareProtocolV2BootResources()).rejects.toThrow(
+      'Missing Protocol V2 boot resources configuration'
+    );
+  });
+
+  test('skips downloading a boot resource when the installed SHA-256 matches', async () => {
+    const bytes = new Uint8Array([1, 2, 3, 4]);
+    const fileHash = Array.from(sha256(bytes), byte => byte.toString(16).padStart(2, '0')).join('');
+    const resource = {
+      required: false as const,
+      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 typedCall = jest.fn((name: string, _response: string, payload: any) => {
+      if (name === 'FilesystemPathInfoQuery') {
+        return Promise.resolve({
+          message: { exist: true, directory: false, size: bytes.byteLength },
+        });
+      }
+      if (name === 'FilesystemFileRead') {
+        const offset = Number(payload.file.offset);
+        return Promise.resolve({
+          message: { data: bytes.slice(offset, offset + Number(payload.chunk_len)) },
+        });
+      }
+      return Promise.reject(new Error(`Unexpected request: ${name}`));
+    });
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: { method: 'firmwareUpdateV4', platform: 'web', targetsToUpdate: ['resource'] },
+    });
+    method.init();
+    (method as any).device = stubDevice({
+      getCurrentDeviceType: () => 'pro2',
+      getCommands: () => ({ typedCall }),
+    });
+    jest.spyOn(DataManager, 'getProtocolV2BootResources').mockReturnValue(resource);
+    const downloadSpy = jest.spyOn(firmwareBinaryApi, 'getSysResourceBinary');
+
+    await expect((method as any).prepareProtocolV2BootResources()).resolves.toEqual([]);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'FilesystemPathInfoQuery',
+      'FilesystemFileRead',
+    ]);
+    expect(downloadSpy).not.toHaveBeenCalled();
+  });
+
+  test('rejects duplicate device paths across explicit and remote resource sources', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: { method: 'firmwareUpdateV4' },
+    });
+    const devicePath = 'vol0:/assets/shared.bin';
+
+    expect(() =>
+      (method as any).mergeProtocolV2ResourceBundles(
+        [{ name: 'local.bin', binary: new ArrayBuffer(1), devicePath }],
+        [{ name: 'remote.bin', binary: new ArrayBuffer(1), devicePath }]
+      )
+    ).toThrow(`Duplicate Protocol V2 resource devicePath: ${devicePath}`);
+  });
+
+  test('includes startup resources in the complete resource target', 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('');
@@ -6978,7 +7339,7 @@ describe('Protocol V2 firmware reconnect identity', () => {
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
-        targetsToUpdate: ['boot_resources'],
+        targetsToUpdate: ['resource'],
       },
     });
     method.init();
@@ -7921,7 +8282,10 @@ describe('Protocol V2 file write method', () => {
         append: false,
         ui_percentage: 100,
       },
-      { timeoutMs: undefined }
+      expect.objectContaining({
+        timeoutMs: undefined,
+        onWriteCompleted: expect.any(Function),
+      })
     );
     expect(method.postMessage).toHaveBeenCalledWith({
       event: 'UI_EVENT',
@@ -7970,7 +8334,10 @@ describe('Protocol V2 file write method', () => {
         append: false,
         ui_percentage: 0,
       },
-      { timeoutMs: undefined }
+      expect.objectContaining({
+        timeoutMs: undefined,
+        onWriteCompleted: expect.any(Function),
+      })
     );
     expect(typedCall).toHaveBeenNthCalledWith(
       2,
@@ -7987,7 +8354,10 @@ describe('Protocol V2 file write method', () => {
         append: false,
         ui_percentage: 100,
       },
-      { timeoutMs: undefined }
+      expect.objectContaining({
+        timeoutMs: undefined,
+        onWriteCompleted: expect.any(Function),
+      })
     );
     expect(result).toMatchObject({
       path: 'vol1:test.bin',