@onekeyfe/hd-core 1.2.0-alpha.112 → 1.2.0-alpha.113

package/__tests__/protocol-v2.test.ts

@@ -613,7 +613,7 @@ const protocolV2BootloaderDeviceInfo: ProtocolV2DeviceInfo = {
   hw: {
     serial_no: 'PR9999999999',
   },
-  main_mcu: {
+  fw: {
     bootloader: {
       version: '0.0.1',
     },
@@ -677,7 +677,7 @@ describe('Protocol V2 feature adapter', () => {
     const deviceInfo: ProtocolV2DeviceInfo = {
       protocol_version: 1,
       hw: { serial_no: 'P2-STATIC' },
-      main_mcu: { application: { version: '1.0.0' } },
+      fw: { application: { version: '1.0.0' } },
       coprocessor: { bt_adv_name: 'Pro2 STATIC' },
     };
     const deviceStatus: DeviceStatus = {
@@ -751,7 +751,7 @@ describe('Protocol V2 feature adapter', () => {
         Device_type: DeviceType.PRO2,
         serial_no: 'PR2SERIAL',
       },
-      main_mcu: {
+      fw: {
         romloader: {
           version: '0.1.0',
           build_id: 'rom-build',
@@ -841,7 +841,7 @@ describe('Protocol V2 feature adapter', () => {
       hw: {
         serial_no: 'PR2BOOT',
       },
-      main_mcu: {
+      fw: {
         bootloader: {
           version: '0.2.0',
         },
@@ -863,7 +863,7 @@ describe('Protocol V2 feature adapter', () => {
     const features = normalizeProtocolV2Features(descriptor as any, {
       protocol_version: 1,
       hw: { serial_no: 'PR2NORMAL' },
-      main_mcu: { bootloader: { version: '0.2.0' } },
+      fw: { bootloader: { version: '0.2.0' } },
     });
 
     expect(features.mode).toBe('normal');
@@ -876,7 +876,7 @@ describe('Protocol V2 feature adapter', () => {
       hw: {
         serial_no: 'PR2ROM',
       },
-      main_mcu: {
+      fw: {
         romloader: {
           version: '1.0.0',
         },
@@ -917,17 +917,17 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(
       getProtocolV2RuntimeMode(legacyProtocolInfo, {
-        main_mcu: { bootloader: { version: '0.2.0' } },
+        fw: { bootloader: { version: '0.2.0' } },
       })
     ).toBe('bootloader');
     expect(
       getProtocolV2RuntimeMode(legacyProtocolInfo, {
-        main_mcu: { romloader: { version: '1.0.0' } },
+        fw: { romloader: { version: '1.0.0' } },
       })
     ).toBe('romloader');
     expect(
       getProtocolV2RuntimeMode(legacyProtocolInfo, {
-        main_mcu: {
+        fw: {
           application: { version: '1.2.3' },
           bootloader: { version: '0.2.0' },
         },
@@ -1998,7 +1998,7 @@ describe('Protocol V2 feature adapter', () => {
       { ...descriptor, protocolType: 'V2' } as any,
       {
         protocol_version: 2,
-        main_mcu: { application: { version: '1.2.3' } },
+        fw: { application: { version: '1.2.3' } },
         se1: { application: { version: '4.5.6' } },
         status: { unlocked: false, passphrase_enabled: false },
       }
@@ -2035,7 +2035,7 @@ describe('Protocol V2 feature adapter', () => {
       deviceInfo: {
         protocol_version: 1,
         hw: { serial_no: 'PR9999999999' },
-        main_mcu: { application: { version: '1.0.0' } },
+        fw: { application: { version: '1.0.0' } },
       },
       deviceStatus: {
         device_id: 'firmware-reconnect-id',
@@ -2400,7 +2400,7 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features = {
       ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
         hw: { serial_no: 'PR2SERIAL' },
-        main_mcu: { application: { version: '4.15.0' } },
+        fw: { application: { version: '4.15.0' } },
         status: { passphrase_enabled: true },
       }),
       unlocked: true,
@@ -2825,7 +2825,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-          main_mcu: { application: { version: '1.2.3' } },
+          fw: { application: { version: '1.2.3' } },
         },
       }),
     };
@@ -2846,7 +2846,7 @@ describe('Protocol V2 feature adapter', () => {
       {
         targets: {
           hw: true,
-          main_mcu: true,
+          fw: true,
           coprocessor: true,
         },
         types: {
@@ -2955,7 +2955,7 @@ describe('Protocol V2 feature adapter', () => {
     const device = stubDevice({
       originalDescriptor: { protocolType: 'V2' },
       features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
-        main_mcu: {
+        fw: {
           application: {
             version: '4.14.0',
           },
@@ -3009,7 +3009,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-          main_mcu: { application: { version: '1.2.3' } },
+          fw: { application: { version: '1.2.3' } },
         },
       })
       .mockResolvedValueOnce({
@@ -3044,7 +3044,7 @@ describe('Protocol V2 feature adapter', () => {
       {
         targets: {
           hw: true,
-          main_mcu: true,
+          fw: true,
           coprocessor: true,
         },
         types: {
@@ -3073,7 +3073,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
-          main_mcu: { bootloader: { version: '0.2.0' } },
+          fw: { bootloader: { version: '0.2.0' } },
           se1: {},
         },
       })
@@ -3123,7 +3123,7 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.probeProtocolV2RuntimeState({
       hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-      main_mcu: { romloader: { version: '1.0.0' } },
+      fw: { romloader: { version: '1.0.0' } },
     });
 
     expect(typedCall).toHaveBeenCalledTimes(1);
@@ -3151,7 +3151,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.probeProtocolV2RuntimeState({
         hw: { Device_type: DeviceType.PRO, serial_no: 'PRO-SERIAL' },
-        main_mcu: { romloader: { version: '1.0.0' } },
+        fw: { romloader: { version: '1.0.0' } },
       })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceInitializeFailed });
 
@@ -3176,7 +3176,7 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.probeProtocolV2RuntimeState({
       hw: { serial_no: 'PR2SERIAL' },
-      main_mcu: { application: { version: '1.2.3' } },
+      fw: { application: { version: '1.2.3' } },
     });
 
     expect(typedCall).toHaveBeenCalledTimes(1);
@@ -3208,7 +3208,7 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.probeProtocolV2RuntimeState({
       hw: { serial_no: 'PR2SERIAL' },
-      main_mcu: { application: { version: '1.2.3' } },
+      fw: { application: { version: '1.2.3' } },
     });
 
     expect(typedCall).toHaveBeenCalledTimes(2);
@@ -3236,7 +3236,7 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.probeProtocolV2RuntimeState({
       hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-      main_mcu: { bootloader: { version: '0.2.0' } },
+      fw: { bootloader: { version: '0.2.0' } },
     });
 
     expect(device.features).toMatchObject({
@@ -3265,7 +3265,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.probeProtocolV2RuntimeState({
         hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-        main_mcu: { application: { version: '1.2.3' } },
+        fw: { application: { version: '1.2.3' } },
       })
     ).rejects.toBe(linkError);
 
@@ -3290,7 +3290,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.probeProtocolV2RuntimeState({
         hw: { serial_no: 'PR2SERIAL' },
-        main_mcu: { application: { version: '1.2.3' } },
+        fw: { application: { version: '1.2.3' } },
       })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceInitializeFailed });
     expect(typedCall).toHaveBeenCalledTimes(1);
@@ -3307,7 +3307,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-          main_mcu: { bootloader: { version: '0.2.0' } },
+          fw: { bootloader: { version: '0.2.0' } },
         },
       })
       .mockResolvedValueOnce({
@@ -3357,7 +3357,7 @@ describe('Protocol V2 feature adapter', () => {
     await device.probeProtocolV2RuntimeState(
       {
         hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-        main_mcu: { application: { version: '1.2.3' } },
+        fw: { application: { version: '1.2.3' } },
       },
       5000
     );
@@ -3402,7 +3402,7 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.probeProtocolV2RuntimeState({
       hw: { Device_type: DeviceType.NEO, serial_no: 'NEOSERIAL' },
-      main_mcu: { bootloader: { version: '0.2.0' } },
+      fw: { bootloader: { version: '0.2.0' } },
     });
 
     expect(typedCall).toHaveBeenNthCalledWith(1, 'ProtocolInfoRequest', 'ProtocolInfo', {
@@ -3436,7 +3436,7 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.probeProtocolV2RuntimeState({
       hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-      main_mcu: { romloader: { version: '1.0.0' } },
+      fw: { romloader: { version: '1.0.0' } },
     });
 
     expect(typedCall).toHaveBeenCalledTimes(1);
@@ -3474,7 +3474,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.probeProtocolV2RuntimeState({
         hw: { serial_no: 'PR2SERIAL' },
-        main_mcu: { application: { version: '1.0.0' } },
+        fw: { application: { version: '1.0.0' } },
       })
     ).rejects.toThrow('state update failed');
 
@@ -3499,7 +3499,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-          main_mcu: { application: { version: '1.2.3' } },
+          fw: { application: { version: '1.2.3' } },
         },
       })
       .mockResolvedValueOnce({
@@ -3514,7 +3514,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-          main_mcu: { application: { version: '1.2.4' } },
+          fw: { application: { version: '1.2.4' } },
         },
       })
       .mockResolvedValueOnce({
@@ -3546,7 +3546,7 @@ describe('Protocol V2 feature adapter', () => {
       {
         targets: {
           hw: true,
-          main_mcu: true,
+          fw: true,
           coprocessor: true,
         },
         types: {
@@ -3567,7 +3567,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
-          main_mcu: { application: { version: '1.2.4' } },
+          fw: { application: { version: '1.2.4' } },
         },
       })
       .mockResolvedValueOnce({
@@ -3644,7 +3644,7 @@ describe('Protocol V2 feature adapter', () => {
       { ...descriptor, protocolType: 'V2' } as any,
       {
         hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
-        main_mcu: { application: { version: '1.2.3' } },
+        fw: { application: { version: '1.2.3' } },
         status: { init_states: true },
       }
     );
@@ -3684,7 +3684,7 @@ describe('Protocol V2 feature adapter', () => {
       { ...descriptor, protocolType: 'V2' } as any,
       {
         hw: { serial_no: 'PR2SERIAL' },
-        main_mcu: { application: { version: '4.15.0' } },
+        fw: { application: { version: '4.15.0' } },
         status: { passphrase_enabled: false },
       }
     );
@@ -3731,7 +3731,7 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
       {
-        main_mcu: { application: { version: '1.2.3' } },
+        fw: { application: { version: '1.2.3' } },
         status: { unlocked: false },
       }
     );
@@ -4160,7 +4160,7 @@ describe('Protocol V2 firmware update targets', () => {
           type: 'DeviceInfo',
           message: {
             hw: { serial_no: 'BLE-PRO2-SERIAL' },
-            main_mcu: {
+            fw: {
               bootloader: { version: '0.0.0' },
               application: { version: '0.0.0' },
             },
@@ -4212,7 +4212,7 @@ describe('Protocol V2 firmware update targets', () => {
       {
         targets: {
           hw: true,
-          main_mcu: true,
+          fw: true,
           coprocessor: true,
           se1: true,
           se2: true,
@@ -4631,6 +4631,43 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postTipMessage).toHaveBeenCalledWith('GoToBootloaderSuccess');
   });
 
+  test('keeps an ambiguous legacy runtime on the direct loader update path', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'legacy-path', protocolType: 'V2' },
+      state: {
+        raw: {
+          protocolV2ProtocolInfo: {
+            version: 1,
+            build_fingerprint: '',
+            supported_messages: [],
+            protobuf_definition: null,
+          },
+        },
+      },
+      features: {
+        deviceType: 'pro2',
+        mode: 'bootloader',
+        bootloaderMode: true,
+        capabilities: [],
+      },
+      isBootloader: () => true,
+      isRomloader: () => false,
+    });
+    (method as any).protocolV2Reboot = jest.fn();
+    method.postTipMessage = jest.fn();
+
+    await expect((method as any).enterProtocolV2BootloaderMode()).resolves.toBe(false);
+
+    expect((method as any).protocolV2LegacyDirectUpdate).toBe(true);
+    expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
+  });
+
   test('keeps Protocol V2 romloader active before firmware transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -5079,7 +5116,7 @@ describe('Protocol V2 firmware update targets', () => {
       type: 'DeviceInfo',
       message: {
         hw: { serial_no: 'PR2SERIAL' },
-        main_mcu: { application: { version: '1.0.0' } },
+        fw: { application: { version: '1.0.0' } },
       },
     });
     (method as any).protocolV2ExpectedSerialNumber = 'expected-serial';
@@ -5206,50 +5243,49 @@ describe('Protocol V2 firmware update targets', () => {
     );
   });
 
-  test('stages targets before sending the empty Protocol V2 install request', async () => {
+  test('requires an explicit Protocol V2 update ACK before entering install state', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const targets = [{ target_id: 4, path: 'vol1:firmware.bin' }];
-    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValue(
+        Object.assign(
+          new Error("Failed to execute 'open' on 'USBDevice': The device was disconnected"),
+          { name: 'NotFoundError' }
+        )
+      );
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
     });
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
 
     await expect(
-      (method as any).protocolV2StartFirmwareUpdate({ targets })
-    ).resolves.toBeUndefined();
+      (method as any).protocolV2StartFirmwareUpdate({
+        targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
+      })
+    ).rejects.toThrow();
 
-    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateStage', 'Success', { targets });
-    expect(call).toHaveBeenCalledWith(
-      'DeviceFirmwareUpdateRequest',
-      {},
-      { returnAfterWrite: true }
-    );
-    expect(typedCall.mock.invocationCallOrder[0]).toBeLessThan(call.mock.invocationCallOrder[0]);
-    expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
-    expect(method.postProgressMessage).toHaveBeenCalledWith(0, 'installingFirmware');
+    expect(method.postTipMessage).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
-  test('does not send the install request when Protocol V2 staging fails', async () => {
+  test('does not poll Protocol V2 install status when the update ACK times out', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest.fn().mockRejectedValue(new Error('stage failed'));
-    const call = jest.fn();
+    const typedCall = jest.fn().mockRejectedValue(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
     });
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
@@ -5258,26 +5294,78 @@ describe('Protocol V2 firmware update targets', () => {
       (method as any).protocolV2StartFirmwareUpdate({
         targets: [{ target_id: 4, path: 'vol1:application_p1.bin' }],
       })
-    ).rejects.toThrow('stage failed');
+    ).rejects.toThrow('LIBUSB_TRANSFER_TIMED_OUT');
 
-    expect(call).not.toHaveBeenCalled();
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
-  test('does not enter install state when writing the empty request fails', async () => {
+  test.each([
+    'Failure_InvalidMessage,Handler not registered',
+    'Failure_InvalidMessage,Unsupported message',
+  ])('reboots a legacy App when the direct update endpoint is unavailable: %s', async message => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+    const appTypedCall = jest.fn().mockRejectedValueOnce(new Error(message));
+    const bootloaderTypedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Success', message: { message: '' } });
+    let activeCommands = { typedCall: appTypedCall };
+
+    (method as any).device = stubDevice({
+      getCommands: () => activeCommands,
+    });
+    (method as any).protocolV2LegacyDirectUpdate = true;
+    (method as any).rebootProtocolV2ToBootloader = jest.fn().mockImplementation(() => {
+      activeCommands = { typedCall: bootloaderTypedCall };
+      return Promise.resolve(true);
+    });
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    await expect((method as any).protocolV2StartFirmwareUpdate({ targets })).resolves.toEqual({
+      type: 'Success',
+      message: { message: '' },
+    });
+
+    expect(appTypedCall).toHaveBeenCalledTimes(1);
+    expect(appTypedCall).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      'Success',
+      { targets },
+      { timeoutMs: 180000 }
+    );
+    expect(bootloaderTypedCall).toHaveBeenCalledTimes(1);
+    expect(bootloaderTypedCall).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      'Success',
+      { targets },
+      { timeoutMs: 180000 }
+    );
+    expect((method as any).rebootProtocolV2ToBootloader).toHaveBeenCalledTimes(1);
+    expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
+    expect(method.postProgressMessage).toHaveBeenCalledWith(0, 'installingFirmware');
+  });
+
+  test('does not replay a legacy direct update after a link failure', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockRejectedValue(new Error('write failed'));
+    const typedCall = jest.fn().mockRejectedValue(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
     });
+    (method as any).protocolV2LegacyDirectUpdate = true;
+    (method as any).rebootProtocolV2ToBootloader = jest.fn();
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
 
@@ -5285,9 +5373,10 @@ describe('Protocol V2 firmware update targets', () => {
       (method as any).protocolV2StartFirmwareUpdate({
         targets: [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
       })
-    ).rejects.toThrow('write failed');
+    ).rejects.toThrow('LIBUSB_TRANSFER_TIMED_OUT');
 
-    expect(call).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect((method as any).rebootProtocolV2ToBootloader).not.toHaveBeenCalled();
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
@@ -5335,21 +5424,26 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('accepts the terminal Success returned by the install request', async () => {
+  test('accepts a missing firmware status handler only after confirming normal mode', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValue(new Error('Failure: Handler not registered for this message'));
     const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
-    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
+    (method as any).protocolV2InstallAckReceived = true;
     method.postProgressMessage = jest.fn();
 
     await (method as any).waitForProtocolV2FirmwareUpdateComplete([
@@ -5358,7 +5452,47 @@ describe('Protocol V2 firmware update targets', () => {
 
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
     expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceFirmwareUpdateStatusGet']);
-    expect((method as any).protocolV2FinalStatusVerified).toBe(true);
+    expect((method as any).probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+  });
+
+  test('accepts an empty firmware status dump only after confirming normal mode', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceFirmwareUpdateStatus',
+      message: { records: [] },
+    });
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    let now = 0;
+    jest.spyOn(Date, 'now').mockImplementation(() => now);
+    jest.spyOn(global, 'setTimeout').mockImplementation(((callback: () => void) => {
+      now += 31 * 1000;
+      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 as any).protocolV2InstallAckReceived = true;
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (method as any).waitForProtocolV2FirmwareUpdateComplete([
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+      ])
+    ).resolves.toBeUndefined();
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect((method as any).probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
@@ -5672,7 +5806,7 @@ describe('Protocol V2 firmware update targets', () => {
     );
   });
 
-  test('polls target status after the install request and finishes when all targets complete', async () => {
+  test('polls target status after update ACK and finishes when all targets complete', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5707,7 +5841,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
-      ['DeviceFirmwareUpdateStatus', 'Success'],
+      'DeviceFirmwareUpdateStatus',
       expect.anything(),
       expect.anything()
     );
@@ -5983,7 +6117,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
-      ['DeviceFirmwareUpdateStatus', 'Success'],
+      'DeviceFirmwareUpdateStatus',
       {
         fields: {
           status: true,
@@ -7183,10 +7317,9 @@ describe('Protocol V2 firmware update targets', () => {
       ],
     };
     const zip = new JSZip();
-    zip.file('pro2-resource/manifest.json', JSON.stringify(manifest));
-    zip.file('pro2-resource/bundles/images/images.okpkg', imagesBinary);
-    zip.file('pro2-resource/loaders/bootloader/boot_resource.okpkg', bootResourceBinary);
-    zip.file('pro2-resource/build-info.txt', 'ignored');
+    zip.file('manifest.json', JSON.stringify(manifest));
+    zip.file('bundles/images/images.okpkg', imagesBinary);
+    zip.file('loaders/bootloader/boot_resource.okpkg', bootResourceBinary);
     const resourceArchiveBinary = await zip.generateAsync({ type: 'arraybuffer' });
     const applicationP1Binary = new Uint8Array([7, 8, 9]).buffer;
     const bootloaderBinary = new Uint8Array([10, 11, 12]).buffer;
@@ -7262,39 +7395,6 @@ describe('Protocol V2 firmware update targets', () => {
     }
   });
 
-  test('accepts a local resource ZIP without manifest.json', async () => {
-    const imagesBinary = new Uint8Array([1, 2, 3]).buffer;
-    const bootResourceBinary = new Uint8Array([4, 5, 6]).buffer;
-    const zip = new JSZip();
-    zip.file('pro2-resource/bundles/images/images.okpkg', imagesBinary);
-    zip.file('pro2-resource/loaders/bootloader/boot_resource.okpkg', bootResourceBinary);
-    zip.file('pro2-resource/build-info.txt', 'ignored');
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-        targetsToUpdate: ['resource'],
-      },
-    });
-    method.init();
-
-    await expect(
-      (method as any).prepareProtocolV2LocalResourceArchive(
-        await zip.generateAsync({ type: 'arraybuffer' })
-      )
-    ).resolves.toMatchObject({
-      materializedEntries: [
-        { entryName: 'manifest.json' },
-        { entryName: 'bundles/images/images.okpkg', binary: imagesBinary },
-        {
-          entryName: 'loaders/bootloader/boot_resource.okpkg',
-          binary: bootResourceBinary,
-        },
-      ],
-    });
-  });
-
   test('rejects a local resource ZIP whose file hash does not match its manifest', async () => {
     const resourceBinary = new Uint8Array([1, 2, 3]).buffer;
     const bootResourceBinary = new Uint8Array([4, 5, 6]).buffer;
@@ -7385,57 +7485,18 @@ describe('Protocol V2 firmware update targets', () => {
 
   test('rejects an oversized ZIP entry before allocating its decompressed bytes', async () => {
     const extractEntry = jest.fn();
-    const oversizedFileSize = 257 * 1024 * 1024;
-    const manifestBinary = new TextEncoder().encode(
-      JSON.stringify({
-        files: [
-          {
-            archive_path: 'loaders/bootloader/boot_resource.okpkg',
-            original_name: 'boot_resource.okpkg',
-            device_path: 'vol0:/loaders/bootloader/boot_resource.okpkg',
-            size: oversizedFileSize,
-            sha256: '0'.repeat(64),
-            signed: true,
-            sig_algo: 'ed25519',
-          },
-          {
-            archive_path: 'bundles/images/images.okpkg',
-            original_name: 'images.okpkg',
-            device_path: 'vol0:/bundles/images/images.okpkg',
-            size: oversizedFileSize,
-            sha256: '0'.repeat(64),
-            signed: true,
-            sig_algo: 'ed25519',
+    const loadSpy = jest.spyOn(JSZip, 'loadAsync').mockResolvedValue({
+      files: {
+        'manifest.json': {
+          name: 'manifest.json',
+          dir: false,
+          _data: {
+            compressedSize: 1,
+            uncompressedSize: 2 * 1024 * 1024,
           },
-        ],
-      })
-    );
-    const zipFiles = {
-      'manifest.json': {
-        name: 'manifest.json',
-        dir: false,
-        _data: {
-          compressedSize: manifestBinary.byteLength,
-          uncompressedSize: manifestBinary.byteLength,
+          async: extractEntry,
         },
-        async: jest.fn().mockResolvedValue(manifestBinary.buffer),
-      },
-      'loaders/bootloader/boot_resource.okpkg': {
-        name: 'loaders/bootloader/boot_resource.okpkg',
-        dir: false,
-        _data: { compressedSize: 1, uncompressedSize: oversizedFileSize },
-        async: extractEntry,
       },
-      'bundles/images/images.okpkg': {
-        name: 'bundles/images/images.okpkg',
-        dir: false,
-        _data: { compressedSize: 1, uncompressedSize: oversizedFileSize },
-        async: extractEntry,
-      },
-    };
-    const loadSpy = jest.spyOn(JSZip, 'loadAsync').mockResolvedValue({
-      files: zipFiles,
-      file: (name: string) => zipFiles[name as keyof typeof zipFiles] ?? null,
     } as unknown as JSZip);
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -7450,7 +7511,7 @@ describe('Protocol V2 firmware update targets', () => {
     try {
       await expect(
         (method as any).prepareProtocolV2LocalResourceArchive(new Uint8Array([1]).buffer)
-      ).rejects.toThrow('declared size is invalid');
+      ).rejects.toThrow('declared size exceeds the allowed limit');
       expect(extractEntry).not.toHaveBeenCalled();
     } finally {
       loadSpy.mockRestore();
@@ -7746,7 +7807,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([4000, 97]);
     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, 99]);
+    expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 100]);
     expect(method.postMessage).toHaveBeenLastCalledWith({
       event: 'UI_EVENT',
       type: UI_REQUEST.FIRMWARE_PROGRESS,
@@ -7827,9 +7888,9 @@ describe('Protocol V2 firmware update targets', () => {
 
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
     const deviceProgress = writePayloads.map(payload => payload.ui_percentage);
-    expect(deviceProgress).toEqual([0, 50, 99, 99]);
+    expect(deviceProgress).toEqual([0, 50, 99, 100]);
     expect(deviceProgress.filter(progress => progress === 0)).toHaveLength(1);
-    expect(deviceProgress.filter(progress => progress === 100)).toHaveLength(0);
+    expect(deviceProgress.filter(progress => progress === 100)).toHaveLength(1);
     expect(method.postTipMessage).toHaveBeenCalledTimes(2);
     expect(method.postTipMessage).toHaveBeenNthCalledWith(1, 'StartTransferData');
     expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'ConfirmOnDevice');
@@ -8147,7 +8208,7 @@ describe('Protocol V2 firmware update targets', () => {
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
     expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 1800]);
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1800, 1]);
-    expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 99]);
+    expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 100]);
     expect(typedCall.mock.calls.map(call => call[3])).toEqual([
       expect.objectContaining({
         writeWithResponse: false,
@@ -8206,24 +8267,23 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1960, 1]);
   });
 
-  test('starts install progress only after Stage and the empty Request are written', async () => {
+  test('ends device confirmation and starts install progress only after Protocol V2 ACK', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    let resolveWrite: ((value: unknown) => void) | undefined;
-    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockImplementation(
+    let resolveRequest: ((value: unknown) => void) | undefined;
+    const typedCall = jest.fn().mockImplementation(
       () =>
         new Promise(resolve => {
-          resolveWrite = resolve;
+          resolveRequest = resolve;
         })
     );
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
     });
     method.postProgressMessage = jest.fn();
     method.postTipMessage = jest.fn();
@@ -8231,31 +8291,21 @@ describe('Protocol V2 firmware update targets', () => {
     const startPromise = (method as any).protocolV2StartFirmwareUpdate({
       targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
     });
-    await new Promise<void>(resolve => {
-      setImmediate(resolve);
-    });
+    await Promise.resolve();
 
-    expect(typedCall.mock.calls[0]).toEqual([
-      'DeviceFirmwareUpdateStage',
-      'Success',
-      { targets: [{ target_id: 4, path: 'vol1:firmware.bin' }] },
-    ]);
-    expect(call).toHaveBeenCalledWith(
-      'DeviceFirmwareUpdateRequest',
-      {},
-      { returnAfterWrite: true }
-    );
+    expect(typedCall.mock.calls[0][1]).toBe('Success');
+    expect(typedCall.mock.calls[0][3]).toEqual(expect.objectContaining({ timeoutMs: 180_000 }));
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
 
-    resolveWrite?.({ type: 'WriteCompleted', message: {} });
+    resolveRequest?.({ type: 'Success', message: { message: 'ok' } });
     await startPromise;
     expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
     expect(method.postProgressMessage).toHaveBeenCalledWith(0, 'installingFirmware');
     expect(method.postTipMessage).toHaveBeenCalledTimes(1);
   });
 
-  test('sends an empty Protocol V2 firmware install request without waiting for its response', async () => {
+  test('requests only a Success ACK for Protocol V2 firmware install', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -8266,10 +8316,9 @@ describe('Protocol V2 firmware update targets', () => {
       type: 'Success',
       message: { message: 'accepted' },
     });
-    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
     });
     method.postProgressMessage = jest.fn();
     method.postTipMessage = jest.fn();
@@ -8278,12 +8327,7 @@ describe('Protocol V2 firmware update targets', () => {
       targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
     });
 
-    expect(typedCall.mock.calls[0][0]).toBe('DeviceFirmwareUpdateStage');
-    expect(call).toHaveBeenCalledWith(
-      'DeviceFirmwareUpdateRequest',
-      {},
-      { returnAfterWrite: true }
-    );
+    expect(typedCall.mock.calls[0][1]).toBe('Success');
     expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
   });
 });
@@ -9178,29 +9222,6 @@ describe('Protocol V2 protected method execution', () => {
     }
   );
 
-  test('skips DeviceStatus and unlock when Protocol V2 is not initialized', async () => {
-    const method = {
-      name: 'firmwareUpdateV4',
-      unlockPolicy: 'unlock-before-run',
-      run: jest.fn().mockResolvedValue({ message: 'updating' }),
-    };
-    const device = {
-      state: { status: { initialized: false } },
-      commands: { typedCall: jest.fn() },
-      isProtocolV2: () => true,
-      isBootloader: () => false,
-      isRomloader: () => false,
-      unlockDevice: jest.fn(),
-    };
-
-    await expect(runMethodWithUnlockPolicy(method as any, device as any)).resolves.toEqual({
-      message: 'updating',
-    });
-    expect(device.commands.typedCall).not.toHaveBeenCalled();
-    expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(method.run).toHaveBeenCalledTimes(1);
-  });
-
   test('keeps Protocol V1 and lock-free methods outside the preflight path', async () => {
     for (const [isProtocolV2, unlockPolicy] of [
       [false, 'unlock-before-run'],
@@ -9380,7 +9401,7 @@ describe('Protocol V2 current low-level methods', () => {
       info: {
         version: undefined,
         serial_number: 'PR2SERIAL',
-        factory_burn_in_completed: true,
+        burn_in_completed: true,
         factory_test_completed: undefined,
         manufacture_time: undefined,
       },
@@ -9630,7 +9651,7 @@ describe('Protocol V2 raw device info method', () => {
       'DeviceInfoGet',
       'DeviceInfo',
       {
-        targets: { hw: true, main_mcu: true, coprocessor: true },
+        targets: { hw: true, fw: true, coprocessor: true },
         types: { version: true, specific: true },
       },
       { timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS }