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

package/__tests__/DeviceCommands.test.ts

@@ -193,7 +193,7 @@ describe('DeviceCommands failure mapping', () => {
               Device_type: 7,
               hardware_version: '1.0.0',
             },
-            main_mcu: {
+            fw: {
               application: {
                 version: '5.0.0',
                 build_id: '20260811',
@@ -218,7 +218,7 @@ describe('DeviceCommands failure mapping', () => {
               Device_type: 7,
               hardware_version: '1.0.0',
             },
-            main_mcu: {
+            fw: {
               application: {
                 version: '5.0.0',
                 build_id: '20260811',

package/__tests__/device-lifecycle-events.test.ts

@@ -353,7 +353,7 @@ describe('public device lifecycle events', () => {
             message: {
               protocol_version: 2,
               hw: { Device_type: protocolV2DeviceType, serial_no: 'SERIAL-001' },
-              main_mcu: { application: { version: '5.0.0' } },
+              fw: { application: { version: '5.0.0' } },
             },
           };
         }

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

@@ -115,7 +115,7 @@ describe('DeviceStateMapper', () => {
       {
         protocol_version: 2,
         hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
-        main_mcu: {
+        fw: {
           application: { version: '5.0.0', build_id: 'p1-build', hash: [0x01, 0x02] },
           application_data: { version: '5.0.1', build_id: 'p2-build', hash: [0x03, 0x04] },
           bootloader: { version: '2.0.0' },
@@ -188,7 +188,7 @@ describe('DeviceStateMapper', () => {
       {
         protocol_version: 2,
         hw: { serial_no: 'SERIAL-NORMAL' },
-        main_mcu: {
+        fw: {
           application: { version: '5.0.0' },
           bootloader: { version: '2.0.0' },
         },
@@ -214,7 +214,7 @@ describe('DeviceStateMapper', () => {
       'bootloader',
       {
         hw: { serial_no: 'SERIAL-BOOT' },
-        main_mcu: { bootloader: { version: '2.0.0' } },
+        fw: { bootloader: { version: '2.0.0' } },
         se1: {},
       },
     ],
@@ -222,7 +222,7 @@ describe('DeviceStateMapper', () => {
       'romloader',
       {
         hw: { serial_no: 'SERIAL-ROM' },
-        main_mcu: {
+        fw: {
           romloader: { version: '1.0.0' },
           bootloader: { version: '2.0.0' },
         },

package/__tests__/device-utils.test.ts

@@ -89,7 +89,7 @@ describe('device feature selectors', () => {
     const features = buildProtocolV2FeaturesPayload({
       deviceInfo: {
         hw: { Device_type: DeviceType.PRO2, serial_no: 'P2-001' },
-        main_mcu: {
+        fw: {
           application: { version: '5.0.0' },
           bootloader: { version: '2.0.0' },
           romloader: { version: '1.0.0' },

package/__tests__/firmware-update/firmware-update-v3-reconnect.test.ts

@@ -1,6 +1,7 @@
 import * as hdShared from '@onekeyfe/hd-shared';
 
 import FirmwareUpdateV3 from '../../src/api/FirmwareUpdateV3';
+import { DataManager } from '../../src/data-manager';
 import { DevicePool } from '../../src/device/DevicePool';
 
 import type { Device } from '../../src/device/Device';
@@ -112,10 +113,125 @@ describe('FirmwareUpdateV3 reconnect', () => {
         })
       ).rejects.toBe(reconnectError);
 
+      expect(commands.typedCall).toHaveBeenCalledWith('GetFeatures', 'Features', {});
       expect(waitForDeviceReconnect).toHaveBeenCalledWith(3 * 60 * 1000);
     } finally {
       jest.clearAllTimers();
       jest.useRealTimers();
     }
   });
+
+  it('lets Browser WebUSB clean up a timed out install probe before reconnecting', async () => {
+    jest.spyOn(hdShared, 'wait').mockResolvedValue(undefined);
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(true);
+    const method = new FirmwareUpdateV3({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV3',
+        connectId: 'webusb-device',
+      },
+    });
+    const reconnectError = new Error('stop after WebUSB reconnect assertion');
+    const waitForDeviceReconnect = jest
+      .spyOn(method, 'waitForDeviceReconnect')
+      .mockRejectedValue(reconnectError);
+    method.isBleReconnect = jest.fn(() => false);
+    method.params = {
+      platform: 'web',
+    } as any;
+    const commands = {
+      typedCall: jest.fn().mockRejectedValue(new Error('Protocol V1 read timeout after 3000ms')),
+    };
+    method.device = {
+      features: {},
+      getCommands: () => commands,
+    } as unknown as Device;
+    (method as any).createUpdatesFolderIfNotExists = jest.fn().mockResolvedValue(undefined);
+    (method as any).startEmmcFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
+    method.postTipMessage = jest.fn();
+    method.postProcessingMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (method as any).executeUpdate({
+        resourceBinary: null,
+        resourceEntries: [],
+        fwSources: [],
+        bootloaderSource: null,
+      })
+    ).rejects.toBe(reconnectError);
+
+    expect(commands.typedCall).toHaveBeenCalledWith(
+      'GetFeatures',
+      'Features',
+      {},
+      {
+        timeoutMs: 3000,
+      }
+    );
+    expect(waitForDeviceReconnect).toHaveBeenCalledWith(60 * 1000);
+  });
+
+  it('does not treat cached firmware versions as Browser WebUSB install completion', async () => {
+    jest.spyOn(hdShared, 'wait').mockResolvedValue(undefined);
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(true);
+    const method = new FirmwareUpdateV3({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV3',
+        connectId: 'webusb-device',
+      },
+    });
+    method.params = {
+      platform: 'web',
+    } as any;
+    const commands = {
+      typedCall: jest
+        .fn()
+        .mockResolvedValueOnce({
+          type: 'Features',
+          message: {
+            major_version: 0,
+            minor_version: 0,
+            patch_version: 0,
+          },
+        })
+        .mockResolvedValueOnce({
+          type: 'Features',
+          message: {
+            major_version: 4,
+            minor_version: 21,
+            patch_version: 0,
+            onekey_ble_version: '2.3.7',
+          },
+        }),
+    };
+    method.device = {
+      features: {
+        firmwareVersion: '4.21.0',
+        bleVersion: '2.3.7',
+      },
+      getCommands: () => commands,
+    } as unknown as Device;
+    (method as any).createUpdatesFolderIfNotExists = jest.fn().mockResolvedValue(undefined);
+    (method as any).startEmmcFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
+    method.postTipMessage = jest.fn();
+    method.postProcessingMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    const result = await (method as any).executeUpdate({
+      resourceBinary: null,
+      resourceEntries: [],
+      fwSources: [],
+      bootloaderSource: null,
+    });
+
+    expect(commands.typedCall).toHaveBeenCalledTimes(2);
+    expect(result).toMatchObject({
+      firmwareVersion: '4.21.0',
+      bleVersion: '2.3.7',
+    });
+  });
 });

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

@@ -1,6 +1,7 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+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';
 
@@ -10,11 +11,19 @@ jest.mock('../../src/data/config', () => ({
 }));
 
 describe('FirmwareUpdateV4 install polling', () => {
+  let getSettingsSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    getSettingsSpy = jest
+      .spyOn(DataManager, 'getSettings')
+      .mockReturnValue('react-native' as never);
+  });
+
   afterEach(() => {
     jest.restoreAllMocks();
   });
 
-  test('uses Stage, an empty write-only Request, then status polling', async () => {
+  test('polls status instead of replaying install after React Native BLE releases', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -25,9 +34,8 @@ describe('FirmwareUpdateV4 install polling', () => {
     const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
     const typedCall = jest
       .fn()
-      .mockResolvedValueOnce({ type: 'Success', message: {} })
+      .mockRejectedValueOnce(new Error('React Native BLE transport released'))
       .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
         message: {
           records: [
             {
@@ -38,16 +46,15 @@ describe('FirmwareUpdateV4 install polling', () => {
           ],
         },
       });
-    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
 
     method.device = {
-      getCommands: () => ({ typedCall, call }),
+      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<void>;
+      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<unknown>;
       waitForProtocolV2FirmwareUpdateComplete: (value: typeof targets) => Promise<void>;
       reconnectProtocolV2Device: () => Promise<void>;
       verifyProtocolV2ReconnectIdentity: () => Promise<Record<string, never>>;
@@ -55,20 +62,19 @@ describe('FirmwareUpdateV4 install polling', () => {
     firmwareUpdate.reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
     firmwareUpdate.verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue({});
 
-    await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
-    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets);
+    await expect(
+      firmwareUpdate.protocolV2StartFirmwareUpdate({ targets })
+    ).resolves.toBeUndefined();
+    await expect(
+      firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets)
+    ).resolves.toBeUndefined();
 
-    expect(typedCall.mock.calls[0]).toEqual(['DeviceFirmwareUpdateStage', 'Success', { targets }]);
-    expect(call).toHaveBeenCalledWith(
-      'DeviceFirmwareUpdateRequest',
-      {},
-      { returnAfterWrite: true }
-    );
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall.mock.calls[0]?.[0]).toBe('DeviceFirmwareUpdateRequest');
     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 () => {
+  test('does not treat an explicit workflow cancellation as an install reboot', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -77,25 +83,34 @@ describe('FirmwareUpdateV4 install polling', () => {
       },
     });
     const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
-    const typedCall = jest.fn().mockRejectedValue(new Error('stage rejected'));
-    const call = jest.fn();
+    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, call }),
+      getCommands: () => ({ typedCall }),
     } as unknown as Device;
 
     await expect(
       (
         method as unknown as {
-          protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
+          protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<unknown>;
         }
       ).protocolV2StartFirmwareUpdate({ targets })
-    ).rejects.toThrow('stage rejected');
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallQueueActionCancelled,
+    });
 
-    expect(call).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledTimes(1);
   });
 
-  test('does not hide an explicit workflow cancellation during status polling', async () => {
+  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: {
@@ -103,23 +118,61 @@ describe('FirmwareUpdateV4 install polling', () => {
         connectId: 'pro2-ble',
       },
     });
-    const abortController = new AbortController();
-    abortController.abort();
+    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+    const typedCall = jest.fn().mockRejectedValue(ERRORS.TypedError(errorCode));
 
-    method.abortSignal = abortController.signal;
+    method.device = {
+      getCommands: () => ({ typedCall }),
+    } as unknown as Device;
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
 
     await expect(
       (
         method as unknown as {
-          waitForProtocolV2FirmwareUpdateComplete: (
-            targets: Array<{ target_id: number; path: string }>
-          ) => Promise<void>;
+          protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<unknown>;
         }
-      ).waitForProtocolV2FirmwareUpdateComplete([
-        { target_id: 4, path: 'vol0:/application_p1.bin' },
-      ])
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.CallQueueActionCancelled,
-    });
+      ).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

@@ -123,7 +123,7 @@ describe('getDeviceState', () => {
           message: {
             protocol_version: 2,
             hw: { serial_no: 'SERIAL-1' },
-            main_mcu: { application: { version: '5.0.0' } },
+            fw: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -150,7 +150,7 @@ describe('getDeviceState', () => {
           message: {
             protocol_version: 2,
             hw: { serial_no: 'SERIAL-1' },
-            main_mcu: { application: { version: '5.0.0', hash: 'HASH-1' } },
+            fw: { application: { version: '5.0.0', hash: 'HASH-1' } },
           },
         };
       }
@@ -182,7 +182,7 @@ describe('getDeviceState', () => {
       message: {
         protocol_version: 2,
         hw: { serial_no: 'SERIAL-1' },
-        main_mcu: { application: { version: '5.0.0' } },
+        fw: { application: { version: '5.0.0' } },
         se1: { application: { version: '1.0.0' } },
       },
     });
@@ -230,7 +230,7 @@ describe('getDeviceState', () => {
           raw: {
             protocolV2DeviceInfo: {
               hw: { Device_type: protocolV2DeviceType, serial_no: 'SERIAL-1' },
-              main_mcu:
+              fw:
                 mode === 'romloader'
                   ? { romloader: { version: '1.0.0' } }
                   : { bootloader: { version: '1.0.0' } },
@@ -285,7 +285,7 @@ describe('getDeviceState', () => {
         return {
           message: {
             hw: { serial_no: 'SERIAL-1' },
-            main_mcu: { application: { version: '5.0.0' } },
+            fw: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -354,7 +354,7 @@ describe('getDeviceState', () => {
         return {
           message: {
             hw: { serial_no: 'SERIAL-1' },
-            main_mcu: { application: { version: '5.0.0' } },
+            fw: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -397,7 +397,7 @@ describe('getDeviceState', () => {
         return {
           message: {
             hw: { serial_no: 'SERIAL-1' },
-            main_mcu: { application: { version: '5.0.0' } },
+            fw: { application: { version: '5.0.0' } },
           },
         };
       }
@@ -582,7 +582,7 @@ describe('getDeviceState', () => {
           message: {
             protocol_version: 1,
             hw: { serial_no: 'SERIAL-1' },
-            main_mcu: { bootloader: { version: '1.0.0' } },
+            fw: { bootloader: { version: '1.0.0' } },
             se1: {},
           },
         };

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

@@ -126,26 +126,6 @@ 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('ignores release metadata and accepts a partial resource file set', () => {
-    expect(
-      parseProtocolV2ResourceManifest({
-        schema: 1,
-        variant: 'dev_resource',
-        restore_mode: 'bootloader_update',
-        trees: [],
-        files: [resourceManifest.files[0]],
-      })
-    ).toEqual({ files: [resourceManifest.files[0]] });
-  });
-
   test('rejects missing source and malformed manifest paths', () => {
     expect(() => parseProtocolV2Resources({})).toThrow('source is required');
     expect(() =>