@onekeyfe/hd-core 1.2.6-alpha.0 → 1.2.6-alpha.2

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

@@ -4,8 +4,11 @@ import CheckAllFirmwareRelease, {
   buildProtocolV2FirmwareRelease,
 } from '../src/api/CheckAllFirmwareRelease';
 import { DataManager } from '../src/data-manager';
+import { mapProtocolV2DeviceInfoToState } from '../src/device/DeviceStateMapper';
+import { DeviceStateStore } from '../src/device/DeviceStateStore';
 import { createCoreApi } from '../src/inject';
 
+import type { ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
 import type { CoreApi } from '../src/types/api';
 import type { DeviceStateVersions, IFirmwareReleaseInfo } from '../src/types';
 
@@ -290,6 +293,67 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     expect(result.targetsToUpdate).toEqual(['app_v1', 'app_v2']);
   });
 
+  test('does not repeat a P2 update after normal firmware follows an older loader P2 reading', () => {
+    const store = new DeviceStateStore();
+    store.update(
+      mapProtocolV2DeviceInfoToState(
+        {
+          main_mcu: {
+            application: { version: '1.0.2' },
+            application_data: { version: '1.0.2', build_id: 'old-p2', hash: [0xbb] },
+          },
+        } as ProtocolV2DeviceInfo,
+        'bootloader'
+      ),
+      'device-info'
+    );
+    const { state } = store.update(
+      mapProtocolV2DeviceInfoToState(
+        {
+          main_mcu: {
+            application: { version: '1.0.3', hash: [0xaa] },
+            application_data: { version: '1.0.2', build_id: 'old-p2', hash: [0xbb] },
+          },
+        } as ProtocolV2DeviceInfo,
+        'normal'
+      ),
+      'device-info'
+    );
+    const packageSet: IFirmwareReleaseInfo = {
+      ...release,
+      installOrder: ['applicationP1', 'applicationP2'],
+      components: {
+        applicationP1: {
+          target: 'APPLICATION_P1',
+          version: [1, 0, 3],
+          url: 'https://example.com/p1.okpkg',
+        },
+        applicationP2: {
+          target: 'APPLICATION_P2',
+          version: [1, 0, 3],
+          url: 'https://example.com/p2.okpkg',
+        },
+      },
+    };
+
+    expect(state.versions.applicationP2).toBeNull();
+    expect(state.verification?.applicationP2BuildId).toBeNull();
+    expect(state.verification?.applicationP2Hash).toBeNull();
+    expect(
+      buildProtocolV2FirmwareRelease({
+        currentVersions: state.versions,
+        currentVerification: state.verification,
+        checkFirmwareHash: true,
+        remotePayloadHashes: {
+          applicationP1: 'aa'.repeat(64),
+          applicationP2: 'cc'.repeat(64),
+        },
+        firmwareType: EFirmwareType.Universal,
+        release: packageSet,
+      }).targetsToUpdate
+    ).toEqual([]);
+  });
+
   test('does not read vol0 resource inventory while Protocol V2 is in Application mode', async () => {
     const method = new CheckAllFirmwareRelease({
       id: 1,

package/__tests__/device-state-mapper.test.ts

@@ -110,7 +110,7 @@ describe('DeviceStateMapper', () => {
     expect(patch.identity?.firmwareType).toBe(EFirmwareType.Universal);
   });
 
-  test('maps Protocol V2 DeviceInfo without inventing runtime status', () => {
+  test('maps Protocol V2 bootloader DeviceInfo including P2', () => {
     const patch = mapProtocolV2DeviceInfoToState(
       {
         protocol_version: 2,
@@ -130,7 +130,7 @@ describe('DeviceStateMapper', () => {
           application: { version: '3.0.0', build_id: 'se1-build', hash: [0x05, 0x06] },
         },
       } as ProtocolV2DeviceInfo,
-      'normal'
+      'bootloader'
     );
 
     expect(patch.identity).toMatchObject({
@@ -157,9 +157,33 @@ describe('DeviceStateMapper', () => {
       se01: { type: 'THD89', state: 'APP' },
     });
     expect(patch).toMatchObject({ protocolVersion: 2 });
-    expect(patch.status?.unlocked).toBeUndefined();
+    expect(patch.status?.unlocked).toBeNull();
   });
 
+  test.each([undefined, { version: '1.0.2', build_id: 'old-p2', hash: [0x01, 0x02] }])(
+    'clears cached loader P2 version and verification when normal firmware reports P1',
+    applicationData => {
+      const patch = mapProtocolV2DeviceInfoToState(
+        {
+          main_mcu: {
+            application: { version: '1.0.3' },
+            application_data: applicationData,
+          },
+        } as ProtocolV2DeviceInfo,
+        'normal'
+      );
+
+      expect(patch.versions).toMatchObject({
+        applicationP1: '1.0.3',
+        applicationP2: null,
+      });
+      expect(patch.verification).toMatchObject({
+        applicationP2BuildId: null,
+        applicationP2Hash: null,
+      });
+    }
+  );
+
   test('maps the Protocol V2 Neo device type without treating it as Pro2', () => {
     const patch = mapProtocolV2DeviceInfoToState({
       hw: { Device_type: DeviceType.NEO, serial_no: 'NEO-SERIAL-1' },

package/__tests__/firmware-update/firmware-update-v4-install-poll.test.ts

@@ -3,6 +3,8 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import FirmwareUpdateV4 from '../../src/api/FirmwareUpdateV4';
 
 import type { Device } from '../../src/device/Device';
+import type { ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+import type { Features } from '../../src/types';
 
 jest.mock('../../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://example.com/',
@@ -833,6 +835,304 @@ describe('FirmwareUpdateV4 install polling', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
+  test.each([
+    { scenario: 'missed progress after reconnect', updatedAt: 0, loaderBeforeUpdate: false },
+    { scenario: 'a reboot on the reconnected link', updatedAt: 1000, loaderBeforeUpdate: true },
+    { scenario: 'completion at the deadline', updatedAt: 600_000, loaderBeforeUpdate: false },
+    {
+      scenario: 'completion at the deadline without a disconnect',
+      updatedAt: 600_000,
+      loaderBeforeUpdate: false,
+      skipReconnect: true,
+    },
+    {
+      scenario: 'a reboot with an unavailable status endpoint',
+      updatedAt: 1000,
+      loaderBeforeUpdate: true,
+      statusUnavailable: true,
+    },
+    {
+      scenario: 'a different physical device after reconnect',
+      updatedAt: 0,
+      loaderBeforeUpdate: false,
+      differentDevice: true,
+    },
+    {
+      scenario: 'unchanged versions despite cached P2',
+      updatedAt: Infinity,
+      loaderBeforeUpdate: false,
+    },
+    {
+      scenario: 'normal firmware P1 updated while P2 is unobservable',
+      updatedAt: Infinity,
+      p1UpdatedAt: 0,
+      loaderBeforeUpdate: false,
+    },
+    {
+      scenario: 'P2-only install cannot be inferred from an already updated P1',
+      updatedAt: Infinity,
+      p1UpdatedAt: 0,
+      loaderBeforeUpdate: false,
+      p2Only: true,
+    },
+    {
+      scenario: 'normal firmware P1 updated after in-progress status disappears',
+      updatedAt: 3000,
+      p1UpdatedAt: 0,
+      statusInProgressAtStart: true,
+      loaderBeforeUpdate: false,
+    },
+  ])(
+    'checks fresh versions when BLE status is unavailable: $scenario',
+    async ({
+      updatedAt,
+      p1UpdatedAt,
+      p2Only,
+      statusInProgressAtStart,
+      loaderBeforeUpdate,
+      skipReconnect,
+      statusUnavailable,
+      differentDevice,
+    }) => {
+      let now = 0;
+      jest.spyOn(Date, 'now').mockImplementation(() => now);
+      jest.spyOn(global, 'setTimeout').mockImplementation(((
+        callback: () => void,
+        delay: number
+      ) => {
+        now += delay;
+        callback();
+        return 0;
+      }) as typeof setTimeout);
+      const method = new FirmwareUpdateV4({
+        id: 1,
+        payload: { method: 'firmwareUpdateV4', connectId: 'pro2-ble' },
+      });
+      const targets = [
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+        { target_id: 5, path: 'vol0:/application_p2.bin' },
+      ].filter(target => !p2Only || target.target_id === 5);
+      let statusPolls = 0;
+      const statusGet = jest.fn().mockImplementation(() => {
+        if (statusUnavailable) throw new Error('unsupported message');
+        if (statusInProgressAtStart && statusPolls++ === 0) {
+          return {
+            type: 'DeviceFirmwareUpdateStatus',
+            message: { records: [{ ...targets[targets.length - 1], status: 1 }] },
+          };
+        }
+        return { type: 'DeviceFirmwareUpdateStatus', message: { records: [] } };
+      });
+      let lastDeviceInfo: ProtocolV2DeviceInfo | undefined;
+      const deviceInfoGet = jest.fn().mockImplementation(() => {
+        lastDeviceInfo = {
+          hw: { serial_no: differentDevice ? 'pro2-other' : 'pro2-test' },
+          main_mcu: {
+            application: { version: now >= (p1UpdatedAt ?? updatedAt) ? '1.0.2' : '1.0.1' },
+            application_data: { version: now >= updatedAt ? '1.0.2' : '1.0.1' },
+          },
+        };
+        return { type: 'DeviceInfo', message: lastDeviceInfo };
+      });
+      const typedCall = jest.fn().mockImplementation((type: string) => {
+        if (type === 'DeviceFirmwareUpdateStatusGet') return statusGet();
+        if (type === 'DeviceInfoGet') return deviceInfoGet();
+        throw new Error(`Unexpected command: ${type}`);
+      });
+      let finalFeatures: Features | undefined;
+      const probeProtocolV2RuntimeState = jest
+        .fn()
+        .mockImplementation(
+          (
+            info: ProtocolV2DeviceInfo,
+            _timeout: number,
+            options?: { forceRuntimeContextRefresh?: boolean }
+          ) => {
+            const normal =
+              options?.forceRuntimeContextRefresh && (!loaderBeforeUpdate || now >= updatedAt);
+            finalFeatures = {
+              mode: normal ? 'normal' : 'bootloader',
+              bootloaderMode: !normal,
+              firmwareVersion: info.main_mcu?.application?.version,
+            } as Features;
+            return finalFeatures;
+          }
+        );
+      method.device = {
+        originalDescriptor: { path: 'pro2-ble' },
+        getCommands: () => ({ typedCall }),
+        // A retained P2 field is deliberately newer than the live pre-install version.
+        state: { versions: { applicationP2: '1.0.2' } },
+        probeProtocolV2RuntimeState,
+        setCancelableAction: jest.fn(),
+      } as unknown as Device;
+      method.postProgressMessage = jest.fn();
+      const firmwareUpdate = method as unknown as {
+        isBleReconnect: () => boolean;
+        protocolV2InstallNeedsReconnect: boolean;
+        protocolV2ExpectedSerialNumber: string;
+        protocolV2InstallBaselineVersions: Map<number, string>;
+        protocolV2LatestFinalFeatures?: Features;
+        protocolV2LatestFinalDeviceInfo?: ProtocolV2DeviceInfo;
+        params: { expectedTargetVersions: { app_v1: string; app_v2: string } };
+        waitForProtocolV2FirmwareUpdateComplete: (
+          value: typeof targets,
+          requireCurrentInstallStatus: boolean
+        ) => Promise<void>;
+        reconnectProtocolV2Device: () => Promise<void>;
+        assertExpectedProtocolV2Versions: () => void;
+      };
+      firmwareUpdate.isBleReconnect = () => true;
+      firmwareUpdate.protocolV2InstallNeedsReconnect = !skipReconnect;
+      firmwareUpdate.protocolV2ExpectedSerialNumber = 'pro2-test';
+      firmwareUpdate.protocolV2InstallBaselineVersions = new Map([
+        [4, '1.0.1'],
+        [5, '1.0.1'],
+      ]);
+      firmwareUpdate.params = { expectedTargetVersions: { app_v1: '1.0.2', app_v2: '1.0.2' } };
+      firmwareUpdate.reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+
+      const polling = firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+      if (differentDevice) {
+        await expect(polling).rejects.toThrow('physical identity mismatch');
+        expect(probeProtocolV2RuntimeState).not.toHaveBeenCalled();
+        expect(method.postProgressMessage).not.toHaveBeenCalled();
+        return;
+      }
+      let completionAt = updatedAt;
+      if (p2Only) {
+        completionAt = Infinity;
+      } else if (!loaderBeforeUpdate) {
+        completionAt = Math.min(updatedAt, p1UpdatedAt ?? Infinity);
+      }
+      if (Number.isFinite(completionAt)) {
+        await polling;
+        expect(now).toBe(Math.max(completionAt, statusInProgressAtStart ? 1000 : 0));
+        firmwareUpdate.protocolV2LatestFinalFeatures = finalFeatures;
+        firmwareUpdate.protocolV2LatestFinalDeviceInfo = lastDeviceInfo;
+        expect(() => firmwareUpdate.assertExpectedProtocolV2Versions()).not.toThrow();
+        firmwareUpdate.params.expectedTargetVersions.app_v1 = '1.0.3';
+        expect(() => firmwareUpdate.assertExpectedProtocolV2Versions()).toThrow('expected 1.0.3');
+        expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+      } else {
+        await expect(polling).rejects.toMatchObject({
+          params: { firmwareUpdateCode: 'FirmwareInstallTimeout' },
+        });
+        expect(now).toBe(600_000);
+        expect(method.postProgressMessage).not.toHaveBeenCalled();
+      }
+      expect(deviceInfoGet).toHaveBeenCalledTimes(
+        skipReconnect ? 1 : now / 1000 + 1 - (statusInProgressAtStart ? 1 : 0)
+      );
+      expect(probeProtocolV2RuntimeState).toHaveBeenLastCalledWith(
+        expect.anything(),
+        expect.any(Number),
+        { forceRuntimeContextRefresh: true }
+      );
+      expect(typedCall).toHaveBeenCalledWith(
+        'DeviceInfoGet',
+        'DeviceInfo',
+        expect.objectContaining({
+          targets: {
+            hw: true,
+            main_mcu: true,
+            coprocessor: true,
+            se1: true,
+            se2: true,
+            se3: true,
+            se4: true,
+          },
+        }),
+        expect.anything()
+      );
+    }
+  );
+
+  test.each([
+    {
+      scenario: 'finishes after five minutes',
+      terminalAt: 360_000,
+      terminalStatus: 2,
+      error: undefined,
+    },
+    {
+      scenario: 'finishes at the deadline',
+      terminalAt: 600_000,
+      terminalStatus: 2,
+      error: undefined,
+    },
+    {
+      scenario: 'remains in progress',
+      terminalAt: Infinity,
+      terminalStatus: 1,
+      error: 'FirmwareInstallTimeout',
+    },
+    {
+      scenario: 'fails at the deadline',
+      terminalAt: 600_000,
+      terminalStatus: 3,
+      error: 'FirmwareInstallFailed',
+    },
+    {
+      scenario: 'is cancelled at the deadline',
+      terminalAt: 600_000,
+      terminalStatus: -1,
+      error: 'cancelled',
+    },
+  ])(
+    'polls installation for ten minutes: $scenario',
+    async ({ terminalAt, terminalStatus, error }) => {
+      let now = 0;
+      jest.spyOn(Date, 'now').mockImplementation(() => now);
+      jest.spyOn(global, 'setTimeout').mockImplementation(((
+        callback: () => void,
+        delay: number
+      ) => {
+        now += delay;
+        callback();
+        return 0;
+      }) as typeof setTimeout);
+      const method = new FirmwareUpdateV4({
+        id: 1,
+        payload: { method: 'firmwareUpdateV4', connectId: 'pro2-ble' },
+      });
+      const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+      const typedCall = jest.fn().mockImplementation(() => {
+        if (now >= terminalAt && terminalStatus === -1) {
+          throw ERRORS.TypedError(HardwareErrorCode.ActionCancelled);
+        }
+        return {
+          type: 'DeviceFirmwareUpdateStatus',
+          message: { records: [{ ...targets[0], status: now >= terminalAt ? terminalStatus : 1 }] },
+        };
+      });
+      method.device = { getCommands: () => ({ typedCall }) } as unknown as Device;
+      method.postProgressMessage = jest.fn();
+      const firmwareUpdate = method as unknown as {
+        isBleReconnect: () => boolean;
+        waitForProtocolV2FirmwareUpdateComplete: (
+          value: typeof targets,
+          requireCurrentInstallStatus: boolean
+        ) => Promise<void>;
+      };
+      firmwareUpdate.isBleReconnect = () => true;
+      const polling = firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+      if (error) {
+        await expect(polling).rejects.toMatchObject(
+          error === 'cancelled'
+            ? { errorCode: HardwareErrorCode.ActionCancelled }
+            : { params: { firmwareUpdateCode: error } }
+        );
+        expect(method.postProgressMessage).not.toHaveBeenCalledWith(100, 'installingFirmware');
+      } else {
+        await polling;
+        expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+      }
+      expect(now).toBe(Math.min(terminalAt, 600_000));
+      expect(typedCall).toHaveBeenCalledTimes(now / 1000 + 1);
+    }
+  );
+
   test('does not send Request when Stage is rejected', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,

package/__tests__/protocol-v2.test.ts

@@ -6328,7 +6328,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(3);
   });
 
-  test('waits five minutes before rejecting normal mode without install evidence', async () => {
+  test('waits ten minutes before rejecting normal mode without install evidence', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6366,7 +6366,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
 
     expect(method.postProgressMessage).not.toHaveBeenCalledWith(100, 'installingFirmware');
-    expect(typedCall).toHaveBeenCalledTimes(5);
+    expect(typedCall).toHaveBeenCalledTimes(11);
   });
 
   test('preserves multi-app completion evidence when App mode replaces the status endpoint', async () => {
@@ -6381,6 +6381,7 @@ describe('Protocol V2 firmware update targets', () => {
         },
       },
     });
+    method.init();
     const typedCall = jest
       .fn()
       .mockRejectedValue(new Error('Failure: Handler not registered for this message'));
@@ -6410,7 +6411,9 @@ describe('Protocol V2 firmware update targets', () => {
       ])
     ).resolves.toBeUndefined();
 
-    expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000);
+    expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000, {
+      forceRuntimeContextRefresh: true,
+    });
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
     expect(Array.from((method as any).protocolV2CompletedTargetIds)).toEqual([4, 5]);
 
@@ -6535,7 +6538,9 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).device = stubDevice({ probeProtocolV2RuntimeState });
 
     await expect((method as any).probeProtocolV2NormalMode(deviceInfo)).resolves.toBe(expected);
-    expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000);
+    expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000, {
+      forceRuntimeContextRefresh: true,
+    });
   });
 
   test('keeps polling when the firmware status handler is missing in loader mode', async () => {
@@ -6735,7 +6740,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
   });
 
-  test('uses the firmware version for P1 and the optional DeviceInfo version for P2', () => {
+  test('uses bootloader DeviceInfo for the P2 version', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6753,6 +6758,9 @@ describe('Protocol V2 firmware update targets', () => {
       major_version: 1,
       minor_version: 0,
       patch_version: 0,
+      mode: 'bootloader',
+      bootloaderMode: true,
+      firmwareVersion: '1.0.0',
     };
     (method as any).protocolV2LatestFinalDeviceInfo = {
       main_mcu: {
@@ -6764,7 +6772,36 @@ describe('Protocol V2 firmware update targets', () => {
     expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
   });
 
-  test('rejects a mismatched final DeviceInfo application slot version', () => {
+  test('uses P1 after normal boot even when DeviceInfo retains an old P2 version', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'desktop',
+        targetsToUpdate: ['app_v1', 'app_v2'],
+        expectedTargetVersions: { app_v1: '2.0.0', app_v2: '2.0.0' },
+      },
+    });
+    method.init();
+    (method as any).protocolV2LatestFinalFeatures = {
+      major_version: 2,
+      minor_version: 0,
+      patch_version: 0,
+      mode: 'normal',
+      bootloaderMode: false,
+    };
+    (method as any).protocolV2LatestFinalDeviceInfo = {
+      main_mcu: {
+        application: { version: '2.0.0' },
+        application_data: { version: '1.0.1' },
+      },
+    };
+    (method as any).protocolV2CompletedTargetVersions = new Map([[5, 0x20000]]);
+
+    expect(() => (method as any).assertExpectedProtocolV2Versions()).not.toThrow();
+  });
+
+  test('rejects a mismatched bootloader DeviceInfo application slot version', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6782,6 +6819,9 @@ describe('Protocol V2 firmware update targets', () => {
       major_version: 1,
       minor_version: 0,
       patch_version: 0,
+      mode: 'bootloader',
+      bootloaderMode: true,
+      firmwareVersion: '1.0.0',
     };
     (method as any).protocolV2LatestFinalDeviceInfo = {
       main_mcu: {
@@ -6888,7 +6928,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('keeps polling missing target records until the five-minute timeout', async () => {
+  test('keeps polling missing target records until the ten-minute timeout', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6926,7 +6966,7 @@ describe('Protocol V2 firmware update targets', () => {
       message: 'Protocol V2 firmware install timed out',
       params: { firmwareUpdateCode: 'FirmwareInstallTimeout' },
     });
-    expect(typedCall).toHaveBeenCalledTimes(5);
+    expect(typedCall).toHaveBeenCalledTimes(11);
   });
 
   test('keeps polling incomplete records after a Pro2 reboot interruption', async () => {
@@ -6982,7 +7022,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(4);
   });
 
-  test('uses a five-minute Pro2 install status window', async () => {
+  test('uses a ten-minute Pro2 install status window with a final status check', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -6992,7 +7032,13 @@ describe('Protocol V2 firmware update targets', () => {
     jest
       .spyOn(Date, 'now')
       .mockReturnValueOnce(0)
-      .mockReturnValue(5 * 60 * 1000);
+      .mockReturnValue(10 * 60 * 1000);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceFirmwareUpdateStatus',
+      message: { records: [{ target_id: 4, status: 1 }] },
+    });
+    method.device = stubDevice({ getCommands: () => ({ typedCall }) });
+    method.postProgressMessage = jest.fn();
 
     await expect(
       (method as any).waitForProtocolV2FirmwareUpdateComplete([
@@ -7003,6 +7049,7 @@ describe('Protocol V2 firmware update targets', () => {
       message: 'Protocol V2 firmware install timed out',
       params: { firmwareUpdateCode: 'FirmwareInstallTimeout' },
     });
+    expect(typedCall).toHaveBeenCalledTimes(1);
   });
 
   test('uses a 90-second Pro2 bootloader reconnect window', async () => {
@@ -8914,6 +8961,54 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
+  test.each([
+    ['react-native', 10_000],
+    ['webusb', undefined],
+  ] as const)('uses the native firmware write timeout in %s', async (env, timeoutMs) => {
+    const getSettingsSpy = jest.spyOn(DataManager, 'getSettings').mockReturnValue(env);
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'FilesystemFile',
+      message: { processed_byte: 1 },
+    });
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    try {
+      await (method as any).fileWriteChunk(
+        'vol0:/application_p1.bin',
+        1,
+        0,
+        new Uint8Array([1]),
+        true,
+        1
+      );
+    } finally {
+      getSettingsSpy.mockRestore();
+    }
+
+    expect(typedCall).toHaveBeenCalledWith(
+      'FilesystemFileWrite',
+      'FilesystemFile',
+      expect.objectContaining({
+        file: expect.objectContaining({
+          path: 'vol0:/application_p1.bin',
+          offset: 0,
+        }),
+      }),
+      expect.objectContaining({
+        timeoutMs,
+        writeWithResponse: false,
+      })
+    );
+  });
+
   test('does not retry or wrap a stale BLE bond during a V4 file transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,

package/__tests__/sol-sign-offchain-message.test.ts

@@ -54,14 +54,6 @@ describe('SolSignOffchainMessage', () => {
     });
   });
 
-  test('maps omitted required signers to an empty repeated field', () => {
-    const method = createMethod({ requiredSigners: undefined });
-
-    method.init();
-
-    expect(method.params.required_signers).toEqual([]);
-  });
-
   test.each([
     { requiredSigners: ['11'], error: '32-byte hex public key' },
     { requiredSigners: [signerB, signerA], error: 'strictly sorted and unique' },

package/dist/api/FirmwareUpdateV4.d.ts

@@ -16,6 +16,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     private protocolV2CompletedTargetIds;
     private protocolV2LatestFinalFeatures?;
     private protocolV2LatestFinalDeviceInfo?;
+    private protocolV2InitialDeviceInfo?;
     private protocolV2InstallBaselineVersions;
     private protocolV2InstallNeedsReconnect;
     private protocolV2InstallDisconnectObserved;

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

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"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"}

package/dist/device/DeviceStateMapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeviceStateMapper.d.ts","sourceRoot":"","sources":["../../src/device/DeviceStateMapper.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,aAAa,EAEb,cAAc,EACd,YAAY,EACZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAEV,eAAe,EACf,gBAAgB,EAChB,QAAQ,EACR,cAAc,EACf,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAsDxE,eAAO,MAAM,kBAAkB,aAAc,QAAQ,KAAG,gBAqEtD,CAAC;AAEH,eAAO,MAAM,4BAA4B,uBACnB,cAAc,KACjC,gBAA0F,CAAC;AAc9F,eAAO,MAAM,kCAAkC,aAAc,cAAc,KAAG,gBAgE7E,CAAC;AAEF,eAAO,MAAM,8BAA8B,SACnC,oBAAoB,SACpB,eAAe,KACpB,gBAuGF,CAAC;AAEF,eAAO,MAAM,gCAAgC,WAAY,YAAY,KAAG,gBActE,CAAC;AAEH,eAAO,MAAM,uBAAuB,aAAc,aAAa,KAAG,gBAmBjE,CAAC;AAEF,eAAO,MAAM,wBAAwB,aAAc,cAAc,KAAG,gBA0BnE,CAAC;AAEF,eAAO,MAAM,6BAA6B,aAAc,oBAAoB,KAAG,cAe3E,CAAC"}
+{"version":3,"file":"DeviceStateMapper.d.ts","sourceRoot":"","sources":["../../src/device/DeviceStateMapper.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,aAAa,EAEb,cAAc,EACd,YAAY,EACZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAEV,eAAe,EACf,gBAAgB,EAChB,QAAQ,EACR,cAAc,EACf,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAsDxE,eAAO,MAAM,kBAAkB,aAAc,QAAQ,KAAG,gBAqEtD,CAAC;AAEH,eAAO,MAAM,4BAA4B,uBACnB,cAAc,KACjC,gBAA0F,CAAC;AAc9F,eAAO,MAAM,kCAAkC,aAAc,cAAc,KAAG,gBAgE7E,CAAC;AAEF,eAAO,MAAM,8BAA8B,SACnC,oBAAoB,SACpB,eAAe,KACpB,gBAyGF,CAAC;AAEF,eAAO,MAAM,gCAAgC,WAAY,YAAY,KAAG,gBActE,CAAC;AAEH,eAAO,MAAM,uBAAuB,aAAc,aAAa,KAAG,gBAmBjE,CAAC;AAEF,eAAO,MAAM,wBAAwB,aAAc,cAAc,KAAG,gBA0BnE,CAAC;AAEF,eAAO,MAAM,6BAA6B,aAAc,oBAAoB,KAAG,cAe3E,CAAC"}

package/dist/index.js

@@ -44899,7 +44899,7 @@ const mapProtocolV2DeviceInfoToState = (info, mode = 'unknown') => {
         versions: definedEntries({
             firmware: imageVersion((_d = info.main_mcu) === null || _d === void 0 ? void 0 : _d.application),
             applicationP1: imageVersion((_e = info.main_mcu) === null || _e === void 0 ? void 0 : _e.application),
-            applicationP2: imageVersion((_f = info.main_mcu) === null || _f === void 0 ? void 0 : _f.application_data),
+            applicationP2: mode === 'normal' ? null : imageVersion((_f = info.main_mcu) === null || _f === void 0 ? void 0 : _f.application_data),
             bootloader: imageVersion((_g = info.main_mcu) === null || _g === void 0 ? void 0 : _g.bootloader),
             board: imageVersion((_h = info.main_mcu) === null || _h === void 0 ? void 0 : _h.romloader),
             ble: imageVersion((_j = info.coprocessor) === null || _j === void 0 ? void 0 : _j.application),
@@ -44917,8 +44917,8 @@ const mapProtocolV2DeviceInfoToState = (info, mode = 'unknown') => {
             firmwareHash: imageHash((_u = info.main_mcu) === null || _u === void 0 ? void 0 : _u.application),
             applicationP1BuildId: imageBuildId((_v = info.main_mcu) === null || _v === void 0 ? void 0 : _v.application),
             applicationP1Hash: imageHash((_w = info.main_mcu) === null || _w === void 0 ? void 0 : _w.application),
-            applicationP2BuildId: imageBuildId((_x = info.main_mcu) === null || _x === void 0 ? void 0 : _x.application_data),
-            applicationP2Hash: imageHash((_y = info.main_mcu) === null || _y === void 0 ? void 0 : _y.application_data),
+            applicationP2BuildId: mode === 'normal' ? null : imageBuildId((_x = info.main_mcu) === null || _x === void 0 ? void 0 : _x.application_data),
+            applicationP2Hash: mode === 'normal' ? null : imageHash((_y = info.main_mcu) === null || _y === void 0 ? void 0 : _y.application_data),
             bootloaderBuildId: imageBuildId((_z = info.main_mcu) === null || _z === void 0 ? void 0 : _z.bootloader),
             bootloaderHash: imageHash((_0 = info.main_mcu) === null || _0 === void 0 ? void 0 : _0.bootloader),
             boardBuildId: imageBuildId((_1 = info.main_mcu) === null || _1 === void 0 ? void 0 : _1.romloader),
@@ -52412,7 +52412,8 @@ const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
 const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
 const PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
-const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
+const PROTOCOL_V2_FILE_WRITE_RESPONSE_TIMEOUT = 10 * 1000;
+const PROTOCOL_V2_INSTALL_TIMEOUT = 10 * 60 * 1000;
 const PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY = 1000;
 const PROTOCOL_V2_INSTALL_FINISHED_AFTER_DISCONNECT_POLLS = 4;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
@@ -52891,8 +52892,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.captureProtocolV2PhysicalIdentity();
             const deviceFeatures = yield this.getProtocolV2DeviceFeatures();
-            this.protocolV2InstallBaselineVersions =
-                this.getProtocolV2ObservableTargetVersions(deviceFeatures);
+            this.protocolV2InstallBaselineVersions = this.getProtocolV2ObservableTargetVersions(deviceFeatures, this.protocolV2InitialDeviceInfo);
             this.protocolV2LastRuntimeProbeFeatures = undefined;
             const currentDeviceType = this.device.getCurrentDeviceType();
             const capabilityDeviceType = currentDeviceType === hdShared.EDeviceType.Pro2 || currentDeviceType === hdShared.EDeviceType.Neo
@@ -53297,7 +53297,9 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             app_v1: features
                 ? getDeviceFirmwareVersion(features).join('.')
                 : (_c = (_b = deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.main_mcu) === null || _b === void 0 ? void 0 : _b.application) === null || _c === void 0 ? void 0 : _c.version,
-            app_v2: (_e = (_d = deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.main_mcu) === null || _d === void 0 ? void 0 : _d.application_data) === null || _e === void 0 ? void 0 : _e.version,
+            app_v2: (features === null || features === void 0 ? void 0 : features.mode) === 'normal'
+                ? getDeviceFirmwareVersion(features).join('.')
+                : (_e = (_d = deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.main_mcu) === null || _d === void 0 ? void 0 : _d.application_data) === null || _e === void 0 ? void 0 : _e.version,
             coprocessor: features ? getDeviceBLEFirmwareVersion(features).join('.') : undefined,
             se01: (_f = features === null || features === void 0 ? void 0 : features.se01Version) !== null && _f !== void 0 ? _f : undefined,
             se02: (_g = features === null || features === void 0 ? void 0 : features.se02Version) !== null && _g !== void 0 ? _g : undefined,
@@ -53402,11 +53404,16 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             }
             this.protocolV2ExpectedSerialNumber = serialNumber;
             this.protocolV2ExpectedPath = path;
+            this.protocolV2InitialDeviceInfo = deviceInfo;
         });
     }
-    verifyProtocolV2ReconnectIdentity() {
+    verifyProtocolV2ReconnectIdentity(request) {
         return __awaiter(this, void 0, void 0, function* () {
-            const deviceInfo = yield this.requestProtocolV2PhysicalIdentity();
+            const deviceInfo = yield requestProtocolV2DeviceInfo({
+                commands: this.device.getCommands(),
+                timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
+                request,
+            });
             this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
             return deviceInfo;
         });
@@ -54158,12 +54165,18 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
         return Array.from(expectedTargetIds).filter(targetId => !reportedTargetIds.has(targetId));
     }
-    getProtocolV2ObservableTargetVersions(features) {
+    getProtocolV2ObservableTargetVersions(features, deviceInfo) {
+        var _a, _b;
         const versions = new Map();
         versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER, getDeviceBootloaderVersion(features).join('.'));
         const applicationVersion = getDeviceFirmwareVersion(features).join('.');
         versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1, applicationVersion);
-        versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2, applicationVersion);
+        const applicationP2Version = features.mode === 'normal'
+            ? applicationVersion
+            : (_b = (_a = deviceInfo === null || deviceInfo === void 0 ? void 0 : deviceInfo.main_mcu) === null || _a === void 0 ? void 0 : _a.application_data) === null || _b === void 0 ? void 0 : _b.version;
+        if (applicationP2Version) {
+            versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2, applicationP2Version);
+        }
         versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR, getDeviceBLEFirmwareVersion(features).join('.'));
         const secureElementVersions = [
             [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01, features.se01Version],
@@ -54177,17 +54190,31 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
         return versions;
     }
-    hasProtocolV2InstallVersionChanged(expectedTargetIds) {
+    hasProtocolV2InstallVersionChanged(expectedTargetIds, deviceInfo) {
         if (!this.protocolV2LastRuntimeProbeFeatures)
             return false;
-        const currentVersions = this.getProtocolV2ObservableTargetVersions(this.protocolV2LastRuntimeProbeFeatures);
-        return Array.from(expectedTargetIds).some(targetId => {
-            const previousVersion = this.protocolV2InstallBaselineVersions.get(targetId);
-            const currentVersion = currentVersions.get(targetId);
-            return (previousVersion !== undefined &&
-                currentVersion !== undefined &&
-                previousVersion !== currentVersion);
-        });
+        const currentVersions = this.getProtocolV2ObservableTargetVersions(this.protocolV2LastRuntimeProbeFeatures, deviceInfo);
+        const p1TargetId = ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1;
+        const p2TargetId = ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2;
+        return (expectedTargetIds.size > 0 &&
+            Array.from(expectedTargetIds).every(targetId => {
+                var _a, _b, _c;
+                if (targetId === p2TargetId && ((_a = this.protocolV2LastRuntimeProbeFeatures) === null || _a === void 0 ? void 0 : _a.mode) === 'normal') {
+                    if (!expectedTargetIds.has(p1TargetId))
+                        return false;
+                    const previousP1Version = this.protocolV2InstallBaselineVersions.get(p1TargetId);
+                    const currentP1Version = currentVersions.get(p1TargetId);
+                    return (previousP1Version !== undefined &&
+                        currentP1Version !== undefined &&
+                        previousP1Version !== currentP1Version &&
+                        currentP1Version === ((_c = (_b = this.params) === null || _b === void 0 ? void 0 : _b.expectedTargetVersions) === null || _c === void 0 ? void 0 : _c.app_v2));
+                }
+                const previousVersion = this.protocolV2InstallBaselineVersions.get(targetId);
+                const currentVersion = currentVersions.get(targetId);
+                return (previousVersion !== undefined &&
+                    currentVersion !== undefined &&
+                    previousVersion !== currentVersion);
+            }));
     }
     recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds) {
         expectedTargetIds.forEach(targetId => this.protocolV2CompletedTargetIds.add(targetId));
@@ -54224,8 +54251,9 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 finishedStatusSnapshotKey = undefined;
                 finishedStatusSnapshotPolls = 0;
             };
-            while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
+            for (;;) {
                 this.throwIfAborted();
+                const isFinalStatusCheck = Date.now() - startTime >= PROTOCOL_V2_INSTALL_TIMEOUT;
                 try {
                     if (shouldReconnect) {
                         const isBleInstallReconnect = this.isBleReconnect();
@@ -54347,17 +54375,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             lastError = new Error('Protocol V2 firmware status is stale; waiting for the current install to start');
                         }
                         if (statusTargets.length === 0 &&
-                            !currentDeviceInfo &&
-                            bleInstallLinkReady &&
-                            installEvidenceObserved) {
-                            currentDeviceInfo = yield this.verifyProtocolV2ReconnectIdentity();
+                            (currentDeviceInfo || bleInstallLinkReady || isFinalStatusCheck)) {
+                            currentDeviceInfo = yield this.verifyProtocolV2ReconnectIdentity(PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST);
                             deviceInfo = currentDeviceInfo;
-                        }
-                        if (statusTargets.length === 0 && currentDeviceInfo) {
                             const isNormalMode = yield this.probeProtocolV2NormalMode(currentDeviceInfo);
                             if (isNormalMode &&
                                 (installEvidenceObserved ||
-                                    this.hasProtocolV2InstallVersionChanged(expectedTargetIds))) {
+                                    this.hasProtocolV2InstallVersionChanged(expectedTargetIds, currentDeviceInfo))) {
                                 Log$6.log('[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete');
                                 this.recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds);
                                 this.postProgressMessage(100, 'installingFirmware');
@@ -54379,24 +54403,19 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         }
                     }
                     catch (error) {
-                        if (isProtocolV2TerminalInstallStatusError(error)) {
+                        if (this.isProtocolV2ReconnectIdentityError(error) ||
+                            isProtocolV2TerminalInstallStatusError(error)) {
                             throw error;
                         }
                         if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
-                            if (!currentDeviceInfo) {
-                                if (!bleInstallLinkReady) {
-                                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 device identity is unavailable during install polling');
-                                }
-                                deviceInfo = yield this.verifyProtocolV2ReconnectIdentity();
-                            }
-                            const reconnectDeviceInfo = currentDeviceInfo !== null && currentDeviceInfo !== void 0 ? currentDeviceInfo : deviceInfo;
-                            if (!reconnectDeviceInfo) {
+                            if (!currentDeviceInfo && !bleInstallLinkReady && !isFinalStatusCheck) {
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 device identity is unavailable during install polling');
                             }
-                            const isNormalMode = yield this.probeProtocolV2NormalMode(reconnectDeviceInfo);
+                            deviceInfo = yield this.verifyProtocolV2ReconnectIdentity(PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST);
+                            const isNormalMode = yield this.probeProtocolV2NormalMode(deviceInfo);
                             if (isNormalMode &&
                                 (installEvidenceObserved ||
-                                    this.hasProtocolV2InstallVersionChanged(expectedTargetIds))) {
+                                    this.hasProtocolV2InstallVersionChanged(expectedTargetIds, deviceInfo))) {
                                 Log$6.log('[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot');
                                 this.recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds);
                                 this.postProgressMessage(100, 'installingFirmware');
@@ -54437,6 +54456,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     bleInstallLinkReady = false;
                     Log$6.log('Protocol V2 firmware install device readiness probe failed: ', error);
                 }
+                if (isFinalStatusCheck)
+                    break;
                 yield hdShared.wait(1000);
             }
             Log$6.error(`[FirmwareUpdateV4] install timed out after ${PROTOCOL_V2_INSTALL_TIMEOUT / 1000}s: ${this.normalizeErrorMessage(lastError)}`);
@@ -54467,7 +54488,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
     probeProtocolV2NormalMode(deviceInfo) {
         return __awaiter(this, void 0, void 0, function* () {
-            const features = yield this.device.probeProtocolV2RuntimeState(deviceInfo, PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT);
+            const features = yield this.device.probeProtocolV2RuntimeState(deviceInfo, PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT, { forceRuntimeContextRefresh: true });
             this.protocolV2LastRuntimeProbeFeatures = features;
             return this.isProtocolV2ApplicationMode(features);
         });
@@ -54627,6 +54648,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+            const env = DataManager.getSettings('env');
             const writeRes = yield typedCall('FilesystemFileWrite', 'FilesystemFile', {
                 file: {
                     path: filePath,
@@ -54638,6 +54660,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 append: false,
                 ui_percentage: progress !== null && progress !== void 0 ? progress : undefined,
             }, {
+                timeoutMs: env === 'react-native' ? PROTOCOL_V2_FILE_WRITE_RESPONSE_TIMEOUT : undefined,
                 writeWithResponse: false,
                 onWriteCompleted: () => undefined,
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.6-alpha.0",
+  "version": "1.2.6-alpha.2",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.6-alpha.0",
-    "@onekeyfe/hd-transport": "1.2.6-alpha.0",
+    "@onekeyfe/hd-shared": "1.2.6-alpha.2",
+    "@onekeyfe/hd-transport": "1.2.6-alpha.2",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "buffer": "^6.0.3",
@@ -46,5 +46,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "9aa91a0780c3169164da575deadf5d256013d416"
+  "gitHead": "c01014c750c5c0bc4f6bff2e07b2fee985893f59"
 }

package/src/api/FirmwareUpdateV4.ts

@@ -70,7 +70,7 @@ import type {
   FirmwareUpdateV4Target,
 } from '../types/api/firmwareUpdate';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
-import type { ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+import type { DeviceInfoGet, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
 import type { TypedResponseMessage } from '../device/DeviceCommands';
 import type {
   Features,
@@ -91,7 +91,9 @@ const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
 const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
 const PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT = 15 * 1000;
-const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
+// React Native invalidates a timed-out BLE link, and V4 can safely replay the staging file.
+const PROTOCOL_V2_FILE_WRITE_RESPONSE_TIMEOUT = 10 * 1000;
+const PROTOCOL_V2_INSTALL_TIMEOUT = 10 * 60 * 1000;
 const PROTOCOL_V2_INSTALL_STATUS_INITIAL_DELAY = 1000;
 const PROTOCOL_V2_INSTALL_FINISHED_AFTER_DISCONNECT_POLLS = 4;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
@@ -577,6 +579,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2LatestFinalDeviceInfo?: ProtocolV2DeviceInfo;
 
+  private protocolV2InitialDeviceInfo?: ProtocolV2DeviceInfo;
+
   private protocolV2InstallBaselineVersions = new Map<number, string>();
 
   private protocolV2InstallNeedsReconnect = false;
@@ -814,8 +818,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async runProtocolV2() {
     await this.captureProtocolV2PhysicalIdentity();
     const deviceFeatures = await this.getProtocolV2DeviceFeatures();
-    this.protocolV2InstallBaselineVersions =
-      this.getProtocolV2ObservableTargetVersions(deviceFeatures);
+    this.protocolV2InstallBaselineVersions = this.getProtocolV2ObservableTargetVersions(
+      deviceFeatures,
+      this.protocolV2InitialDeviceInfo
+    );
     this.protocolV2LastRuntimeProbeFeatures = undefined;
     const currentDeviceType = this.device.getCurrentDeviceType();
     const capabilityDeviceType =
@@ -1382,7 +1388,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       app_v1: features
         ? getDeviceFirmwareVersion(features).join('.')
         : deviceInfo?.main_mcu?.application?.version,
-      app_v2: deviceInfo?.main_mcu?.application_data?.version,
+      // Production boot verifies P2 against P1 before normal firmware can run.
+      app_v2:
+        features?.mode === 'normal'
+          ? getDeviceFirmwareVersion(features).join('.')
+          : deviceInfo?.main_mcu?.application_data?.version,
       coprocessor: features ? getDeviceBLEFirmwareVersion(features).join('.') : undefined,
       se01: features?.se01Version ?? undefined,
       se02: features?.se02Version ?? undefined,
@@ -1511,10 +1521,15 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     }
     this.protocolV2ExpectedSerialNumber = serialNumber;
     this.protocolV2ExpectedPath = path;
+    this.protocolV2InitialDeviceInfo = deviceInfo;
   }
 
-  private async verifyProtocolV2ReconnectIdentity() {
-    const deviceInfo = await this.requestProtocolV2PhysicalIdentity();
+  private async verifyProtocolV2ReconnectIdentity(request?: DeviceInfoGet) {
+    const deviceInfo = await requestProtocolV2DeviceInfo({
+      commands: this.device.getCommands(),
+      timeoutMs: this.getProtocolV2DeviceInfoTimeout(),
+      request,
+    });
     this.assertProtocolV2DeviceInfoIdentity(deviceInfo);
     return deviceInfo;
   }
@@ -2505,7 +2520,10 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return Array.from(expectedTargetIds).filter(targetId => !reportedTargetIds.has(targetId));
   }
 
-  private getProtocolV2ObservableTargetVersions(features: Features) {
+  private getProtocolV2ObservableTargetVersions(
+    features: Features,
+    deviceInfo?: ProtocolV2DeviceInfo
+  ) {
     const versions = new Map<number, string>();
     versions.set(
       ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
@@ -2513,7 +2531,16 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     );
     const applicationVersion = getDeviceFirmwareVersion(features).join('.');
     versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1, applicationVersion);
-    versions.set(ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2, applicationVersion);
+    const applicationP2Version =
+      features.mode === 'normal'
+        ? applicationVersion
+        : deviceInfo?.main_mcu?.application_data?.version;
+    if (applicationP2Version) {
+      versions.set(
+        ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2,
+        applicationP2Version
+      );
+    }
     versions.set(
       ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR,
       getDeviceBLEFirmwareVersion(features).join('.')
@@ -2530,20 +2557,41 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     return versions;
   }
 
-  private hasProtocolV2InstallVersionChanged(expectedTargetIds: Set<number>) {
+  private hasProtocolV2InstallVersionChanged(
+    expectedTargetIds: Set<number>,
+    deviceInfo: ProtocolV2DeviceInfo
+  ) {
     if (!this.protocolV2LastRuntimeProbeFeatures) return false;
     const currentVersions = this.getProtocolV2ObservableTargetVersions(
-      this.protocolV2LastRuntimeProbeFeatures
+      this.protocolV2LastRuntimeProbeFeatures,
+      deviceInfo
+    );
+    const p1TargetId = ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1;
+    const p2TargetId = ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2;
+    return (
+      expectedTargetIds.size > 0 &&
+      Array.from(expectedTargetIds).every(targetId => {
+        if (targetId === p2TargetId && this.protocolV2LastRuntimeProbeFeatures?.mode === 'normal') {
+          // P1 must change in this install; a pre-existing P1 version cannot prove a P2-only update.
+          if (!expectedTargetIds.has(p1TargetId)) return false;
+          const previousP1Version = this.protocolV2InstallBaselineVersions.get(p1TargetId);
+          const currentP1Version = currentVersions.get(p1TargetId);
+          return (
+            previousP1Version !== undefined &&
+            currentP1Version !== undefined &&
+            previousP1Version !== currentP1Version &&
+            currentP1Version === this.params?.expectedTargetVersions?.app_v2
+          );
+        }
+        const previousVersion = this.protocolV2InstallBaselineVersions.get(targetId);
+        const currentVersion = currentVersions.get(targetId);
+        return (
+          previousVersion !== undefined &&
+          currentVersion !== undefined &&
+          previousVersion !== currentVersion
+        );
+      })
     );
-    return Array.from(expectedTargetIds).some(targetId => {
-      const previousVersion = this.protocolV2InstallBaselineVersions.get(targetId);
-      const currentVersion = currentVersions.get(targetId);
-      return (
-        previousVersion !== undefined &&
-        currentVersion !== undefined &&
-        previousVersion !== currentVersion
-      );
-    });
   }
 
   private recordProtocolV2AuthoritativeInstallCompletion(expectedTargetIds: Set<number>) {
@@ -2588,10 +2636,12 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       finishedStatusSnapshotPolls = 0;
     };
 
-    while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
+    for (;;) {
       // A transport release caused by an explicit workflow cancellation must not
       // be mistaken for the expected device reboot during installation.
       this.throwIfAborted();
+      // Read once more at the deadline so a completed reboot is not reported as a timeout.
+      const isFinalStatusCheck = Date.now() - startTime >= PROTOCOL_V2_INSTALL_TIMEOUT;
       try {
         if (shouldReconnect) {
           const isBleInstallReconnect = this.isBleReconnect();
@@ -2750,22 +2800,19 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
           if (
             statusTargets.length === 0 &&
-            !currentDeviceInfo &&
-            bleInstallLinkReady &&
-            installEvidenceObserved
+            (currentDeviceInfo || bleInstallLinkReady || isFinalStatusCheck)
           ) {
-            // BLE install reconnect skips generic probes because loaders may not answer Ping.
-            // Restore the verified identity only after current-install evidence disappears.
-            currentDeviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+            // Installation can finish while BLE is disconnected, hiding all progress.
+            // Refresh identity and target versions even without observed install status.
+            currentDeviceInfo = await this.verifyProtocolV2ReconnectIdentity(
+              PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST
+            );
             deviceInfo = currentDeviceInfo;
-          }
-
-          if (statusTargets.length === 0 && currentDeviceInfo) {
             const isNormalMode = await this.probeProtocolV2NormalMode(currentDeviceInfo);
             if (
               isNormalMode &&
               (installEvidenceObserved ||
-                this.hasProtocolV2InstallVersionChanged(expectedTargetIds))
+                this.hasProtocolV2InstallVersionChanged(expectedTargetIds, currentDeviceInfo))
             ) {
               Log.log(
                 '[FirmwareUpdateV4] empty firmware status after confirmed App reboot; update complete'
@@ -2795,33 +2842,29 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             }
           }
         } catch (error) {
-          if (isProtocolV2TerminalInstallStatusError(error)) {
+          if (
+            this.isProtocolV2ReconnectIdentityError(error) ||
+            isProtocolV2TerminalInstallStatusError(error)
+          ) {
             throw error;
           }
-          // App firmware does not register DeviceFirmwareUpdateStatusGet. Treat the
-          // missing endpoint as completion only after the runtime probe confirms App mode.
+          // Some firmware builds do not expose install status. Require a fresh runtime
+          // probe and current-install evidence or changed versions before accepting completion.
           if (isProtocolV2FirmwareStatusEndpointUnavailable(error)) {
-            if (!currentDeviceInfo) {
-              if (!bleInstallLinkReady) {
-                throw ERRORS.TypedError(
-                  HardwareErrorCode.RuntimeError,
-                  'Protocol V2 device identity is unavailable during install polling'
-                );
-              }
-              deviceInfo = await this.verifyProtocolV2ReconnectIdentity();
-            }
-            const reconnectDeviceInfo = currentDeviceInfo ?? deviceInfo;
-            if (!reconnectDeviceInfo) {
+            if (!currentDeviceInfo && !bleInstallLinkReady && !isFinalStatusCheck) {
               throw ERRORS.TypedError(
                 HardwareErrorCode.RuntimeError,
                 'Protocol V2 device identity is unavailable during install polling'
               );
             }
-            const isNormalMode = await this.probeProtocolV2NormalMode(reconnectDeviceInfo);
+            deviceInfo = await this.verifyProtocolV2ReconnectIdentity(
+              PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST
+            );
+            const isNormalMode = await this.probeProtocolV2NormalMode(deviceInfo);
             if (
               isNormalMode &&
               (installEvidenceObserved ||
-                this.hasProtocolV2InstallVersionChanged(expectedTargetIds))
+                this.hasProtocolV2InstallVersionChanged(expectedTargetIds, deviceInfo))
             ) {
               Log.log(
                 '[FirmwareUpdateV4] firmware status endpoint unavailable after confirmed App reboot'
@@ -2871,6 +2914,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         bleInstallLinkReady = false;
         Log.log('Protocol V2 firmware install device readiness probe failed: ', error);
       }
+      if (isFinalStatusCheck) break;
       await wait(1000);
     }
 
@@ -2909,7 +2953,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
   private async probeProtocolV2NormalMode(deviceInfo: ProtocolV2DeviceInfo) {
     const features = await this.device.probeProtocolV2RuntimeState(
       deviceInfo,
-      PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT
+      PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+      { forceRuntimeContextRefresh: true }
     );
     this.protocolV2LastRuntimeProbeFeatures = features;
     return this.isProtocolV2ApplicationMode(features);
@@ -3132,6 +3177,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     progress: number | null
   ): Promise<TypedResponseMessage<'FilesystemFile'>> {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+    const env = DataManager.getSettings('env');
     const writeRes = await typedCall(
       'FilesystemFileWrite',
       'FilesystemFile',
@@ -3147,6 +3193,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
         ui_percentage: progress ?? undefined,
       },
       {
+        timeoutMs: env === 'react-native' ? PROTOCOL_V2_FILE_WRITE_RESPONSE_TIMEOUT : undefined,
         writeWithResponse: false,
         onWriteCompleted: () => undefined,
       }

package/src/device/DeviceStateMapper.ts

@@ -271,7 +271,8 @@ export const mapProtocolV2DeviceInfoToState = (
     versions: definedEntries({
       firmware: imageVersion(info.main_mcu?.application),
       applicationP1: imageVersion(info.main_mcu?.application),
-      applicationP2: imageVersion(info.main_mcu?.application_data),
+      // The running application does not report P2; discard a loader-era version.
+      applicationP2: mode === 'normal' ? null : imageVersion(info.main_mcu?.application_data),
       bootloader: imageVersion(info.main_mcu?.bootloader),
       board: imageVersion(info.main_mcu?.romloader),
       ble: imageVersion(info.coprocessor?.application),
@@ -289,8 +290,9 @@ export const mapProtocolV2DeviceInfoToState = (
       firmwareHash: imageHash(info.main_mcu?.application),
       applicationP1BuildId: imageBuildId(info.main_mcu?.application),
       applicationP1Hash: imageHash(info.main_mcu?.application),
-      applicationP2BuildId: imageBuildId(info.main_mcu?.application_data),
-      applicationP2Hash: imageHash(info.main_mcu?.application_data),
+      applicationP2BuildId:
+        mode === 'normal' ? null : imageBuildId(info.main_mcu?.application_data),
+      applicationP2Hash: mode === 'normal' ? null : imageHash(info.main_mcu?.application_data),
       bootloaderBuildId: imageBuildId(info.main_mcu?.bootloader),
       bootloaderHash: imageHash(info.main_mcu?.bootloader),
       boardBuildId: imageBuildId(info.main_mcu?.romloader),