@onekeyfe/hd-core 1.2.0-alpha.20 → 1.2.0-alpha.21

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

@@ -83,7 +83,7 @@ describe('public device lifecycle events', () => {
       const internalDevice = createInitializedDevice(protocol);
 
       DevicePool.emitter.emit(DEVICE.CONNECT, internalDevice);
-      internalDevice.updateState({ identity: { label: 'Updated label' } }, 'apply-settings');
+      internalDevice.updateState({ identity: { label: 'Updated label' } }, 'settings-write');
       DevicePool.emitter.emit(DEVICE.DISCONNECT, internalDevice);
 
       const connectMessage = messages.find(message => message.type === DEVICE.CONNECT);

package/__tests__/device-settings.test.ts

@@ -1,4 +1,4 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import DeviceSettings from '../src/api/device/DeviceSettings';
@@ -24,6 +24,7 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
     device: {
       features,
       isProtocolV2: () => protocol === 'V2',
+      getCurrentDeviceType: () => (protocol === 'V2' ? EDeviceType.Pro2 : EDeviceType.Pro),
       commands: { typedCall },
       updateState,
       getDeviceState,
@@ -80,6 +81,7 @@ describe('DeviceSettings protocol routing', () => {
         method: 'deviceSettings',
         label: 'Shared Label',
         language: 'ja',
+        bluetoothEnabled: true,
       },
     });
     method.init();
@@ -98,14 +100,15 @@ describe('DeviceSettings protocol routing', () => {
       safety_checks: undefined,
       experimental_features: undefined,
       auto_shutdown_delay_ms: undefined,
+      use_ble: true,
       haptic_feedback: undefined,
     });
     expect(updateState).toHaveBeenCalledWith(
       {
         identity: { label: 'Shared Label' },
-        settings: { language: 'ja' },
+        settings: { language: 'ja', bleEnabled: true },
       },
-      'apply-settings'
+      'settings-write'
     );
   });
 
@@ -119,6 +122,7 @@ describe('DeviceSettings protocol routing', () => {
         language: 'ja',
         autoLockDelayMs: 60_000,
         hapticFeedback: true,
+        bluetoothEnabled: true,
       },
     });
     method.init();
@@ -129,6 +133,7 @@ describe('DeviceSettings protocol routing', () => {
       settings: {
         label: 'Shared Label',
         language: 'ja-Jpan-JP',
+        bt_enable: true,
         autolock_delay_ms: 60_000,
         haptic_feedback: true,
       },
@@ -137,12 +142,13 @@ describe('DeviceSettings protocol routing', () => {
       {
         identity: { label: 'Shared Label' },
         settings: {
-          language: 'ja-Jpan-JP',
+          language: 'ja',
+          bleEnabled: true,
           autoLockDelayMs: 60_000,
           hapticFeedback: true,
         },
       },
-      'apply-settings'
+      'settings-write'
     );
     expect(typedCall.mock.calls.map(call => call[0])).not.toEqual(
       expect.arrayContaining(['DeviceInfoGet', 'DeviceStatusGet', 'DeviceSettingsGet'])
@@ -283,4 +289,103 @@ describe('DeviceSettings protocol routing', () => {
     });
     expect(typedCall).not.toHaveBeenCalled();
   });
+
+  it('rejects Protocol V1-only settings on Protocol V2 without partially applying the request', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 9,
+      payload: {
+        method: 'deviceSettings',
+        label: 'Must not be partially applied',
+        safetyChecks: 0,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      message: 'Protocol V2 does not support settings: safetyChecks.',
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('rejects Protocol V2-only settings on Protocol V1 without partially applying the request', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 10,
+      payload: {
+        method: 'deviceSettings',
+        label: 'Must not be partially applied',
+        brightness: 80,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      message: 'Protocol V1 does not support settings: brightness.',
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('accepts the Protocol V2 never timeout wire value', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 11,
+      payload: {
+        method: 'deviceSettings',
+        autoLockDelayMs: 0x10000000,
+        autoShutdownDelayMs: 0x10000000,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await method.run();
+
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsSet', 'Success', {
+      settings: {
+        autolock_delay_ms: 0x10000000,
+        autoshutdown_delay_ms: 0x10000000,
+      },
+    });
+  });
+
+  it('rejects unsupported Protocol V2 timeout values before sending a command', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 12,
+      payload: {
+        method: 'deviceSettings',
+        autoLockDelayMs: 0,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('rejects unknown Protocol V1 safety check levels before sending a command', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 13,
+      payload: {
+        method: 'deviceSettings',
+        safetyChecks: 3,
+      },
+    } as never);
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
 });

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

@@ -27,7 +27,7 @@ describe('Device state events', () => {
           protocolV2DeviceInfo: { protocol_version: 2 },
         },
       },
-      'apply-settings'
+      'settings-write'
     );
 
     expect(state?.identity.label).toBe('Renamed');
@@ -36,7 +36,7 @@ describe('Device state events', () => {
       expect.objectContaining({
         state: expect.objectContaining({ revision: 1 }),
         revision: 1,
-        source: 'apply-settings',
+        source: 'settings-write',
       })
     );
     expect(onFeatures).not.toHaveBeenCalled();
@@ -96,7 +96,7 @@ describe('Device state events', () => {
         protocol: 'V1',
         identity: { label: 'Legacy' },
       },
-      'apply-settings'
+      'settings-write'
     );
 
     expect(onFeatures).toHaveBeenCalledWith(device, expect.objectContaining({ label: 'Legacy' }));

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

@@ -1,5 +1,6 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
 import {
   mapApplySettingsToState,
   mapDeviceSettingsToState,
@@ -208,22 +209,33 @@ describe('DeviceStateMapper', () => {
 
   test('maps common settings into identity, status and settings sections', () => {
     expect(
-      mapApplySettingsToState({ label: 'Renamed', use_passphrase: true, haptic_feedback: false })
+      mapApplySettingsToState({
+        label: 'Renamed',
+        use_passphrase: true,
+        haptic_feedback: false,
+        use_ble: true,
+        safety_checks: 'Strict',
+      })
     ).toEqual({
       identity: { label: 'Renamed' },
       status: { passphraseProtection: true },
-      settings: { hapticFeedback: false },
+      settings: {
+        hapticFeedback: false,
+        bleEnabled: true,
+        safetyChecks: Enum_SafetyCheckLevel.Strict,
+      },
     });
 
     expect(
       mapDeviceSettingsToState({
         label: 'Pro2',
+        language: 'en-Latn-US',
         brightness: 80,
         autolock_delay_ms: 30_000,
       } as DeviceSettings)
     ).toEqual({
       identity: { label: 'Pro2' },
-      settings: { brightness: 80, autoLockDelayMs: 30_000 },
+      settings: { language: 'en', brightness: 80, autoLockDelayMs: 30_000 },
     });
   });
 });

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

@@ -14,7 +14,7 @@ describe('DeviceStateStore', () => {
     store.update({ identity: { bleName: 'Pro2 1234', label: null } }, 'initialize');
     const result = store.update(
       { identity: { label: 'My Wallet', bleName: undefined } },
-      'apply-settings'
+      'settings-write'
     );
 
     expect(result.state.identity).toMatchObject({

package/__tests__/deviceSettings.test.ts

@@ -3,8 +3,11 @@ import { EDeviceType } from '@onekeyfe/hd-shared';
 import {
   getAutoLockOptions,
   getAutoShutDownOptions,
+  getDeviceSettingsCapabilities,
   getLanguageConfig,
+  mapLanguageFromProtocolV2,
   mapLanguageToProtocolV2,
+  PROTOCOL_V2_NEVER_TIMEOUT_MS,
 } from '../src/utils/deviceSettings';
 
 describe('Pro 2 device settings options', () => {
@@ -38,26 +41,63 @@ describe('Pro 2 device settings options', () => {
     expect(mapLanguageToProtocolV2(undefined)).toBeUndefined();
   });
 
+  test('maps Protocol V2 tags back to the shared SDK language keys', () => {
+    expect(mapLanguageFromProtocolV2('en-Latn-US')).toBe('en');
+    expect(mapLanguageFromProtocolV2('zh-Hans-CN')).toBe('zh_cn');
+    expect(mapLanguageFromProtocolV2('pt-Latn-BR')).toBe('pt_br');
+    expect(mapLanguageFromProtocolV2('vi-Latn-VN')).toBe('vi-Latn-VN');
+    expect(mapLanguageFromProtocolV2(undefined)).toBeUndefined();
+  });
+
   test('returns the firmware-supported auto-lock delays', () => {
-    expect(getAutoLockOptions(EDeviceType.Pro2)).toEqual([
-      { seconds: 30, minute: 0, hour: 0, day: 0 },
-      { seconds: 0, minute: 1, hour: 0, day: 0 },
-      { seconds: 0, minute: 2, hour: 0, day: 0 },
-      { seconds: 0, minute: 5, hour: 0, day: 0 },
-      { seconds: 0, minute: 10, hour: 0, day: 0 },
-      { seconds: 0, minute: 30, hour: 0, day: 0 },
-      { seconds: 0, minute: 0, hour: 0, day: 0 },
+    expect(getAutoLockOptions(EDeviceType.Pro2, 'V2')).toEqual([
+      { label: '30 seconds', valueMs: 30_000 },
+      { label: '1 minute', valueMs: 60_000 },
+      { label: '2 minutes', valueMs: 120_000 },
+      { label: '5 minutes', valueMs: 300_000 },
+      { label: '10 minutes', valueMs: 600_000 },
+      { label: '30 minutes', valueMs: 1_800_000 },
+      { label: 'Never', valueMs: PROTOCOL_V2_NEVER_TIMEOUT_MS },
     ]);
   });
 
   test('returns the firmware-supported auto-shutdown delays', () => {
-    expect(getAutoShutDownOptions(EDeviceType.Pro2)).toEqual([
-      { seconds: 0, minute: 1, hour: 0, day: 0 },
-      { seconds: 0, minute: 2, hour: 0, day: 0 },
-      { seconds: 0, minute: 5, hour: 0, day: 0 },
-      { seconds: 0, minute: 10, hour: 0, day: 0 },
-      { seconds: 0, minute: 30, hour: 0, day: 0 },
-      { seconds: 0, minute: 0, hour: 0, day: 0 },
+    expect(getAutoShutDownOptions(EDeviceType.Pro2, 'V2')).toEqual([
+      { label: '1 minute', valueMs: 60_000 },
+      { label: '2 minutes', valueMs: 120_000 },
+      { label: '5 minutes', valueMs: 300_000 },
+      { label: '10 minutes', valueMs: 600_000 },
+      { label: '30 minutes', valueMs: 1_800_000 },
+      { label: 'Never', valueMs: PROTOCOL_V2_NEVER_TIMEOUT_MS },
     ]);
   });
+
+  test('keeps the legacy and Protocol V2 never values protocol-specific', () => {
+    expect(getAutoLockOptions(EDeviceType.Pro, 'V1').slice(-1)[0]).toEqual({
+      label: 'Never',
+      valueMs: 0,
+    });
+    expect(getAutoLockOptions(EDeviceType.Pro2, 'V2').slice(-1)[0]).toEqual({
+      label: 'Never',
+      valueMs: PROTOCOL_V2_NEVER_TIMEOUT_MS,
+    });
+  });
+
+  test('returns one capability model for Protocol V1 and V2 consumers', () => {
+    const v1 = getDeviceSettingsCapabilities(EDeviceType.Pro, 'V1');
+    const v2 = getDeviceSettingsCapabilities(EDeviceType.Pro2, 'V2');
+
+    expect(v1.supportedFields).toEqual(
+      expect.arrayContaining(['label', 'safetyChecks', 'experimentalFeatures'])
+    );
+    expect(v1.supportedFields).not.toContain('brightness');
+    expect(v2.supportedFields).toEqual(
+      expect.arrayContaining(['label', 'brightness', 'airgapMode'])
+    );
+    expect(v2.supportedFields).not.toContain('safetyChecks');
+    expect(v2.ranges.brightness).toEqual({ min: 10, max: 100 });
+    expect(v1.safetyCheckOptions.map(option => option.value)).toEqual([0, 1, 2]);
+    expect(v2.safetyCheckOptions).toEqual([]);
+    expect(v2.onDeviceConfirmationFields).toEqual(['usePassphrase', 'airgapMode']);
+  });
 });

package/__tests__/evmLedgerLegacySafety.test.ts

@@ -4,6 +4,7 @@ import EVMGetPublicKey from '../src/api/evm/EVMGetPublicKey';
 import { findMethod } from '../src/api/utils';
 import { getDeviceType, getFirmwareType, getMethodVersionRange } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
 
 import type { EDeviceType } from '@onekeyfe/hd-shared';
 
@@ -21,7 +22,7 @@ const createDevice = (onekeyDeviceType: string) => {
   const features = {
     onekey_device_type: onekeyDeviceType,
     deviceType: onekeyDeviceType.toLowerCase() as EDeviceType,
-    safety_checks: 'Strict',
+    safety_checks: Enum_SafetyCheckLevel.Strict,
   };
   return {
     typedCall,
@@ -68,7 +69,7 @@ describe('EVM Ledger legacy path safety checks', () => {
       await method.checkSafetyLevelOnTestNet();
 
       expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-        safety_checks: 'PromptTemporarily',
+        safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
       });
     }
   );
@@ -87,7 +88,7 @@ describe('EVM Ledger legacy path safety checks', () => {
     await method.checkSafetyLevelOnTestNet();
 
     expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
+      safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
     });
   });
 
@@ -136,7 +137,7 @@ describe('EVM Ledger legacy path safety checks', () => {
     );
 
     expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
+      safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
     });
 
     runSpy.mockRestore();
@@ -216,7 +217,7 @@ describe('EVM Ledger legacy path safety checks', () => {
 
     expect(typedCall).toHaveBeenCalledTimes(1);
     expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
+      safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
     });
 
     runSpy.mockRestore();

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

@@ -1,6 +1,7 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { Device } from '../src/device/Device';
+import { DEVICE } from '../src/events';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -167,6 +168,8 @@ describe('getDeviceState', () => {
     });
     const device = createV2Device(typedCall);
     device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
+    const onState = jest.fn();
+    device.on(DEVICE.STATE, onState);
 
     const state = await device.getDeviceState({ refreshSections: ['settings'] });
 
@@ -179,6 +182,10 @@ describe('getDeviceState', () => {
     expect(state.identity.label).toBe('Renamed Pro 2');
     expect(state.settings.language).toBe('ja-JP');
     expect(state.settings.brightness).toBe(70);
+    expect(onState).toHaveBeenCalledWith(
+      device,
+      expect.objectContaining({ source: 'settings-read' })
+    );
   });
 
   test('refreshes Protocol V2 status before settings in a combined read', async () => {