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

package/__tests__/device-settings.test.ts

@@ -1,3 +1,6 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+
 import DeviceSettings from '../src/api/device/DeviceSettings';
 
 import type { Features } from '../src/types';
@@ -16,19 +19,59 @@ const features = {
 function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
   const typedCall = jest.fn().mockResolvedValue({ message: { message: 'Success' } });
   const updateState = jest.fn();
+  const getDeviceState = jest.fn();
   return {
     device: {
       features,
       isProtocolV2: () => protocol === 'V2',
       commands: { typedCall },
       updateState,
+      getDeviceState,
     },
     typedCall,
     updateState,
+    getDeviceState,
   };
 }
 
 describe('DeviceSettings protocol routing', () => {
+  it.each([
+    ['label', { label: 'Shared Label' }],
+    ['language', { language: 'ja-JP' }],
+    ['brightness', { brightness: 80 }],
+    ['haptic feedback', { hapticFeedback: true }],
+  ])('does not unlock Protocol V2 before changing %s', (_name, settings) => {
+    const method = new DeviceSettings({
+      id: 1,
+      payload: {
+        method: 'deviceSettings',
+        ...settings,
+      },
+    });
+
+    method.init();
+
+    expect(method.unlockPolicy).toBe('none');
+  });
+
+  it.each([
+    ['auto lock', { autoLockDelayMs: 60_000 }],
+    ['auto shutdown', { autoShutdownDelayMs: 120_000 }],
+    ['mixed settings', { brightness: 80, autoLockDelayMs: 60_000 }],
+  ])('unlocks Protocol V2 before changing %s', (_name, settings) => {
+    const method = new DeviceSettings({
+      id: 1,
+      payload: {
+        method: 'deviceSettings',
+        ...settings,
+      },
+    });
+
+    method.init();
+
+    expect(method.unlockPolicy).toBe('retry-on-locked');
+  });
+
   it('uses ApplySettings and commits the confirmed patch for Protocol V1', async () => {
     const { device, typedCall, updateState } = createDevice({ protocol: 'V1' });
     const method = new DeviceSettings({
@@ -36,7 +79,7 @@ describe('DeviceSettings protocol routing', () => {
       payload: {
         method: 'deviceSettings',
         label: 'Shared Label',
-        language: 'ja-JP',
+        language: 'ja',
       },
     });
     method.init();
@@ -45,7 +88,7 @@ describe('DeviceSettings protocol routing', () => {
     await expect(method.run()).resolves.toEqual({ message: 'Success' });
     expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
       label: 'Shared Label',
-      language: 'ja-JP',
+      language: 'ja',
       use_passphrase: undefined,
       homescreen: undefined,
       _passphrase_source: undefined,
@@ -60,7 +103,7 @@ describe('DeviceSettings protocol routing', () => {
     expect(updateState).toHaveBeenCalledWith(
       {
         identity: { label: 'Shared Label' },
-        settings: { language: 'ja-JP' },
+        settings: { language: 'ja' },
       },
       'apply-settings'
     );
@@ -73,7 +116,7 @@ describe('DeviceSettings protocol routing', () => {
       payload: {
         method: 'deviceSettings',
         label: 'Shared Label',
-        language: 'ja-JP',
+        language: 'ja',
         autoLockDelayMs: 60_000,
         hapticFeedback: true,
       },
@@ -85,7 +128,7 @@ describe('DeviceSettings protocol routing', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSettingsSet', 'Success', {
       settings: {
         label: 'Shared Label',
-        language: 'ja-JP',
+        language: 'ja-Jpan-JP',
         autolock_delay_ms: 60_000,
         haptic_feedback: true,
       },
@@ -94,7 +137,7 @@ describe('DeviceSettings protocol routing', () => {
       {
         identity: { label: 'Shared Label' },
         settings: {
-          language: 'ja-JP',
+          language: 'ja-Jpan-JP',
           autoLockDelayMs: 60_000,
           hapticFeedback: true,
         },
@@ -105,4 +148,139 @@ describe('DeviceSettings protocol routing', () => {
       expect.arrayContaining(['DeviceInfoGet', 'DeviceStatusGet', 'DeviceSettingsGet'])
     );
   });
+
+  it('uses the Pro2 passphrase page as a device-side toggle and verifies the target state', async () => {
+    const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState
+      .mockResolvedValueOnce({
+        status: { passphraseProtection: false },
+      })
+      .mockResolvedValueOnce({
+        status: { passphraseProtection: true },
+      });
+    const method = new DeviceSettings({
+      id: 3,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
+      page: DeviceSettingsPage.DevicePassphrase,
+    });
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceSettingsSet', 'Success', expect.anything());
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, { refreshSections: ['status'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['status'] });
+  });
+
+  it('does not open a Pro2 settings page when the hardware already matches the target', async () => {
+    const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState.mockResolvedValue({
+      settings: { airgapMode: false },
+    });
+    const method = new DeviceSettings({
+      id: 4,
+      payload: {
+        method: 'deviceSettings',
+        airgapMode: false,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({
+      message: 'Settings already match requested value.',
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+    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' });
+    getDeviceState.mockResolvedValue({
+      status: { passphraseProtection: false },
+    });
+    const method = new DeviceSettings({
+      id: 5,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: true,
+      },
+    });
+    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.',
+    });
+  });
+
+  it('keeps Protocol V1 passphrase settings on ApplySettings', async () => {
+    const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 6,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await method.run();
+
+    expect(typedCall).toHaveBeenCalledWith(
+      'ApplySettings',
+      'Success',
+      expect.objectContaining({ use_passphrase: true })
+    );
+    expect(getDeviceState).not.toHaveBeenCalled();
+  });
+
+  it('rejects combining a Pro2 device-side toggle with direct settings', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 7,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: true,
+        label: 'New Label',
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    expect(method.unlockPolicy).toBe('none');
+    expect(method.protocolV2UiInteraction).toBeUndefined();
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('rejects two Pro2 device-side toggles without starting an interaction', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 8,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: true,
+        airgapMode: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    expect(method.unlockPolicy).toBe('none');
+    expect(method.protocolV2UiInteraction).toBeUndefined();
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
 });

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

@@ -23,7 +23,6 @@ describe('Device state events', () => {
       {
         protocol: 'V2',
         identity: { label: 'Renamed', bleName: 'Pro2 1234' },
-        session: { sessionId: 'private-session', passphraseState: 'private-state' },
         raw: {
           protocolV2DeviceInfo: { protocol_version: 2 },
         },
@@ -31,7 +30,7 @@ describe('Device state events', () => {
       'apply-settings'
     );
 
-    expect(state?.identity.displayName).toBe('Renamed');
+    expect(state?.identity.label).toBe('Renamed');
     expect(onState).toHaveBeenCalledWith(
       device,
       expect.objectContaining({

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

@@ -35,7 +35,7 @@ describe('DeviceStateMapper', () => {
       },
       status: { mode: 'normal', initialized: true, unlocked: true },
       settings: { language: 'en-US' },
-      versions: { firmware: '4.10.1', se: '1.1.0.2' },
+      versions: { firmware: '4.10.1', se: '1.1.0.2', se01: '1.1.0.2' },
     });
   });
 
@@ -105,18 +105,21 @@ describe('DeviceStateMapper', () => {
   });
 
   test('maps Protocol V2 DeviceInfo without inventing runtime status', () => {
-    const patch = mapProtocolV2DeviceInfoToState({
-      protocol_version: 2,
-      hw: { serial_no: 'SERIAL-1' },
-      fw: {
-        application: { version: '5.0.0' },
-        bootloader: { version: '2.0.0' },
-      },
-      coprocessor: {
-        bt_adv_name: 'Pro2 1234',
-        application: { version: '1.2.3' },
-      },
-    } as ProtocolV2DeviceInfo);
+    const patch = mapProtocolV2DeviceInfoToState(
+      {
+        protocol_version: 2,
+        hw: { serial_no: 'SERIAL-1' },
+        fw: {
+          application: { version: '5.0.0' },
+          bootloader: { version: '2.0.0' },
+        },
+        coprocessor: {
+          bt_adv_name: 'Pro2 1234',
+          application: { version: '1.2.3' },
+        },
+      } as ProtocolV2DeviceInfo,
+      'normal'
+    );
 
     expect(patch.identity).toMatchObject({
       deviceType: EDeviceType.Pro2,
@@ -133,18 +136,21 @@ describe('DeviceStateMapper', () => {
   });
 
   test('keeps normal mode when Protocol V2 application and SE versions are returned together', () => {
-    const patch = mapProtocolV2DeviceInfoToState({
-      protocol_version: 2,
-      hw: { serial_no: 'SERIAL-NORMAL' },
-      fw: {
-        application: { version: '5.0.0' },
-        bootloader: { version: '2.0.0' },
-      },
-      se1: {
-        application: { version: '1.0.0', build_id: 'se-app', hash: [0x01, 0x02] },
-        bootloader: { version: '0.1.0', build_id: 'se-boot', hash: [0x03, 0x04] },
-      },
-    } as ProtocolV2DeviceInfo);
+    const patch = mapProtocolV2DeviceInfoToState(
+      {
+        protocol_version: 2,
+        hw: { serial_no: 'SERIAL-NORMAL' },
+        fw: {
+          application: { version: '5.0.0' },
+          bootloader: { version: '2.0.0' },
+        },
+        se1: {
+          application: { version: '1.0.0', build_id: 'se-app', hash: [0x01, 0x02] },
+          bootloader: { version: '0.1.0', build_id: 'se-boot', hash: [0x03, 0x04] },
+        },
+      } as ProtocolV2DeviceInfo,
+      'normal'
+    );
 
     expect(patch.status?.mode).toBe('normal');
     expect(patch.verification).toMatchObject({
@@ -161,6 +167,7 @@ describe('DeviceStateMapper', () => {
       {
         hw: { serial_no: 'SERIAL-BOOT' },
         fw: { bootloader: { version: '2.0.0' } },
+        se1: {},
       },
     ],
     [
@@ -174,7 +181,7 @@ describe('DeviceStateMapper', () => {
       },
     ],
   ] as const)('clears stale device identity in Protocol V2 %s mode', (mode, info) => {
-    const patch = mapProtocolV2DeviceInfoToState(info as ProtocolV2DeviceInfo);
+    const patch = mapProtocolV2DeviceInfoToState(info as ProtocolV2DeviceInfo, mode);
 
     expect(patch.status?.mode).toBe(mode);
     expect(patch.identity).toMatchObject({ deviceId: null });

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

@@ -3,7 +3,7 @@ import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 import { DeviceStateStore, createEmptyDeviceState } from '../src/device/DeviceStateStore';
 
 describe('DeviceStateStore', () => {
-  test('merges patches, ignores undefined and recomputes displayName', () => {
+  test('merges identity patches and ignores undefined', () => {
     const store = new DeviceStateStore(
       createEmptyDeviceState({
         deviceType: EDeviceType.Pro2,
@@ -20,11 +20,9 @@ describe('DeviceStateStore', () => {
     expect(result.state.identity).toMatchObject({
       label: 'My Wallet',
       bleName: 'Pro2 1234',
-      displayName: 'My Wallet',
     });
     expect(result.revision).toBe(2);
     expect(result.changedKeys).toContain('identity.label');
-    expect(result.changedKeys).toContain('identity.displayName');
   });
 
   test('does not advance revision when the patch has no real changes', () => {
@@ -47,22 +45,6 @@ describe('DeviceStateStore', () => {
     expect(result.changedKeys).toContain('protocolVersion');
   });
 
-  test('clears only ephemeral session state', () => {
-    const store = new DeviceStateStore(createEmptyDeviceState());
-    store.update(
-      {
-        identity: { label: 'Kept' },
-        session: { sessionId: 'session-1', passphraseState: 'state-1' },
-      },
-      'initialize'
-    );
-
-    const result = store.clearSession('transport-reconnect');
-
-    expect(result?.state.identity.label).toBe('Kept');
-    expect(result?.state.session).toBeUndefined();
-  });
-
   test('merges raw protocol sources instead of replacing the previous source', () => {
     const store = new DeviceStateStore(createEmptyDeviceState());
     const deviceInfo = { protocol_version: 2, hw: { serial_no: 'SERIAL-1' } };
@@ -97,19 +79,4 @@ describe('DeviceStateStore', () => {
       protocolV2DeviceInfo: deviceInfo,
     });
   });
-
-  test.each([
-    [EDeviceType.Classic1s, 'OneKey Classic 1S'],
-    [EDeviceType.ClassicPure, 'OneKey Classic 1S Pure'],
-    [EDeviceType.Touch, 'OneKey Touch'],
-    [EDeviceType.Pro, 'OneKey Pro'],
-    [EDeviceType.Pro2, 'OneKey Pro 2'],
-  ] as const)(
-    'uses the product display name for %s when label and BLE name are absent',
-    (type, name) => {
-      const state = createEmptyDeviceState({ deviceType: type });
-
-      expect(state.identity.displayName).toBe(name);
-    }
-  );
 });

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

@@ -4,7 +4,6 @@ import {
   deviceWalletSessionStore,
 } from '../src/device/DeviceWalletSessionStore';
 import { Device } from '../src/device/Device';
-import { DevicePool } from '../src/device/DevicePool';
 import { createCoreApi } from '../src/inject';
 
 jest.mock('../src/data/config', () => ({
@@ -45,7 +44,10 @@ describe('DeviceWalletSessionStore', () => {
     store.set('ble-path', 'hidden-a', 'session-a');
     store.setPending('ble-path', 'pending-session');
 
-    store.migrateDeviceKey('ble-path', 'stable-device-id');
+    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');
@@ -53,6 +55,25 @@ describe('DeviceWalletSessionStore', () => {
     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');
@@ -75,34 +96,48 @@ describe('DeviceWalletSessionStore', () => {
 describe('ClearSessionCache', () => {
   beforeEach(() => {
     deviceWalletSessionStore.clear();
-    DevicePool.devicesCache = {};
   });
 
-  afterEach(() => {
-    DevicePool.devicesCache = {};
-  });
+  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');
 
-  test('clears matching sessions from both runtime stores', async () => {
-    const matchingDevice = Device.fromDescriptor({ id: 'one', path: 'one' } as never);
-    matchingDevice.updateState(
-      {
-        protocol: 'V1',
-        identity: { deviceId: 'device-1' },
-        session: { sessionId: 'session-a', passphraseState: 'hidden-a' },
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
       },
-      'initialize'
-    );
-    const otherDevice = Device.fromDescriptor({ id: 'two', path: 'two' } as never);
-    otherDevice.updateState(
-      {
-        protocol: 'V1',
-        identity: { deviceId: 'device-2' },
-        session: { sessionId: 'session-b', 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('keeps legacy Features session fields as projections of the store', 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',
+        },
       },
-      'initialize'
-    );
-    DevicePool.devicesCache = { one: matchingDevice, two: otherDevice };
-    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    } as never;
+
+    expect(device.state).not.toHaveProperty('session');
+    expect(device.features).toMatchObject({
+      sessionId: 'session-a',
+      session_id: 'session-a',
+      passphraseState: 'hidden-a',
+    });
 
     const method = new ClearSessionCache({
       payload: {
@@ -114,10 +149,11 @@ describe('ClearSessionCache', () => {
     method.init();
     await method.run();
 
-    expect((matchingDevice.state as any)?.session).toBeUndefined();
-    expect((otherDevice.state as any)?.session).toEqual({
-      sessionId: 'session-b',
-      passphraseState: 'hidden-a',
+    expect(device.features?.sessionId).toBeNull();
+    expect(device.features?.session_id).toBeNull();
+    expect(device.state?.raw?.protocolV1Features).toMatchObject({
+      sessionId: 'session-a',
+      session_id: 'session-a',
     });
   });