@onekeyfe/hd-core 1.2.0-alpha.107 → 1.2.0-alpha.108

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

@@ -0,0 +1,178 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import FirmwareUpdateV4 from '../../src/api/FirmwareUpdateV4';
+import { DataManager } from '../../src/data-manager';
+
+import type { Device } from '../../src/device/Device';
+
+jest.mock('../../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+describe('FirmwareUpdateV4 install polling', () => {
+  let getSettingsSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    getSettingsSpy = jest
+      .spyOn(DataManager, 'getSettings')
+      .mockReturnValue('react-native' as never);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('polls status instead of replaying install after React Native BLE releases', async () => {
+    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()
+      .mockRejectedValueOnce(new Error('React Native BLE transport released'))
+      .mockResolvedValueOnce({
+        message: {
+          records: [
+            {
+              target_id: 4,
+              status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+              path: 'vol0:/application_p1.bin',
+            },
+          ],
+        },
+      });
+
+    method.device = {
+      getCommands: () => ({ typedCall }),
+    } as unknown as Device;
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    const firmwareUpdate = method as unknown as {
+      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<unknown>;
+      waitForProtocolV2FirmwareUpdateComplete: (value: typeof targets) => Promise<void>;
+      reconnectProtocolV2Device: () => Promise<void>;
+      verifyProtocolV2ReconnectIdentity: () => Promise<Record<string, never>>;
+    };
+    firmwareUpdate.reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    firmwareUpdate.verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue({});
+
+    await expect(
+      firmwareUpdate.protocolV2StartFirmwareUpdate({ targets })
+    ).resolves.toBeUndefined();
+    await expect(
+      firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets)
+    ).resolves.toBeUndefined();
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall.mock.calls[0]?.[0]).toBe('DeviceFirmwareUpdateRequest');
+    expect(typedCall.mock.calls[1]?.[0]).toBe('DeviceFirmwareUpdateStatusGet');
+  });
+
+  test('does not treat an explicit workflow cancellation as an install reboot', async () => {
+    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().mockRejectedValue(new Error('React Native BLE transport released'));
+    const abortController = new AbortController();
+    abortController.abort();
+
+    method.abortSignal = abortController.signal;
+    method.device = {
+      getCommands: () => ({ typedCall }),
+    } as unknown as Device;
+
+    await expect(
+      (
+        method as unknown as {
+          protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<unknown>;
+        }
+      ).protocolV2StartFirmwareUpdate({ targets })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallQueueActionCancelled,
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test.each([
+    HardwareErrorCode.BleConnectedError,
+    HardwareErrorCode.BleCharacteristicNotifyError,
+    HardwareErrorCode.BleForceCleanRunPromise,
+    HardwareErrorCode.BleDeviceDisconnected,
+  ])('continues install polling after BLE interruption error %s', async errorCode => {
+    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().mockRejectedValue(ERRORS.TypedError(errorCode));
+
+    method.device = {
+      getCommands: () => ({ typedCall }),
+    } as unknown as Device;
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (
+        method as unknown as {
+          protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<unknown>;
+        }
+      ).protocolV2StartFirmwareUpdate({ targets })
+    ).resolves.toBeUndefined();
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test.each([
+    ['webusb', 'React Native BLE transport released'],
+    ['react-native', 'Unrelated transport failure'],
+  ])(
+    'requires both a BLE environment and an explicit transport release signal: %s / %s',
+    async (env, message) => {
+      getSettingsSpy.mockReturnValue(env);
+      const method = new FirmwareUpdateV4({
+        id: 1,
+        payload: {
+          method: 'firmwareUpdateV4',
+          connectId: 'pro2-device',
+        },
+      });
+      const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+      const typedCall = jest.fn().mockRejectedValue(new Error(message));
+
+      method.device = {
+        getCommands: () => ({ typedCall }),
+      } as unknown as Device;
+      method.postTipMessage = jest.fn();
+      method.postProgressMessage = jest.fn();
+
+      await expect(
+        (
+          method as unknown as {
+            protocolV2StartFirmwareUpdate: (params: {
+              targets: typeof targets;
+            }) => Promise<unknown>;
+          }
+        ).protocolV2StartFirmwareUpdate({ targets })
+      ).rejects.toThrow(message);
+
+      expect(method.postTipMessage).not.toHaveBeenCalled();
+      expect(method.postProgressMessage).not.toHaveBeenCalled();
+    }
+  );
+});

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

@@ -202,25 +202,61 @@ describe('getDeviceState', () => {
     expect(state.versions.se01).toBe('1.0.0');
   });
 
-  test.each(['bootloader', 'romloader'] as const)(
-    'uses ProtocolInfo to preserve %s mode without DeviceStatusGet',
-    async mode => {
+  test.each([
+    ['bootloader', EDeviceType.Pro2, DeviceType.PRO2],
+    ['romloader', EDeviceType.Pro2, DeviceType.PRO2],
+    ['bootloader', EDeviceType.Neo, DeviceType.NEO],
+    ['romloader', EDeviceType.Neo, DeviceType.NEO],
+  ] as const)(
+    'refreshes cached %s state after %s reboots into the application',
+    async (mode, deviceType, protocolV2DeviceType) => {
       const typedCall = jest.fn().mockImplementation((requestType: string) => {
-        if (requestType === 'DeviceInfoGet') {
+        if (requestType === 'ProtocolInfoRequest') {
+          return { message: protocolV2ApplicationInfo };
+        }
+        if (requestType === 'DeviceStatusGet') {
           return {
-            message: {
-              hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
+            message: { init_states: true, unlocked: true, device_id: 'wallet-1' },
+          };
+        }
+        throw new Error(`Unexpected request: ${requestType}`);
+      });
+      const device = createV2Device(typedCall);
+      device.updateState(
+        {
+          protocol: 'V2',
+          identity: { deviceType },
+          status: { mode },
+          raw: {
+            protocolV2DeviceInfo: {
+              hw: { Device_type: protocolV2DeviceType, serial_no: 'SERIAL-1' },
               fw:
                 mode === 'romloader'
                   ? { romloader: { version: '1.0.0' } }
                   : { bootloader: { version: '1.0.0' } },
             },
-          };
-        }
-        if (requestType === 'ProtocolInfoRequest') {
-          return { message: getProtocolV2LoaderInfo(mode) };
-        }
-        throw new Error(`Unexpected request: ${requestType}`);
+            protocolV2ProtocolInfo: getProtocolV2LoaderInfo(mode),
+          },
+        },
+        'initialize'
+      );
+
+      const state = await device.getDeviceState({ refreshSections: ['status'] });
+
+      expect(state.status.mode).toBe('normal');
+      expect(state.identity.deviceId).toBe('wallet-1');
+      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+        'ProtocolInfoRequest',
+        'DeviceStatusGet',
+      ]);
+    }
+  );
+
+  test.each(['bootloader', 'romloader'] as const)(
+    'keeps live %s mode after refreshing cached loader state',
+    async mode => {
+      const typedCall = jest.fn().mockResolvedValue({
+        message: getProtocolV2LoaderInfo(mode),
       });
       const device = createV2Device(typedCall);
       device.updateState(
@@ -236,7 +272,10 @@ describe('getDeviceState', () => {
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
       expect(state.status.mode).toBe(mode);
-      expect(typedCall).not.toHaveBeenCalled();
+      expect(typedCall).toHaveBeenCalledTimes(1);
+      expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+        eventless_wallet_session: true,
+      });
     }
   );
 

package/__tests__/logBlockEvent.test.ts

@@ -104,7 +104,19 @@ describe('getLogBlockLabel', () => {
     });
   });
 
-  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
+  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio'])(
+    'skips large Base64 resource payload logging for %s',
+    method => {
+      const request = { method, path: 'resource.bin', data: 'A'.repeat(1024 * 1024) };
+      expect(getLogBlockLabel(request)).toBe(method);
+      expect(getSafeLogPayload(request, method)).toEqual({
+        method,
+        payload: '[REDACTED]',
+      });
+    }
+  );
+
+  it.each(['fileWrite', 'fileRead'])(
     'keeps metadata and replaces binary payloads with their size for %s',
     method => {
       const request = { method, path: 'resource.bin', data: new Uint8Array(1024) };