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

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

@@ -0,0 +1,125 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import FirmwareUpdateV4 from '../../src/api/FirmwareUpdateV4';
+
+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', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('uses Stage, an empty write-only Request, then status polling', 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()
+      .mockResolvedValueOnce({ type: 'Success', message: {} })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            {
+              target_id: 4,
+              status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+              path: 'vol0:/application_p1.bin',
+            },
+          ],
+        },
+      });
+    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
+
+    method.device = {
+      getCommands: () => ({ typedCall, call }),
+    } as unknown as Device;
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    const firmwareUpdate = method as unknown as {
+      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
+      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 firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
+    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets);
+
+    expect(typedCall.mock.calls[0]).toEqual(['DeviceFirmwareUpdateStage', 'Success', { targets }]);
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      { returnAfterWrite: true }
+    );
+    expect(typedCall.mock.calls[1]?.[0]).toBe('DeviceFirmwareUpdateStatusGet');
+    expect(call.mock.invocationCallOrder[0]).toBeLessThan(typedCall.mock.invocationCallOrder[1]);
+  });
+
+  test('does not send Request when Stage is rejected', 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('stage rejected'));
+    const call = jest.fn();
+
+    method.device = {
+      getCommands: () => ({ typedCall, call }),
+    } as unknown as Device;
+
+    await expect(
+      (
+        method as unknown as {
+          protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
+        }
+      ).protocolV2StartFirmwareUpdate({ targets })
+    ).rejects.toThrow('stage rejected');
+
+    expect(call).not.toHaveBeenCalled();
+  });
+
+  test('does not hide an explicit workflow cancellation during status polling', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        connectId: 'pro2-ble',
+      },
+    });
+    const abortController = new AbortController();
+    abortController.abort();
+
+    method.abortSignal = abortController.signal;
+
+    await expect(
+      (
+        method as unknown as {
+          waitForProtocolV2FirmwareUpdateComplete: (
+            targets: Array<{ target_id: number; path: string }>
+          ) => Promise<void>;
+        }
+      ).waitForProtocolV2FirmwareUpdateComplete([
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+      ])
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallQueueActionCancelled,
+    });
+  });
+});

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

@@ -123,7 +123,7 @@ describe('getDeviceState', () => {
           message: {
             protocol_version: 2,
             hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
+            main_mcu: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -150,7 +150,7 @@ describe('getDeviceState', () => {
           message: {
             protocol_version: 2,
             hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0', hash: 'HASH-1' } },
+            main_mcu: { application: { version: '5.0.0', hash: 'HASH-1' } },
           },
         };
       }
@@ -182,7 +182,7 @@ describe('getDeviceState', () => {
       message: {
         protocol_version: 2,
         hw: { serial_no: 'SERIAL-1' },
-        fw: { application: { version: '5.0.0' } },
+        main_mcu: { application: { version: '5.0.0' } },
         se1: { application: { version: '1.0.0' } },
       },
     });
@@ -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' },
-              fw:
+            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' },
+              main_mcu:
                 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,
+      });
     }
   );
 
@@ -246,7 +285,7 @@ describe('getDeviceState', () => {
         return {
           message: {
             hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
+            main_mcu: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -315,7 +354,7 @@ describe('getDeviceState', () => {
         return {
           message: {
             hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
+            main_mcu: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -358,7 +397,7 @@ describe('getDeviceState', () => {
         return {
           message: {
             hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
+            main_mcu: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -543,7 +582,7 @@ describe('getDeviceState', () => {
           message: {
             protocol_version: 1,
             hw: { serial_no: 'SERIAL-1' },
-            fw: { bootloader: { version: '1.0.0' } },
+            main_mcu: { bootloader: { version: '1.0.0' } },
             se1: {},
           },
         };

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) };

package/__tests__/protocol-v2-resources.test.ts

@@ -126,6 +126,14 @@ describe('Pro2 resource configuration', () => {
     expect(parseProtocolV2ResourceManifest(resourceManifest).files).toHaveLength(9);
   });
 
+  test('uses only the resource file list from a manifest', () => {
+    expect(
+      parseProtocolV2ResourceManifest({
+        files: resourceManifest.files,
+      })
+    ).toEqual({ files: resourceManifest.files });
+  });
+
   test('rejects missing source and malformed manifest paths', () => {
     expect(() => parseProtocolV2Resources({})).toThrow('source is required');
     expect(() =>