@onekeyfe/hd-core 1.2.0-alpha.3 → 1.2.0-alpha.31

package/__tests__/device-utils.test.ts

@@ -0,0 +1,106 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import {
+  getDeviceSerialNo,
+  getDeviceType,
+  getDeviceUUID,
+  getFirmwareType,
+} from '../src/utils/deviceInfoUtils';
+import {
+  getDeviceBLEFirmwareVersion,
+  getDeviceBoardloaderVersion,
+  getDeviceBootloaderVersion,
+  getDeviceFirmwareVersion,
+} from '../src/utils/deviceVersionUtils';
+import {
+  buildProtocolV1FeaturesPayload,
+  buildProtocolV2FeaturesPayload,
+} from '../src/deviceProfile';
+
+import type { PROTO } from '../src/constants';
+
+describe('device feature selectors', () => {
+  test('reads legacy Protocol V1 features without exposing the internal builder', () => {
+    const features = {
+      onekey_device_type: 'CLASSIC1S',
+      onekey_serial_no: 'CP123456',
+      fw_vendor: 'OneKey Bitcoin-only',
+      onekey_firmware_version: 'v3.5.0',
+      onekey_boot_version: '2.8.0-alpha.1',
+      onekey_board_version: '1.2.3+board',
+      onekey_ble_version: '1.4.0+ble',
+    } as PROTO.Features;
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Classic1s);
+    expect(getDeviceSerialNo(features)).toBe('CP123456');
+    expect(getFirmwareType(features)).toBe(EFirmwareType.BitcoinOnly);
+    expect(getDeviceFirmwareVersion(features)).toEqual([3, 5, 0]);
+    expect(getDeviceBootloaderVersion(features)).toEqual([2, 8, 0]);
+    expect(getDeviceBoardloaderVersion(features)).toEqual([1, 2, 3]);
+    expect(getDeviceBLEFirmwareVersion(features)).toEqual([1, 4, 0]);
+  });
+
+  test('keeps getDeviceUUID as a compatibility alias', () => {
+    const features = {
+      onekey_serial_no: 'PR123456',
+      fw_vendor: 'OneKey Bitcoin-only',
+      onekey_board_version: '1.2.3',
+      onekey_ble_version: '2.3.4',
+    } as PROTO.Features;
+
+    expect(getDeviceUUID(features)).toBe(getDeviceSerialNo(features));
+  });
+
+  test('uses bootloader version parts from old Protocol V1 firmware', () => {
+    const features = {
+      bootloader_mode: true,
+      major_version: 1,
+      minor_version: 8,
+      patch_version: 3,
+      model: '1',
+    } as PROTO.Features;
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Classic);
+    expect(getDeviceBootloaderVersion(features)).toEqual([1, 8, 3]);
+  });
+
+  test('shares Protocol V1 compatibility semantics with the internal builder', () => {
+    const rawFeatures = {
+      onekey_device_type: 'PRO',
+      onekey_serial_no: 'PR123456',
+      onekey_firmware_version: '4.16.0',
+      onekey_boot_version: '2.8.0',
+      fw_vendor: 'OneKey Bitcoin-only',
+    } as PROTO.Features;
+    const normalized = buildProtocolV1FeaturesPayload(rawFeatures);
+
+    expect(getDeviceType(normalized)).toBe(getDeviceType(rawFeatures));
+    expect(getDeviceSerialNo(normalized)).toBe(getDeviceSerialNo(rawFeatures));
+    expect(getFirmwareType(normalized)).toBe(getFirmwareType(rawFeatures));
+    expect(getDeviceFirmwareVersion(normalized)).toEqual(getDeviceFirmwareVersion(rawFeatures));
+    expect(getDeviceBootloaderVersion(normalized)).toEqual(getDeviceBootloaderVersion(rawFeatures));
+  });
+
+  test('reads normalized Protocol V2 features through the same public selectors', () => {
+    const features = buildProtocolV2FeaturesPayload({
+      deviceInfo: {
+        hw: { serial_no: 'P2-001' },
+        fw: {
+          application: { version: '5.0.0' },
+          bootloader: { version: '2.0.0' },
+          romloader: { version: '1.0.0' },
+        },
+        coprocessor: {
+          application: { version: '3.0.0' },
+        },
+      },
+    });
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Pro2);
+    expect(getDeviceSerialNo(features)).toBe('P2-001');
+    expect(getDeviceFirmwareVersion(features)).toEqual([5, 0, 0]);
+    expect(getDeviceBootloaderVersion(features)).toEqual([2, 0, 0]);
+    expect(getDeviceBoardloaderVersion(features)).toEqual([1, 0, 0]);
+    expect(getDeviceBLEFirmwareVersion(features)).toEqual([3, 0, 0]);
+  });
+});

package/__tests__/device-wallet-session-store.test.ts

@@ -0,0 +1,358 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ClearSessionCache from '../src/api/ClearSessionCache';
+import DeviceWipe from '../src/api/device/DeviceWipe';
+import {
+  DeviceWalletSessionStore,
+  deviceWalletSessionStore,
+} from '../src/device/DeviceWalletSessionStore';
+import { Device } from '../src/device/Device';
+import { createCoreApi } from '../src/inject';
+import TransportManager from '../src/data-manager/TransportManager';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('DeviceWalletSessionStore', () => {
+  test('requires passphraseState for wallet session lookup', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'session-a');
+
+    expect(store.get('device-1', undefined)).toBeUndefined();
+    expect(store.get('device-1', 'hidden-a')).toBe('session-a');
+  });
+
+  test('isolates wallets and devices', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'session-a');
+    store.set('device-1', 'hidden-b', 'session-b');
+    store.set('device-2', 'hidden-a', 'session-c');
+
+    expect(store.get('device-1', 'hidden-a')).toBe('session-a');
+    expect(store.get('device-1', 'hidden-b')).toBe('session-b');
+    expect(store.get('device-2', 'hidden-a')).toBe('session-c');
+  });
+
+  test('keeps pending sessions unreadable until wallet binding', () => {
+    const store = new DeviceWalletSessionStore();
+    store.setPending('device-1', 'pending-session');
+
+    expect(store.get('device-1', undefined)).toBeUndefined();
+    expect(store.getPending('device-1')).toBe('pending-session');
+  });
+
+  test('migrates descriptor keys to stable device ids', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('ble-path', 'hidden-a', 'session-a');
+    store.setPending('ble-path', 'pending-session');
+
+    store.reconcileDeviceIdentity({
+      temporaryKey: 'ble-path',
+      nextDeviceId: 'stable-device-id',
+    });
+
+    expect(store.get('ble-path', 'hidden-a')).toBeUndefined();
+    expect(store.get('stable-device-id', 'hidden-a')).toBe('session-a');
+    expect(store.getPending('ble-path')).toBeUndefined();
+    expect(store.getPending('stable-device-id')).toBe('pending-session');
+  });
+
+  test('drops sessions from an old stable identity without overwriting the new device', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-a', 'hidden-a', 'session-a');
+    store.setPending('device-a', 'pending-a');
+    store.set('device-b', 'hidden-a', 'session-b');
+    store.setPending('device-b', 'pending-b');
+
+    store.reconcileDeviceIdentity({
+      temporaryKey: 'ble-path',
+      previousDeviceId: 'device-a',
+      nextDeviceId: 'device-b',
+    });
+
+    expect(store.get('device-a', 'hidden-a')).toBeUndefined();
+    expect(store.getPending('device-a')).toBeUndefined();
+    expect(store.get('device-b', 'hidden-a')).toBe('session-b');
+    expect(store.getPending('device-b')).toBe('pending-b');
+  });
+
+  test('clears one wallet, one device, or all sessions', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'session-a');
+    store.set('device-1', 'hidden-b', 'session-b');
+    store.set('device-2', 'hidden-a', 'session-c');
+
+    store.delete('device-1', 'hidden-a');
+    expect(store.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(store.get('device-1', 'hidden-b')).toBe('session-b');
+
+    store.deleteDevice('device-1');
+    expect(store.get('device-1', 'hidden-b')).toBeUndefined();
+    expect(store.get('device-2', 'hidden-a')).toBe('session-c');
+
+    store.clear();
+    expect(store.get('device-2', 'hidden-a')).toBeUndefined();
+  });
+});
+
+describe('Device wipe lifecycle invalidation', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+  });
+
+  test('clears the old Protocol V2 identity and wallet sessions after wipe succeeds', async () => {
+    const device = Device.fromDescriptor({
+      id: 'pro2-descriptor',
+      path: 'pro2-path',
+      protocolType: 'V2',
+    } as never);
+    device.features = {
+      protocol: 'V2',
+      deviceId: 'old-device-id',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    device.passphraseState = 'hidden-a';
+    deviceWalletSessionStore.set('old-device-id', 'hidden-a', 'old-session');
+    deviceWalletSessionStore.set('pro2-path', 'hidden-a', 'temporary-session');
+    device.markPreInitialized({ passphraseState: 'hidden-a' });
+    device.commands = {
+      typedCall: jest.fn().mockResolvedValue({ message: { message: 'accepted' } }),
+    } as never;
+
+    const method = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'accepted' });
+
+    expect(device.features).toBeUndefined();
+    expect(device.passphraseState).toBeUndefined();
+    expect(device.needReloadDevice).toBe(true);
+    expect(device.isPreInitializedValid(60_000)).toBe(false);
+    expect(deviceWalletSessionStore.get('old-device-id', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('pro2-path', 'hidden-a')).toBeUndefined();
+  });
+});
+
+describe('ClearSessionCache', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+  });
+
+  test('uses DeviceWalletSessionStore as the only cache source', async () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
+
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
+      },
+    });
+    method.init();
+    await method.run();
+
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
+  });
+
+  test('rejects passphraseState without a deviceId instead of clearing every device', () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
+    const method = new ClearSessionCache({
+      payload: { method: 'clearSessionCache', passphraseState: 'hidden-a' },
+    });
+
+    expect(() => method.init()).toThrow('Parameter [deviceId] is required with [passphraseState].');
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBe('session-a');
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
+  });
+
+  test('keeps wallet sessions internal instead of projecting them through Features', async () => {
+    const device = Device.fromDescriptor({ id: 'one', path: 'one' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-a',
+      sessionId: 'session-a',
+      session_id: 'session-a',
+      raw: {
+        protocolV1Features: {
+          sessionId: 'session-a',
+          session_id: 'session-a',
+        },
+      },
+    } as never;
+
+    expect(device.state).not.toHaveProperty('session');
+    expect(device.getInternalState()).toBe('session-a');
+    expect(device.features).toMatchObject({
+      sessionId: null,
+      session_id: null,
+    });
+    expect(device.features).not.toHaveProperty('passphraseState');
+    expect(device.features?.raw?.protocolV1Features).not.toHaveProperty('sessionId');
+    expect(device.features?.raw?.protocolV1Features).not.toHaveProperty('session_id');
+
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
+      },
+    });
+    method.init();
+    await method.run();
+
+    expect(device.features?.sessionId).toBeNull();
+    expect(device.features?.session_id).toBeNull();
+    expect(device.state?.raw?.protocolV1Features).not.toHaveProperty('sessionId');
+    expect(device.state?.raw?.protocolV1Features).not.toHaveProperty('session_id');
+  });
+
+  test('uses only the transport path as the temporary Protocol V2 cache key', () => {
+    const device = Device.fromDescriptor({ id: 'descriptor-id' } as never);
+    device.features = {
+      protocol: 'V2',
+      passphraseState: 'hidden-a',
+      sessionId: 'session-a',
+    } as never;
+
+    expect(device.getInternalState()).toBeUndefined();
+    expect(deviceWalletSessionStore.get('descriptor-id', 'hidden-a')).toBeUndefined();
+  });
+
+  test('clears one wallet without using a device', async () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-1', 'hidden-b', 'session-b');
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
+      },
+    });
+
+    method.init();
+
+    expect(method.useDevice).toBe(false);
+    await expect(method.run()).resolves.toEqual({ cleared: true });
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-b')).toBe('session-b');
+  });
+
+  test('clears one device or the full runtime store', async () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
+
+    const clearDevice = new ClearSessionCache({
+      payload: { method: 'clearSessionCache', deviceId: 'device-1' },
+    });
+    clearDevice.init();
+    await clearDevice.run();
+
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
+
+    const clearAll = new ClearSessionCache({
+      payload: { method: 'clearSessionCache' },
+    });
+    clearAll.init();
+    await clearAll.run();
+
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBeUndefined();
+  });
+
+  test('routes cache clearing through the active CoreApi call channel', async () => {
+    const call = jest.fn().mockResolvedValue({ success: true, payload: { cleared: true } });
+    const api = createCoreApi(call as any);
+
+    await api.clearSessionCache({ deviceId: 'device-1', passphraseState: 'hidden-a' });
+
+    expect(call).toHaveBeenCalledWith({
+      method: 'clearSessionCache',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-a',
+    });
+  });
+});
+
+describe('Protocol V1 wallet identity initialization', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+    jest.restoreAllMocks();
+  });
+
+  test('verifies the live device id before sending a cached wallet session', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'cached-device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'live-device-b' },
+    });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await expect(
+      device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      expect.not.objectContaining({ session_id: 'session-a' }),
+      expect.any(Object)
+    );
+  });
+
+  test('resumes a cached V1 wallet only after the live device id matches', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
+      .mockResolvedValueOnce({
+        type: 'Features',
+        message: { device_id: 'device-a', session_id: 'session-a' },
+      });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'Initialize',
+      'Features',
+      expect.not.objectContaining({ session_id: 'session-a' }),
+      expect.any(Object)
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'Initialize',
+      'Features',
+      expect.objectContaining({
+        session_id: 'session-a',
+        passphrase_state: 'hidden-a',
+      }),
+      expect.any(Object)
+    );
+  });
+});

package/__tests__/deviceFeaturesUtils.test.ts

@@ -0,0 +1,39 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import DataManager from '../src/data-manager/DataManager';
+import {
+  getSupportProtocolV1MessageSchema,
+  supportInputPinOnSoftware,
+} from '../src/utils/deviceFeaturesUtils';
+
+import type { Features } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: () => '1.0.0',
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('getSupportProtocolV1MessageSchema', () => {
+  test('Classic Pure 在无主固件的 Bootloader 模式下使用当前协议结构', () => {
+    const features = {
+      deviceType: EDeviceType.ClassicPure,
+      bootloaderMode: true,
+      firmwarePresent: false,
+      firmwareVersion: '2.0.8',
+    } as Features;
+
+    const result = getSupportProtocolV1MessageSchema(features);
+
+    expect(result.protocolV1MessageSchema).toBe('v1CurrentSchema');
+    expect(result.messages).toBe(DataManager.messages.v1CurrentSchema);
+  });
+
+  test('Pro2 never supports entering PIN in software', () => {
+    const features = {
+      deviceType: EDeviceType.Pro2,
+      firmwareVersion: '9.9.9',
+    } as Features;
+
+    expect(supportInputPinOnSoftware(features)).toEqual({ support: false });
+  });
+});

package/__tests__/deviceSettings.test.ts

@@ -0,0 +1,103 @@
+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', () => {
+  test('returns stable SDK keys plus Pro2-only BCP-47 languages', () => {
+    expect(getLanguageConfig(EDeviceType.Pro2)).toEqual([
+      { code: 'en', label: 'English' },
+      { code: 'zh_cn', label: '简体中文' },
+      { code: 'zh_hk', label: '繁體中文（香港）' },
+      { code: 'zh-Hant-TW', label: '繁體中文（台灣）' },
+      { code: 'ja', label: '日本語' },
+      { code: 'ko', label: '한국어' },
+      { code: 'fr', label: 'Français' },
+      { code: 'de', label: 'Deutsch' },
+      { code: 'ru', label: 'Русский' },
+      { code: 'es', label: 'Español' },
+      { code: 'it', label: 'Italiano' },
+      { code: 'pt_br', label: 'Portuguese (Brazil)' },
+      { code: 'vi-Latn-VN', label: 'Tiếng Việt' },
+      { code: 'tr-Latn-TR', label: 'Türkçe' },
+      { code: 'id-Latn-ID', label: 'Bahasa Indonesia' },
+      { code: 'fil-Latn-PH', label: 'Filipino' },
+      { code: 'uk-Cyrl-UA', label: 'Українська' },
+    ]);
+  });
+
+  test('maps shared language keys and preserves Pro2-only BCP-47 tags', () => {
+    expect(mapLanguageToProtocolV2('en')).toBe('en-Latn-US');
+    expect(mapLanguageToProtocolV2('zh_cn')).toBe('zh-Hans-CN');
+    expect(mapLanguageToProtocolV2('pt_br')).toBe('pt-Latn-BR');
+    expect(mapLanguageToProtocolV2('vi-Latn-VN')).toBe('vi-Latn-VN');
+    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, '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, '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

@@ -1,3 +1,5 @@
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+
 import AllNetworkGetAddressBase from '../src/api/allnetwork/AllNetworkGetAddressBase';
 import EvmGetAddress from '../src/api/evm/EVMGetAddress';
 import EVMGetPublicKey from '../src/api/evm/EVMGetPublicKey';
@@ -5,6 +7,8 @@ import { findMethod } from '../src/api/utils';
 import { getDeviceType, getFirmwareType, getMethodVersionRange } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
 
+import type { EDeviceType } from '@onekeyfe/hd-shared';
+
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
@@ -18,7 +22,8 @@ const createDevice = (onekeyDeviceType: string) => {
   const typedCall = jest.fn();
   const features = {
     onekey_device_type: onekeyDeviceType,
-    safety_checks: 'Strict',
+    deviceType: onekeyDeviceType.toLowerCase() as EDeviceType,
+    safety_checks: Enum_SafetyCheckLevel.Strict,
   };
   return {
     typedCall,
@@ -27,8 +32,9 @@ const createDevice = (onekeyDeviceType: string) => {
       commands: {
         typedCall,
       },
-      // BaseMethod 通过 Device accessor 读取设备状态，stub 复用真实工具函数保持映射一致
+      // BaseMethod reads state through Device accessors; reuse production mappers in the stub.
       isProtocolV2: () => false,
+      getProtocol: () => 'V1' as const,
       getCurrentDeviceType: () => getDeviceType(features as any),
       getCurrentSafetyChecks: () => features.safety_checks,
       getCurrentFirmwareType: () => getFirmwareType(features as any),
@@ -65,7 +71,7 @@ describe('EVM Ledger legacy path safety checks', () => {
       await method.checkSafetyLevelOnTestNet();
 
       expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-        safety_checks: 'PromptTemporarily',
+        safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
       });
     }
   );
@@ -84,7 +90,7 @@ describe('EVM Ledger legacy path safety checks', () => {
     await method.checkSafetyLevelOnTestNet();
 
     expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
+      safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
     });
   });
 
@@ -133,7 +139,7 @@ describe('EVM Ledger legacy path safety checks', () => {
     );
 
     expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
+      safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
     });
 
     runSpy.mockRestore();
@@ -213,7 +219,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();