@onekeyfe/hd-core 1.2.0-alpha.140 → 1.2.0-alpha.142

package/__tests__/device-lifecycle-events.test.ts

@@ -128,7 +128,7 @@ describe('public device lifecycle events', () => {
 
     await device.acquire();
 
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V1', undefined);
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V1', undefined, undefined);
     expect(device.getProtocol()).toBe('V1');
     expect(device.originalDescriptor.protocolType).toBe('V1');
   });
@@ -146,7 +146,9 @@ describe('public device lifecycle events', () => {
 
     await device.acquire(undefined, { forceProtocolDetection: true });
 
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, undefined);
+    // Explicit active detection forwards forceProtocolDetection so the
+    // transport bypasses its protocol cache.
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, undefined, true);
     expect(device.getProtocol()).toBe('V2');
     expect(device.originalDescriptor.protocolType).toBe('V2');
   });
@@ -247,7 +249,7 @@ describe('public device lifecycle events', () => {
 
     await device.acquire('V2');
 
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V2', undefined);
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V2', undefined, undefined);
     expect(device.getProtocol()).toBe('V2');
   });
 

package/__tests__/device-wallet-session-store.test.ts

@@ -352,7 +352,75 @@ describe('Protocol V1 wallet identity initialization', () => {
     jest.restoreAllMocks();
   });
 
-  test('verifies the live device id without resetting the cached wallet session', async () => {
+  test('sends no wallet context before identity is proven on first contact', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    // No cached features: there is no local evidence which device sits here.
+    deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'intruder-device', session_id: 'intruder-session' },
+    });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await expect(
+      device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+
+    // Exactly one context-free Initialize: neither the cached session_id nor
+    // the passphrase_state may reach an unproven device.
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      { is_contains_attach: true },
+      expect.any(Object)
+    );
+    // The expected device's cached session is untouched.
+    expect(deviceWalletSessionStore.get('device-a', 'hidden-a')).toBe('session-a');
+  });
+
+  test('proves identity first, then resumes the wallet session on first contact', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'Features',
+        message: { device_id: 'device-a', session_id: 'standard-session' },
+      })
+      .mockResolvedValueOnce({
+        type: 'Features',
+        message: { device_id: 'device-a', session_id: 'session-a' },
+      });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'Initialize',
+      'Features',
+      { is_contains_attach: true },
+      expect.any(Object)
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'Initialize',
+      'Features',
+      expect.objectContaining({
+        session_id: 'session-a',
+        passphrase_state: 'hidden-a',
+      }),
+      expect.any(Object)
+    );
+    // The context-free identity call must not overwrite the cached session.
+    expect(deviceWalletSessionStore.get('device-a', 'hidden-a')).toBe('session-a');
+  });
+
+  test('purges cached sessions and rejects when the live device identity changes', async () => {
     const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
     device.features = {
       protocol: 'V1',
@@ -363,7 +431,7 @@ describe('Protocol V1 wallet identity initialization', () => {
     deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
     const typedCall = jest.fn().mockResolvedValue({
       type: 'Features',
-      message: { device_id: 'live-device-b' },
+      message: { device_id: 'live-device-b', session_id: 'wrong-device-session' },
     });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
@@ -371,11 +439,76 @@ describe('Protocol V1 wallet identity initialization', () => {
     await expect(
       device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+    // Identity is validated from the single Initialize round trip; no separate
+    // GetFeatures preflight.
     expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith('GetFeatures', 'Features', {});
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      expect.objectContaining({ passphrase_state: 'hidden-a' }),
+      expect.any(Object)
+    );
+    // Identity change purges the previous device's cached sessions (pre-existing
+    // reconcileDeviceIdentity behavior — never carry sessions across devices)…
+    expect(deviceWalletSessionStore.get('cached-device-a', 'hidden-a')).toBeUndefined();
+    // …and the session the mismatched Initialize cached under the wrong
+    // device's identity is dropped as well.
+    expect(deviceWalletSessionStore.get('live-device-b', 'hidden-a')).toBeUndefined();
   });
 
-  test('resumes a cached V1 wallet after a non-destructive live identity read', async () => {
+  test('drops the wrong-device session even when reconfigure fails after Initialize', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'cached-device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'live-device-b', session_id: 'wrong-device-session' },
+    });
+    device.commands = { typedCall } as never;
+    // Pre-encode resync succeeds; the post-response reconfigure inside
+    // callInitialize rejects — the session write has already happened by then.
+    jest
+      .spyOn(TransportManager, 'reconfigure')
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new Error('configure failed'));
+
+    await expect(
+      device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+    // The wrong-device session must not survive the error path either.
+    expect(deviceWalletSessionStore.get('live-device-b', 'hidden-a')).toBeUndefined();
+  });
+
+  test('re-syncs the V1 message schema for this device before encoding Initialize', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'device-a' },
+    });
+    device.commands = { typedCall } as never;
+    const reconfigure = jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
+
+    // A stale process-global schema (from another device) would silently strip
+    // passphrase_state from the wire message, so the resync must come first.
+    expect(reconfigure.mock.invocationCallOrder[0]).toBeLessThan(
+      typedCall.mock.invocationCallOrder[0]
+    );
+  });
+
+  test('resumes a cached V1 wallet with a single identity-validated Initialize', async () => {
     const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
     device.features = {
       protocol: 'V1',
@@ -384,22 +517,17 @@ describe('Protocol V1 wallet identity initialization', () => {
       passphraseProtection: true,
     } as never;
     deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
-      .mockResolvedValueOnce({
-        type: 'Features',
-        message: { device_id: 'device-a', session_id: 'session-a' },
-      });
+    const typedCall = jest.fn().mockResolvedValueOnce({
+      type: 'Features',
+      message: { device_id: 'device-a', session_id: 'session-a' },
+    });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
 
     await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
 
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
-    expect(typedCall).toHaveBeenNthCalledWith(
-      2,
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
       'Initialize',
       'Features',
       expect.objectContaining({
@@ -408,9 +536,10 @@ describe('Protocol V1 wallet identity initialization', () => {
       }),
       expect.any(Object)
     );
+    expect(deviceWalletSessionStore.get('device-a', 'hidden-a')).toBe('session-a');
   });
 
-  test('selects the standard V1 wallet after a non-destructive live identity read', async () => {
+  test('selects the standard V1 wallet with a single identity-validated Initialize', async () => {
     const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
     device.features = {
       protocol: 'V1',
@@ -420,17 +549,14 @@ describe('Protocol V1 wallet identity initialization', () => {
     } as never;
     const typedCall = jest
       .fn()
-      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
       .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
 
     await device.initialize({ deviceId: 'device-a' });
 
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
-    expect(typedCall).toHaveBeenNthCalledWith(
-      2,
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
       'Initialize',
       'Features',
       {

package/__tests__/protocol-v2.test.ts

@@ -5200,6 +5200,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000, {
       forceRuntimeContextRefresh: true,
     });
+    expect((method as any).protocolV2LatestFinalDeviceInfo).toBe(deviceInfo);
   });
 
   test('reboots Protocol V2 firmware flow back to normal without legacy switch-firmware prompt', async () => {
@@ -5708,7 +5709,7 @@ describe('Protocol V2 firmware update targets', () => {
       ])
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.FirmwareError,
-      message: 'Firmware installation failed',
+      message: 'Protocol V2 firmware install timed out',
       params: { firmwareUpdateCode: 'FirmwareInstallTimeout' },
     });
 
@@ -5716,11 +5717,16 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(5);
   });
 
-  test('accepts ACK-less normal mode after the requested target version changes', async () => {
+  test('preserves multi-app completion evidence when App mode replaces the status endpoint', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
+        targetsToUpdate: ['app_v1', 'app_v2'],
+        expectedTargetVersions: {
+          app_v1: '2.0.0',
+          app_v2: '2.0.0',
+        },
       },
     });
     const typedCall = jest
@@ -5737,7 +5743,10 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => ({ typedCall }),
       probeProtocolV2RuntimeState,
     });
-    (method as any).protocolV2InstallBaselineVersions = new Map([[4, '1.0.0']]);
+    (method as any).protocolV2InstallBaselineVersions = new Map([
+      [4, '1.0.0'],
+      [5, '1.0.0'],
+    ]);
     (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
     (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
     method.postProgressMessage = jest.fn();
@@ -5745,11 +5754,69 @@ describe('Protocol V2 firmware update targets', () => {
     await expect(
       (method as any).waitForProtocolV2FirmwareUpdateComplete([
         { target_id: 4, path: 'vol0:/application_p1.bin' },
+        { target_id: 5, path: 'vol0:/application_p2.bin' },
       ])
     ).resolves.toBeUndefined();
 
     expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000);
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+    expect(Array.from((method as any).protocolV2CompletedTargetIds)).toEqual([4, 5]);
+
+    (method as any).protocolV2LatestFinalFeatures = {
+      firmwareVersion: '2.0.0',
+    };
+    (method as any).protocolV2LatestFinalDeviceInfo = {
+      main_mcu: {
+        application: { version: '2.0.0' },
+      },
+    };
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
+  });
+
+  test('preserves all target completion evidence when status records disappear after reboot', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Success', message: {} })
+      .mockRejectedValueOnce(new Error('Pro2 is rebooting'))
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [] },
+      });
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await expect(
+        (method as any).waitForProtocolV2FirmwareUpdateComplete([
+          { target_id: 4, path: 'vol0:/application_p1.bin' },
+          { target_id: 5, path: 'vol0:/application_p2.bin' },
+        ])
+      ).resolves.toBeUndefined();
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(Array.from((method as any).protocolV2CompletedTargetIds)).toEqual([4, 5]);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
   test.each([
@@ -5931,7 +5998,7 @@ describe('Protocol V2 firmware update targets', () => {
         ])
       ).rejects.toMatchObject({
         errorCode: HardwareErrorCode.FirmwareError,
-        message: 'Firmware installation failed',
+        message: 'Protocol V2 firmware install status conflict',
         params: {
           firmwareUpdateCode: 'FirmwareInstallStatusConflict',
         },
@@ -5944,7 +6011,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(1);
   });
 
-  test('does not fail a completed multi-app install when final app versions are unobservable', () => {
+  test('uses the device firmware version for P1 and install completion for unobservable P2', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5952,7 +6019,7 @@ describe('Protocol V2 firmware update targets', () => {
         platform: 'desktop',
         targetsToUpdate: ['app_v1', 'app_v2'],
         expectedTargetVersions: {
-          app_v1: '1.0.0',
+          app_v1: '3.0.0',
           app_v2: '2.0.0',
         },
       },
@@ -5968,7 +6035,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
   });
 
-  test('rejects unobservable multi-app versions without per-target completion evidence', () => {
+  test('uses the firmware version for P1 and the optional DeviceInfo version for P2', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5982,6 +6049,66 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     method.init();
+    (method as any).protocolV2LatestFinalFeatures = {
+      major_version: 1,
+      minor_version: 0,
+      patch_version: 0,
+    };
+    (method as any).protocolV2LatestFinalDeviceInfo = {
+      main_mcu: {
+        application: { version: '9.9.9' },
+        application_data: { version: '2.0.0' },
+      },
+    };
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
+  });
+
+  test('rejects a mismatched final DeviceInfo application slot version', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        targetsToUpdate: ['app_v1', 'app_v2'],
+        expectedTargetVersions: {
+          app_v1: '1.0.0',
+          app_v2: '2.0.0',
+        },
+      },
+    });
+    method.init();
+    (method as any).protocolV2LatestFinalFeatures = {
+      major_version: 1,
+      minor_version: 0,
+      patch_version: 0,
+    };
+    (method as any).protocolV2LatestFinalDeviceInfo = {
+      main_mcu: {
+        application: { version: '1.0.0' },
+        application_data: { version: '2.0.1' },
+      },
+    };
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).toThrow(
+      'target app_v2 reached 2.0.1, expected 2.0.0'
+    );
+  });
+
+  test('rejects an unobservable P2 version without P2 completion evidence', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        targetsToUpdate: ['app_v1', 'app_v2'],
+        expectedTargetVersions: {
+          app_v1: '3.0.0',
+          app_v2: '2.0.0',
+        },
+      },
+    });
+    method.init();
     (method as any).protocolV2LatestFinalFeatures = {
       major_version: 3,
       minor_version: 0,
@@ -5991,7 +6118,7 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).protocolV2CompletedTargetIds = new Set([4]);
 
     expect(() => (method as any).assertExpectedProtocolV2Versions()).toThrow(
-      'target app_v1 has no observable final version after status fallback'
+      'target app_v2 has no observable final version after status fallback'
     );
   });
 
@@ -6096,7 +6223,7 @@ describe('Protocol V2 firmware update targets', () => {
       ])
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.FirmwareError,
-      message: 'Firmware installation failed',
+      message: 'Protocol V2 firmware install timed out',
       params: { firmwareUpdateCode: 'FirmwareInstallTimeout' },
     });
     expect(typedCall).toHaveBeenCalledTimes(5);
@@ -6173,7 +6300,7 @@ describe('Protocol V2 firmware update targets', () => {
       ])
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.FirmwareError,
-      message: 'Firmware installation failed',
+      message: 'Protocol V2 firmware install timed out',
       params: { firmwareUpdateCode: 'FirmwareInstallTimeout' },
     });
   });
@@ -6253,7 +6380,7 @@ describe('Protocol V2 firmware update targets', () => {
         ],
         new Set([4, 10])
       )
-    ).toThrow('Firmware installation failed');
+    ).toThrow('Protocol V2 firmware install status conflict');
     expect(method.postProgressMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalledWith(100, 'installingFirmware');
 
@@ -6293,7 +6420,7 @@ describe('Protocol V2 firmware update targets', () => {
       throw new Error('Expected Protocol V2 failed firmware status to throw');
     } catch (error: any) {
       expect(error.errorCode).toBe(HardwareErrorCode.FirmwareError);
-      expect(error.message).toBe('Firmware installation failed');
+      expect(error.message).toBe('Protocol V2 firmware install failed');
       expect(error.params).toEqual({ firmwareUpdateCode: 'FirmwareInstallFailed' });
     }
   });
@@ -6331,7 +6458,7 @@ describe('Protocol V2 firmware update targets', () => {
       ])
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.FirmwareError,
-      message: 'Firmware installation failed',
+      message: 'Protocol V2 firmware install failed',
       params: { firmwareUpdateCode: 'FirmwareInstallFailed' },
     });
     expect(typedCall).toHaveBeenCalledWith(
@@ -6859,6 +6986,9 @@ describe('Protocol V2 firmware update targets', () => {
         method: 'firmwareUpdateV4',
         platform: 'web',
         targetsToUpdate: ['app_v1', 'coprocessor'],
+        expectedTargetVersions: {
+          app_v1: '9.9.9',
+        },
       },
     });
     method.init();
@@ -6877,12 +7007,14 @@ describe('Protocol V2 firmware update targets', () => {
           applicationP1: {
             target: 'APPLICATION_P1',
             url: 'https://example.com/applicationP1.pp.bin',
+            version: [2, 0, 0],
             expectedSize: explicitApplicationBinary.byteLength,
             fingerprint: bytesToHex(sha256(new Uint8Array(explicitApplicationBinary))),
           },
           coprocessor: {
             target: 'COPROCESSOR',
             url: 'https://example.com/coprocessor.pp.bin',
+            version: [1, 1, 0],
             expectedSize: remoteCoprocessorBinary.byteLength,
             fingerprint: bytesToHex(sha256(new Uint8Array(remoteCoprocessorBinary))),
           },
@@ -6923,6 +7055,10 @@ describe('Protocol V2 firmware update targets', () => {
         kind: 'firmware',
       },
     ]);
+    expect((method as any).params.expectedTargetVersions).toEqual({
+      app_v1: '9.9.9',
+      coprocessor: '1.1.0',
+    });
 
     getSysResourceBinarySpy.mockRestore();
     getFirmwareLatestReleaseSpy.mockRestore();
@@ -8139,6 +8275,66 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
+  test('throttles repeated transfer progress while preserving file completion', 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).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      getCurrentDeviceType: () => 'pro2',
+    });
+    (method as any).getProtocolV2FirmwareChunkSize = jest.fn().mockReturnValue(1000);
+    method.postProgressMessage = jest.fn();
+    const dateNowSpy = jest.spyOn(Date, 'now').mockReturnValue(10_000);
+
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(2500).buffer,
+    });
+    try {
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
+        filePath: 'vol0:/resource/images/images.okpkg',
+        processedSize: 0,
+        totalSize: 1_000_000,
+      });
+    } finally {
+      dateNowSpy.mockRestore();
+      await source?.close();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(method.postProgressMessage).toHaveBeenCalledTimes(2);
+    expect(method.postProgressMessage).toHaveBeenNthCalledWith(
+      1,
+      1,
+      'transferData',
+      expect.objectContaining({ transferredBytes: 1000 })
+    );
+    expect(method.postProgressMessage).toHaveBeenNthCalledWith(
+      2,
+      1,
+      'transferData',
+      expect.objectContaining({ transferredBytes: 2500 })
+    );
+  });
+
   test('sends one monotonic device transfer progress range across multiple files', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,

package/dist/api/FirmwareUpdateV4.d.ts

@@ -15,8 +15,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     private protocolV2CompletedTargetVersions;
     private protocolV2CompletedTargetIds;
     private protocolV2LatestFinalFeatures?;
+    private protocolV2LatestFinalDeviceInfo?;
     private protocolV2InstallBaselineVersions;
     private protocolV2LastRuntimeProbeFeatures?;
+    private protocolV2LastTransferProgress?;
+    private protocolV2LastTransferProgressAt;
     init(): void;
     private getProtocolV2FirmwareChunkSize;
     run(): Promise<{
@@ -37,7 +40,6 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     private validateExpectedTargetVersions;
     private getExpectedProtocolV2TargetVersion;
     private assertExpectedProtocolV2Versions;
-    private getProtocolV2RequestedTargets;
     private getProtocolV2DeviceFeatures;
     private getProtocolV2SerialNumber;
     private getProtocolV2PreparedPlanDeviceModel;
@@ -76,6 +78,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     private getProtocolV2MissingTargetIds;
     private getProtocolV2ObservableTargetVersions;
     private hasProtocolV2InstallVersionChanged;
+    private recordProtocolV2AuthoritativeInstallCompletion;
     private waitForProtocolV2FirmwareUpdateComplete;
     private exitProtocolV2BootloaderToNormal;
     private probeProtocolV2NormalMode;

package/dist/api/FirmwareUpdateV4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkD,MAAM,qBAAqB,CAAC;AA0BlG,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAkC/E,OAAO,KAAK,EAEV,sBAAsB,EAEvB,MAAM,6BAA6B,CAAC;AAqFrC,wBAAgB,wCAAwC,CACtD,UAAU,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,EAC5C,MAAM,EAAE,sBAAsB,EAC9B,0BAA0B,UAAQ,QAiCnC;AAuVD,eAAO,MAAM,oCAAoC,WACvC,WAAW,GAAG,UAAU,eACnB,MAAM,GAAG,SAAS,YAKhC,CAAC;AAEF,eAAO,MAAM,iCAAiC,0BACrB,MAAM,uBACR,MAAM,iBACZ,MAAM,eACR,MAAM,SAsBpB,CAAC;AAUF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IAC5F,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,OAAO,CAAC,sBAAsB,CAAC,CAAS;IAExC,OAAO,CAAC,oCAAoC,CAAS;IAErD,qBAAqB;IAIrB,OAAO,CAAC,yBAAyB,CAA4B;IAE7D,OAAO,CAAC,2BAA2B,CAAS;IAE5C,OAAO,CAAC,iCAAiC,CAAS;IAElD,OAAO,CAAC,iCAAiC,CAA6B;IAEtE,OAAO,CAAC,4BAA4B,CAAqB;IAEzD,OAAO,CAAC,6BAA6B,CAAC,CAAW;IAEjD,OAAO,CAAC,iCAAiC,CAA6B;IAEtE,OAAO,CAAC,kCAAkC,CAAC,CAAW;IAEtD,IAAI;IA6LJ,OAAO,CAAC,8BAA8B;IAwBhC,GAAG;;;;;YAKK,aAAa;YAyJb,4BAA4B;YAkB5B,0BAA0B;YAY1B,8BAA8B;YAK9B,+BAA+B;YAqG/B,gCAAgC;YAiIhC,qCAAqC;YAmJrC,gCAAgC;YAgBhC,uCAAuC;YA+HvC,8BAA8B;IA8B5C,OAAO,CAAC,8BAA8B;IA0BtC,OAAO,CAAC,kCAAkC;IAc1C,OAAO,CAAC,gCAAgC;IA8DxC,OAAO,CAAC,6BAA6B;YAsBvB,2BAA2B;IAmBzC,OAAO,CAAC,yBAAyB;IAKjC,OAAO,CAAC,oCAAoC;IAY5C,OAAO,CAAC,4BAA4B;IAUpC,OAAO,CAAC,kCAAkC;IAS1C,OAAO,CAAC,8BAA8B;YAMxB,iCAAiC;YAOjC,iCAAiC;YAmBjC,iCAAiC;IAM/C,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,mCAAmC;IAe3C,OAAO,CAAC,iCAAiC;IAWzC,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,yBAAyB;IAiBjC,OAAO,CAAC,wBAAwB;YAkBlB,iCAAiC;YA6CjC,uCAAuC;YA0CvC,+BAA+B;IAiF7C,OAAO,CAAC,6BAA6B;YAMvB,8BAA8B;YA+C9B,kCAAkC;IA+BhD,OAAO,CAAC,0BAA0B;IAUlC,OAAO,CAAC,yBAAyB;YAcnB,4BAA4B;IAkBpC,6BAA6B;YAkBrB,+BAA+B;IAkD7C,OAAO,CAAC,6BAA6B;YAkCvB,6BAA6B;YA0B7B,0CAA0C;YA6B1C,uBAAuB;YAiCvB,8BAA8B;YA0E9B,6BAA6B;IAuE3C,OAAO,CAAC,mCAAmC;YAI7B,0BAA0B;IAaxC,OAAO,CAAC,4BAA4B;IAkGpC,OAAO,CAAC,6BAA6B;IAcrC,OAAO,CAAC,qCAAqC;IAyB7C,OAAO,CAAC,kCAAkC;YAgB5B,uCAAuC;YA2MvC,gCAAgC;YAehC,yBAAyB;IASvC,OAAO,CAAC,2BAA2B;YAMrB,8BAA8B;IAQ5C,OAAO,CAAC,0BAA0B;YAkBpB,mCAAmC;YAWnC,qCAAqC;YAiDrC,yBAAyB;YA8DzB,8BAA8B;IAU5C,OAAO,CAAC,kCAAkC;YAQ5B,cAAc;YAuCd,6BAA6B;YAW7B,0BAA0B;YAS1B,6BAA6B;YAwB7B,gBAAgB;IAiB9B,OAAO,CAAC,qBAAqB;CAM9B"}
+{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkD,MAAM,qBAAqB,CAAC;AA0BlG,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAkC/E,OAAO,KAAK,EAEV,sBAAsB,EAEvB,MAAM,6BAA6B,CAAC;AAsFrC,wBAAgB,wCAAwC,CACtD,UAAU,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,EAC5C,MAAM,EAAE,sBAAsB,EAC9B,0BAA0B,UAAQ,QAiCnC;AAuVD,eAAO,MAAM,oCAAoC,WACvC,WAAW,GAAG,UAAU,eACnB,MAAM,GAAG,SAAS,YAKhC,CAAC;AAEF,eAAO,MAAM,iCAAiC,0BACrB,MAAM,uBACR,MAAM,iBACZ,MAAM,eACR,MAAM,SAsBpB,CAAC;AAUF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IAC5F,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,OAAO,CAAC,sBAAsB,CAAC,CAAS;IAExC,OAAO,CAAC,oCAAoC,CAAS;IAErD,qBAAqB;IAIrB,OAAO,CAAC,yBAAyB,CAA4B;IAE7D,OAAO,CAAC,2BAA2B,CAAS;IAE5C,OAAO,CAAC,iCAAiC,CAAS;IAElD,OAAO,CAAC,iCAAiC,CAA6B;IAEtE,OAAO,CAAC,4BAA4B,CAAqB;IAEzD,OAAO,CAAC,6BAA6B,CAAC,CAAW;IAEjD,OAAO,CAAC,+BAA+B,CAAC,CAAuB;IAE/D,OAAO,CAAC,iCAAiC,CAA6B;IAEtE,OAAO,CAAC,kCAAkC,CAAC,CAAW;IAEtD,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,OAAO,CAAC,gCAAgC,CAAK;IAE7C,IAAI;IA6LJ,OAAO,CAAC,8BAA8B;IAwBhC,GAAG;;;;;YAKK,aAAa;YAyJb,4BAA4B;YAkB5B,0BAA0B;YAY1B,8BAA8B;YAK9B,+BAA+B;YAqG/B,gCAAgC;YAiIhC,qCAAqC;YAmJrC,gCAAgC;YAgBhC,uCAAuC;YA+HvC,8BAA8B;IA8B5C,OAAO,CAAC,8BAA8B;IA0BtC,OAAO,CAAC,kCAAkC;IAc1C,OAAO,CAAC,gCAAgC;YAuD1B,2BAA2B;IAmBzC,OAAO,CAAC,yBAAyB;IAKjC,OAAO,CAAC,oCAAoC;IAY5C,OAAO,CAAC,4BAA4B;IAUpC,OAAO,CAAC,kCAAkC;IAS1C,OAAO,CAAC,8BAA8B;YAMxB,iCAAiC;YAOjC,iCAAiC;YAmBjC,iCAAiC;IAM/C,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,mCAAmC;IAe3C,OAAO,CAAC,iCAAiC;IAWzC,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,yBAAyB;IAiBjC,OAAO,CAAC,wBAAwB;YAkBlB,iCAAiC;YA6CjC,uCAAuC;YA0CvC,+BAA+B;IAmF7C,OAAO,CAAC,6BAA6B;YAMvB,8BAA8B;YA+C9B,kCAAkC;IA+BhD,OAAO,CAAC,0BAA0B;IAUlC,OAAO,CAAC,yBAAyB;YAcnB,4BAA4B;IAkBpC,6BAA6B;YAkBrB,+BAA+B;IAkD7C,OAAO,CAAC,6BAA6B;YAkCvB,6BAA6B;YA0B7B,0CAA0C;YA6B1C,uBAAuB;YAiCvB,8BAA8B;YA4E9B,6BAA6B;IA8E3C,OAAO,CAAC,mCAAmC;YAI7B,0BAA0B;IAaxC,OAAO,CAAC,4BAA4B;IA0GpC,OAAO,CAAC,6BAA6B;IAcrC,OAAO,CAAC,qCAAqC;IAyB7C,OAAO,CAAC,kCAAkC;IAgB1C,OAAO,CAAC,8CAA8C;YAIxC,uCAAuC;YAiNvC,gCAAgC;YAehC,yBAAyB;IASvC,OAAO,CAAC,2BAA2B;YAMrB,8BAA8B;IAQ5C,OAAO,CAAC,0BAA0B;YAkBpB,mCAAmC;YAWnC,qCAAqC;YAmDrC,yBAAyB;YA8DzB,8BAA8B;IAU5C,OAAO,CAAC,kCAAkC;YAQ5B,cAAc;YAuCd,6BAA6B;YAW7B,0BAA0B;YAS1B,6BAA6B;YAwB7B,gBAAgB;IAiB9B,OAAO,CAAC,qBAAqB;CAM9B"}