@onekeyfe/hd-core 1.2.0-alpha.99 → 1.2.1-alpha.0

package/__tests__/device-settings.test.ts

@@ -2,6 +2,10 @@ import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import DeviceSettings from '../src/api/device/DeviceSettings';
+import { Device } from '../src/device/Device';
+import { DEVICE } from '../src/events';
+import { PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE } from '../src/protocols/protocol-v2';
+import { DEVICE_SETTINGS_NEVER_TIMEOUT_MS } from '../src/utils/deviceSettings';
 
 import type { Features } from '../src/types';
 
@@ -20,6 +24,9 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
   const typedCall = jest.fn().mockResolvedValue({ message: { message: 'Success' } });
   const updateState = jest.fn();
   const getDeviceState = jest.fn();
+  const refreshProtocolV2SettingsAfterMutation = jest.fn(() =>
+    getDeviceState({ refreshSections: ['status', 'settings'] })
+  );
   return {
     device: {
       features,
@@ -28,6 +35,7 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
       commands: { typedCall },
       updateState,
       getDeviceState,
+      refreshProtocolV2SettingsAfterMutation,
     },
     typedCall,
     updateState,
@@ -115,6 +123,39 @@ describe('DeviceSettings protocol routing', () => {
     );
   });
 
+  it('normalizes legacy Protocol V1 never values before ApplySettings', async () => {
+    const { device, typedCall, updateState } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 2,
+      payload: {
+        method: 'deviceSettings',
+        autoLockDelayMs: 0,
+        autoShutdownDelayMs: 0,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith(
+      'ApplySettings',
+      'Success',
+      expect.objectContaining({
+        auto_lock_delay_ms: DEVICE_SETTINGS_NEVER_TIMEOUT_MS,
+        auto_shutdown_delay_ms: DEVICE_SETTINGS_NEVER_TIMEOUT_MS,
+      })
+    );
+    expect(updateState).toHaveBeenCalledWith(
+      {
+        settings: {
+          autoLockDelayMs: DEVICE_SETTINGS_NEVER_TIMEOUT_MS,
+          autoShutdownDelayMs: DEVICE_SETTINGS_NEVER_TIMEOUT_MS,
+        },
+      },
+      'settings-write'
+    );
+  });
+
   it('uses DeviceSettingsSet and reloads Protocol V2 status and settings from the device', async () => {
     const { device, typedCall, updateState, getDeviceState } = createDevice({ protocol: 'V2' });
     const method = new DeviceSettings({
@@ -147,7 +188,98 @@ describe('DeviceSettings protocol routing', () => {
     expect(updateState).not.toHaveBeenCalled();
   });
 
-  it('uses the Pro2 passphrase page as a device-side toggle and verifies the target state', async () => {
+  it('reconciles stale passphrase and label after an unrelated Protocol V2 setting change', async () => {
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceSettingsSet') {
+        return { message: { message: 'Success' } };
+      }
+      if (requestType === 'DeviceStatusGet') {
+        return {
+          message: {
+            init_states: true,
+            unlocked: false,
+            passphrase_enabled: false,
+          },
+        };
+      }
+      if (requestType === 'DeviceSettingsGet') {
+        return {
+          message: {
+            label: 'Current Label',
+            brightness: 80,
+            passphrase_enable: false,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const device = Device.fromDescriptor({
+      id: 'pro2',
+      path: 'pro2',
+      protocolType: 'V2',
+    } as never);
+    (device as any).commands = { typedCall };
+    device.updateState(
+      {
+        protocol: 'V2',
+        identity: {
+          deviceType: EDeviceType.Pro2,
+          label: 'Stale Label',
+        },
+        status: {
+          mode: 'normal',
+          unlocked: false,
+          passphraseProtection: true,
+        },
+        settings: { brightness: 20 },
+        raw: {
+          protocolV2ProtocolInfo: {
+            version: 1,
+            build_fingerprint: 'application__5.0.0__abcdef0__PROD__RELEASE',
+            supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
+          },
+        },
+      },
+      'initialize'
+    );
+    const onState = jest.fn();
+    device.on(DEVICE.STATE, onState);
+    const method = new DeviceSettings({
+      id: 3,
+      payload: {
+        method: 'deviceSettings',
+        brightness: 80,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceSettingsSet',
+      'DeviceStatusGet',
+      'DeviceSettingsGet',
+    ]);
+    expect(device.state).toMatchObject({
+      identity: { label: 'Current Label' },
+      status: { passphraseProtection: false },
+      settings: { brightness: 80 },
+    });
+    expect(onState).toHaveBeenLastCalledWith(
+      device,
+      expect.objectContaining({
+        source: 'settings-read',
+        state: expect.objectContaining({
+          identity: expect.objectContaining({ label: 'Current Label' }),
+          status: expect.objectContaining({ passphraseProtection: false }),
+          settings: expect.objectContaining({ brightness: 80 }),
+        }),
+      })
+    );
+  });
+
+  it('uses the Pro2 passphrase page and refreshes device state after the toggle', async () => {
     const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
     getDeviceState
       .mockResolvedValueOnce({
@@ -229,8 +361,8 @@ describe('DeviceSettings protocol routing', () => {
     expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['settings'] });
   });
 
-  it('rejects a successful Pro2 page response when the hardware did not reach the target', async () => {
-    const { device, getDeviceState } = createDevice({ protocol: 'V2' });
+  it('persists a confirmed Pro2 passphrase enable when the refreshed state is unavailable', async () => {
+    const { device, getDeviceState, updateState } = createDevice({ protocol: 'V2' });
     getDeviceState.mockResolvedValue({
       status: { passphraseProtection: false },
     });
@@ -244,14 +376,15 @@ describe('DeviceSettings protocol routing', () => {
     method.init();
     (method as any).device = device;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.RuntimeError,
-      message: 'Protocol V2 passphrase setting did not reach the requested value.',
-    });
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(updateState).toHaveBeenCalledWith(
+      { status: { passphraseProtection: true } },
+      'settings-write'
+    );
   });
 
-  it('accepts a locked Pro2 as confirmation after disabling passphrase', async () => {
-    const { device, getDeviceState } = createDevice({ protocol: 'V2' });
+  it('persists a confirmed Pro2 passphrase disable when refreshed state is unavailable after locking', async () => {
+    const { device, getDeviceState, updateState } = createDevice({ protocol: 'V2' });
     getDeviceState
       .mockResolvedValueOnce({
         status: { unlocked: true, passphraseProtection: true },
@@ -270,6 +403,101 @@ describe('DeviceSettings protocol routing', () => {
     (method as any).device = device;
 
     await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(updateState).toHaveBeenCalledWith(
+      {
+        status: {
+          passphraseProtection: false,
+          unlockedAttachPin: false,
+        },
+      },
+      'settings-write'
+    );
+  });
+
+  it('persists a confirmed Pro2 passphrase disable when the Attach PIN session locks', async () => {
+    let statusReadCount = 0;
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceStatusGet') {
+        statusReadCount += 1;
+        return {
+          message:
+            statusReadCount === 1
+              ? {
+                  init_states: true,
+                  unlocked: true,
+                  passphrase_enabled: true,
+                  unlocked_by_attach_to_pin: true,
+                }
+              : { init_states: true, unlocked: false },
+        };
+      }
+      if (requestType === 'DeviceSettingsPageShow') {
+        return { message: { message: 'Success' } };
+      }
+      if (requestType === 'DeviceSettingsGet') {
+        return { message: { label: 'Pro 2' } };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const device = Device.fromDescriptor({
+      id: 'pro2-passphrase',
+      path: 'pro2-passphrase',
+      protocolType: 'V2',
+    } as never);
+    (device as any).commands = { typedCall };
+    device.updateState(
+      {
+        protocol: 'V2',
+        identity: { deviceType: EDeviceType.Pro2 },
+        status: {
+          mode: 'normal',
+          unlocked: true,
+          passphraseProtection: true,
+          unlockedAttachPin: true,
+        },
+        raw: {
+          protocolV2ProtocolInfo: {
+            version: 1,
+            supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
+          },
+        },
+      },
+      'initialize'
+    );
+    const method = new DeviceSettings({
+      id: 6,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: false,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+    const onState = jest.fn();
+    device.on(DEVICE.STATE, onState);
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(device.state?.status).toMatchObject({
+      unlocked: false,
+      passphraseProtection: false,
+      unlockedAttachPin: false,
+    });
+    expect(onState).toHaveBeenCalledWith(
+      device,
+      expect.objectContaining({
+        source: 'settings-write',
+        changedKeys: expect.arrayContaining([
+          'status.passphraseProtection',
+          'status.unlockedAttachPin',
+        ]),
+        state: expect.objectContaining({
+          status: expect.objectContaining({
+            passphraseProtection: false,
+            unlockedAttachPin: false,
+          }),
+        }),
+      })
+    );
   });
 
   it('keeps Protocol V1 passphrase settings on ApplySettings', async () => {

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

@@ -88,9 +88,9 @@ describe('Device state events', () => {
     expect(device.getCurrentDeviceType()).toBe(EDeviceType.Pro2);
     expect(device.getCurrentDeviceId()).toBe('wallet-id');
     expect(device.getCurrentSerialNo()).toBe('SERIAL-PRO2');
-    expect(device.getCurrentBleName()).toBe('Pro2 1234');
+    expect(device.getCurrentBleName()).toBe('Pro 2 1234');
     expect(device.getCurrentLabel()).toBeNull();
-    expect((device as any).getCurrentDisplayName()).toBe('Pro2 1234');
+    expect((device as any).getCurrentDisplayName()).toBe('Pro 2 1234');
     expect(device.getCurrentPassphraseProtection()).toBe(false);
     expect(device.getCurrentFirmwareVersionString()).toBe('5.1.2');
     expect(device.getCurrentBLEFirmwareVersionString()).toBe('0.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' },
-        fw: {
+        main_mcu: {
           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' },
@@ -136,7 +136,7 @@ describe('DeviceStateMapper', () => {
     expect(patch.identity).toMatchObject({
       deviceType: EDeviceType.Pro2,
       serialNo: 'SERIAL-1',
-      bleName: 'Pro2 1234',
+      bleName: 'Pro 2 1234',
     });
     expect(patch.versions).toMatchObject({
       firmware: '5.0.0',
@@ -172,6 +172,24 @@ describe('DeviceStateMapper', () => {
     });
   });
 
+  test('removes a truncated Find My suffix from the Protocol V2 BLE name', () => {
+    const patch = mapProtocolV2DeviceInfoToState({
+      hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
+      coprocessor: { bt_adv_name: 'Pro2 22D8 - Fin' },
+    });
+
+    expect(patch.identity?.bleName).toBe('Pro 2 22D8');
+  });
+
+  test('canonicalizes a spaced Pro2 advertisement name from DeviceInfo', () => {
+    const patch = mapProtocolV2DeviceInfoToState({
+      hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
+      coprocessor: { bt_adv_name: 'Pro 2 0088 - Find My' },
+    });
+
+    expect(patch.identity?.bleName).toBe('Pro 2 0088');
+  });
+
   test('maps the hardware model independently from Protocol V2', () => {
     const pro = mapProtocolV2DeviceInfoToState({
       protocol_version: 2,
@@ -188,7 +206,7 @@ describe('DeviceStateMapper', () => {
       {
         protocol_version: 2,
         hw: { serial_no: 'SERIAL-NORMAL' },
-        fw: {
+        main_mcu: {
           application: { version: '5.0.0' },
           bootloader: { version: '2.0.0' },
         },
@@ -214,7 +232,7 @@ describe('DeviceStateMapper', () => {
       'bootloader',
       {
         hw: { serial_no: 'SERIAL-BOOT' },
-        fw: { bootloader: { version: '2.0.0' } },
+        main_mcu: { bootloader: { version: '2.0.0' } },
         se1: {},
       },
     ],
@@ -222,7 +240,7 @@ describe('DeviceStateMapper', () => {
       'romloader',
       {
         hw: { serial_no: 'SERIAL-ROM' },
-        fw: {
+        main_mcu: {
           romloader: { version: '1.0.0' },
           bootloader: { version: '2.0.0' },
         },
@@ -241,6 +259,8 @@ describe('DeviceStateMapper', () => {
       init_states: true,
       unlocked: false,
       passphrase_enabled: true,
+      attach_to_pin_enabled: true,
+      unlocked_by_attach_to_pin: true,
       backup_required: true,
     } as DeviceStatus);
 
@@ -252,6 +272,26 @@ describe('DeviceStateMapper', () => {
       backupRequired: true,
     });
     expect(locked.status).not.toHaveProperty('passphraseProtection');
+    expect(locked.status).not.toHaveProperty('attachToPinEnabled');
+    expect(locked.status).not.toHaveProperty('unlockedAttachPin');
+  });
+
+  test('omits an unavailable attach-to-PIN status after an unlocked query failure', () => {
+    const status = mapProtocolV2DeviceStatusToState({
+      init_states: true,
+      unlocked: true,
+      passphrase_enabled: true,
+      attach_to_pin_enabled: null,
+      unlocked_by_attach_to_pin: false,
+      backup_required: false,
+    } as DeviceStatus);
+
+    expect(status.status).toMatchObject({
+      unlocked: true,
+      passphraseProtection: true,
+      unlockedAttachPin: false,
+    });
+    expect(status.status).not.toHaveProperty('attachToPinEnabled');
   });
 
   test('maps common settings into identity, status and settings sections', () => {
@@ -279,10 +319,26 @@ describe('DeviceStateMapper', () => {
         language: 'en-Latn-US',
         brightness: 80,
         autolock_delay_ms: 30_000,
+        passphrase_enable: null,
       } as DeviceSettings)
     ).toEqual({
       identity: { label: 'Pro2' },
       settings: { language: 'en', brightness: 80, autoLockDelayMs: 30_000 },
     });
   });
+
+  test('omits private Protocol V2 settings that are unavailable while locked', () => {
+    expect(
+      mapDeviceSettingsToState({
+        brightness: 80,
+        passphrase_enable: null,
+        fido_enabled: null,
+        autolock_delay_ms: null,
+        autoshutdown_delay_ms: null,
+        label: null,
+      } as DeviceSettings)
+    ).toEqual({
+      settings: { brightness: 80 },
+    });
+  });
 });

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' },
-        fw: {
+        main_mcu: {
           application: { version: '5.0.0' },
           bootloader: { version: '2.0.0' },
           romloader: { version: '1.0.0' },
@@ -123,6 +123,20 @@ describe('device feature selectors', () => {
   test('recognizes Neo discovery names before initialization', () => {
     expect(getDeviceTypeByBleName('OneKey Neo 1234')).toBe(EDeviceType.Neo);
     expect(getDeviceTypeByBleName('Neo 1234')).toBe(EDeviceType.Neo);
+    expect(getDeviceTypeByBleName('Neo22D8')).toBe(EDeviceType.Neo);
+    expect(getDeviceTypeByBleName('OneKeyNeo22D8')).toBe(EDeviceType.Neo);
+  });
+
+  test('recognizes compact Pro2 discovery names before initialization', () => {
+    expect(getDeviceTypeByBleName('Pro2 A1B2')).toBe(EDeviceType.Pro2);
+    expect(getDeviceTypeByBleName('Pro2A1B2')).toBe(EDeviceType.Pro2);
+    expect(getDeviceTypeByBleName('OneKeyPro2A1B2')).toBe(EDeviceType.Pro2);
+    expect(getDeviceTypeByBleName('Pro 2 A1B2')).toBe(EDeviceType.Pro2);
+    expect(getDeviceTypeByBleName('Pro 2 0088')).toBe(EDeviceType.Pro2);
+    expect(getDeviceTypeByBleName('OneKey Pro 2 A1B2')).toBe(EDeviceType.Pro2);
+    expect(getDeviceTypeByBleName('Pro A1B2')).toBe(EDeviceType.Pro);
+    expect(getDeviceTypeByBleName('Pro 22D8')).toBe(EDeviceType.Pro);
+    expect(getDeviceTypeByBleName('Pro 2D8F')).toBe(EDeviceType.Pro);
   });
 
   test.each([EDeviceType.Pro2, EDeviceType.Neo])(