@onekeyfe/hd-core 1.2.5 → 1.2.6-alpha.1

package/__tests__/DeviceCommands.test.ts

@@ -414,6 +414,27 @@ describe('DeviceCommands failure mapping', () => {
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceBusy });
   });
 
+  it('maps commands rejected during a Protocol V2 firmware update to DeviceBusy', async () => {
+    const commands = createCommands();
+    const message = 'Requested command not allowed while a firmware update is in progress';
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: { code: 'Failure_ProcessError', message },
+        } as any,
+        'ProtocolInfoRequest'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceBusy,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        firmwareMessage: message,
+      },
+    });
+  });
+
   it('maps the current AskPin passphrase-disabled response without relying on a subcode', async () => {
     const commands = createCommands();
 
@@ -551,6 +572,51 @@ describe('DeviceCommands failure mapping', () => {
     }
   );
 
+  it('maps the Protocol V2 seed-session busy response to DeviceBusy', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: DeviceSessionErrorCode.DeviceSessionError_UserCancelled,
+            message: 'PIN cancelled',
+          },
+        } as any,
+        'SignTx'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceBusy,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: DeviceSessionErrorCode.DeviceSessionError_UserCancelled,
+        firmwareMessage: 'PIN cancelled',
+      },
+    });
+  });
+
+  it('keeps the same Protocol V2 response as ActionCancelled for DeviceSession calls', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: DeviceSessionErrorCode.DeviceSessionError_UserCancelled,
+            message: 'PIN cancelled',
+          },
+        } as any,
+        'DeviceSessionAskPin'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.ActionCancelled,
+    });
+  });
+
   it('does not use the legacy cancellation-message fallback for Protocol V1', async () => {
     const commands = createCommands();
     (commands.device.isProtocolV2 as jest.Mock).mockReturnValue(false);

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-bootloader-mode.test.ts

@@ -1,3 +1,5 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
 import { Device } from '../src/device/Device';
 import { UI_REQUEST } from '../src/events/ui-request';
 
@@ -23,12 +25,39 @@ const createBootloaderDevice = (protocolType: 'V1' | 'V2') => {
 };
 
 describe('Pro2 bootloader mode', () => {
-  test('does not block Protocol V2 methods in bootloader mode', () => {
+  test('blocks Protocol V2 methods that are not allowed in bootloader mode', () => {
+    const device = createBootloaderDevice('V2');
+
+    expect(device.hasUnexpectedMode([], [])).toBe(UI_REQUEST.BOOTLOADER);
+  });
+
+  test('allows Protocol V2 methods that explicitly support bootloader mode', () => {
     const device = createBootloaderDevice('V2');
 
-    expect(device.hasUnexpectedMode([], [])).toBeNull();
+    expect(device.hasUnexpectedMode([UI_REQUEST.BOOTLOADER], [])).toBeNull();
   });
 
+  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
+    'blocks unsupported Protocol V2 methods in %s romloader mode',
+    deviceType => {
+      const device = createBootloaderDevice('V2');
+      device.updateState(
+        {
+          protocol: 'V2',
+          identity: { deviceType },
+          status: { mode: 'romloader', initialized: null },
+        },
+        'initialize'
+      );
+
+      expect(device.hasUnexpectedMode([], [])).toBe(UI_REQUEST.BOOTLOADER);
+      expect(device.hasUnexpectedMode([UI_REQUEST.NOT_INITIALIZE], [])).toBe(UI_REQUEST.BOOTLOADER);
+      expect(
+        device.hasUnexpectedMode([UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE], [])
+      ).toBeNull();
+    }
+  );
+
   test('keeps the Protocol V1 bootloader restriction', () => {
     const device = createBootloaderDevice('V1');