@onekeyfe/hd-core 1.2.0-alpha.12 → 1.2.0-alpha.121

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

@@ -0,0 +1,191 @@
+import { DevicePool } from '../src/device/DevicePool';
+import { Device } from '../src/device/Device';
+import { DEVICE } from '../src/events';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('DevicePool state lifecycle', () => {
+  beforeEach(() => {
+    DevicePool.dispose();
+  });
+
+  afterEach(() => {
+    DevicePool.dispose();
+  });
+
+  test('refreshes runtime state for a cached Protocol V2 discovery result', async () => {
+    const descriptor = { path: 'pro2-path', protocolType: 'V2' } as any;
+    const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'normal' } });
+    const device = {
+      originalDescriptor: descriptor,
+      updateDescriptor: jest.fn(),
+      isProtocolV2: () => true,
+      getDeviceState,
+      run: jest.fn(async (callback: () => Promise<void>) => callback()),
+    } as any;
+    DevicePool.devicesCache = { 'pro2-id': device };
+
+    await DevicePool.getDevices([descriptor], 'pro2-id', {
+      connectProtocol: 'V2',
+      refreshRuntimeState: true,
+    });
+
+    expect(device.run).toHaveBeenCalledTimes(1);
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, { refreshSections: ['status'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['settings'] });
+  });
+
+  test('refreshes Protocol V2 discovery state without legacy-specific options', async () => {
+    const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'bootloader' } });
+    const run = jest.fn(async (callback: () => Promise<void>) => callback());
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState,
+      run,
+    } as any;
+
+    await (DevicePool as any)._refreshRuntimeState(device, {
+      refreshRuntimeState: true,
+    });
+
+    expect(run).toHaveBeenCalledWith(expect.any(Function), {
+      connectProtocol: undefined,
+      forceProtocolDetection: undefined,
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, {
+      refreshSections: ['status'],
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['settings'],
+    });
+  });
+
+  test('actively re-detects a cached device when protocol detection is forced', async () => {
+    const descriptor = { path: 'cached-path', protocolType: 'V1' } as any;
+    const device = Device.fromDescriptor(descriptor);
+    const acquire = jest.spyOn(device, 'acquire').mockImplementation(() => {
+      device.originalDescriptor.protocolType = 'V2';
+      return Promise.resolve(true);
+    });
+    const initialize = jest.spyOn(device, 'initialize').mockResolvedValue(undefined);
+    const release = jest.spyOn(device, 'release').mockResolvedValue(undefined);
+    DevicePool.devicesCache = { 'cached-id': device };
+
+    const result = await DevicePool.getDevices([descriptor], 'cached-id', {
+      forceProtocolDetection: true,
+    });
+
+    expect(acquire).toHaveBeenCalledWith(undefined, { forceProtocolDetection: true });
+    expect(initialize).toHaveBeenCalledWith({ forceProtocolDetection: true });
+    expect(release).toHaveBeenCalledTimes(1);
+    expect(device.originalDescriptor.protocolType).toBe('V2');
+    expect(result.deviceList).toEqual([device]);
+  });
+
+  test('keeps a discovered device when its Protocol V2 label cannot be read', async () => {
+    const labelError = new Error('settings unavailable');
+    const getDeviceState = jest
+      .fn()
+      .mockResolvedValueOnce({ status: { mode: 'normal' } })
+      .mockRejectedValueOnce(labelError);
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState,
+      run: jest.fn(async (callback: () => Promise<void>) => callback()),
+    } as any;
+
+    await expect(
+      (DevicePool as any)._refreshRuntimeState(device, { refreshRuntimeState: true })
+    ).resolves.toBeUndefined();
+    expect(getDeviceState).toHaveBeenCalledTimes(2);
+  });
+
+  test('uses the disconnected descriptor and invalidates its cached state', () => {
+    const descriptor = { path: 'pro2-path', protocolType: 'V2' } as any;
+    const device = {
+      originalDescriptor: descriptor,
+      markTransportDisconnected: jest.fn(),
+    } as any;
+    DevicePool.devicesCache = { 'pro2-id': device };
+    DevicePool.disconnectPool = [descriptor];
+    const onDisconnect = jest.fn();
+    DevicePool.emitter.on(DEVICE.DISCONNECT, onDisconnect);
+
+    (DevicePool as any)._sendDisconnectMessage();
+
+    expect(device.markTransportDisconnected).toHaveBeenCalledTimes(1);
+    expect(onDisconnect).toHaveBeenCalledWith(device);
+    expect(DevicePool.disconnectPool).toEqual([]);
+  });
+
+  test('preserves shared listeners when resetting cached device state', () => {
+    const listener = jest.fn();
+    DevicePool.emitter.on(DEVICE.CONNECT, listener);
+    DevicePool.devicesCache = { stale: {} as Device };
+
+    DevicePool.resetState();
+    DevicePool.emitter.emit(DEVICE.CONNECT, { path: 'next-device' });
+
+    expect(DevicePool.devicesCache).toEqual({});
+    expect(listener).toHaveBeenCalledWith({ path: 'next-device' });
+  });
+
+  test('releases a newly created device when initialization fails', async () => {
+    const descriptor = { path: 'pro2-path', protocolType: 'V2' } as any;
+    const release = jest.fn().mockResolvedValue(undefined);
+    const device = {
+      connect: jest.fn().mockResolvedValue(true),
+      initialize: jest.fn().mockRejectedValue(new Error('initialize failed')),
+      release,
+    } as any;
+    const fromDescriptor = jest.spyOn(Device, 'fromDescriptor').mockReturnValue(device);
+
+    try {
+      await expect((DevicePool as any)._createDevice(descriptor)).rejects.toThrow(
+        'initialize failed'
+      );
+    } finally {
+      fromDescriptor.mockRestore();
+    }
+
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+
+  test('releases the cached device before surfacing a runtime refresh error', async () => {
+    const refreshError = new Error('status failed');
+    let callbackRejected = false;
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState: jest.fn().mockRejectedValue(refreshError),
+      run: jest.fn(async (callback: () => Promise<void>) => {
+        try {
+          await callback();
+        } catch {
+          callbackRejected = true;
+        }
+      }),
+    } as any;
+
+    await expect(
+      (DevicePool as any)._refreshRuntimeState(device, { refreshRuntimeState: true })
+    ).rejects.toBe(refreshError);
+    expect(callbackRejected).toBe(false);
+  });
+
+  test('releases an acquired device when reinitialization fails', async () => {
+    const device = Device.fromDescriptor({ path: 'pro2-path', protocolType: 'V2' } as any);
+    (device as any).commands = { disposed: true };
+    jest.spyOn(device, 'acquire').mockResolvedValue(true);
+    jest.spyOn(device, 'initialize').mockRejectedValue(new Error('reinitialize failed'));
+    const release = jest.spyOn(device, 'release').mockResolvedValue(undefined);
+
+    await expect(device.run(jest.fn().mockResolvedValue(undefined))).rejects.toThrow(
+      'reinitialize failed'
+    );
+
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+});

package/__tests__/device-settings.test.ts

@@ -0,0 +1,484 @@
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+
+import DeviceSettings from '../src/api/device/DeviceSettings';
+import { DEVICE_SETTINGS_NEVER_TIMEOUT_MS } from '../src/utils/deviceSettings';
+
+import type { Features } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+const features = {
+  protocol: 'V2',
+  label: 'Old Label',
+  language: 'en-US',
+} as 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',
+      getCurrentDeviceType: () => (protocol === 'V2' ? EDeviceType.Pro2 : EDeviceType.Pro),
+      commands: { typedCall },
+      updateState,
+      getDeviceState,
+    },
+    typedCall,
+    updateState,
+    getDeviceState,
+  };
+}
+
+describe('DeviceSettings protocol routing', () => {
+  it.each([
+    ['language', { language: 'ja-JP' }],
+    ['brightness', { brightness: 80 }],
+    ['haptic feedback', { hapticFeedback: true }],
+    ['animation', { animationEnabled: true }],
+    ['tap to wake', { tapToWake: true }],
+    ['device name display', { deviceNameDisplayEnabled: 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([
+    ['label', { label: 'Shared Label' }],
+    ['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('unlock-before-run');
+  });
+
+  it('uses ApplySettings and refreshes Protocol V1 settings from the device', async () => {
+    const { device, typedCall, updateState } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 1,
+      payload: {
+        method: 'deviceSettings',
+        label: 'Shared Label',
+        language: 'ja',
+        bluetoothEnabled: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
+      label: 'Shared Label',
+      language: 'ja',
+      use_passphrase: undefined,
+      homescreen: undefined,
+      _passphrase_source: undefined,
+      auto_lock_delay_ms: undefined,
+      display_rotation: undefined,
+      passphrase_always_on_device: undefined,
+      safety_checks: undefined,
+      experimental_features: undefined,
+      auto_shutdown_delay_ms: undefined,
+      use_ble: true,
+      haptic_feedback: undefined,
+    });
+    expect(device.getDeviceState).toHaveBeenCalledWith({ refreshSections: ['settings'] });
+    expect(updateState).not.toHaveBeenCalled();
+  });
+
+  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(device.getDeviceState).toHaveBeenCalledWith({ refreshSections: ['settings'] });
+    expect(updateState).not.toHaveBeenCalled();
+  });
+
+  it('refreshes Protocol V1 settings after the on-device brightness update completes', async () => {
+    const { device, typedCall, updateState, getDeviceState } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 3,
+      payload: {
+        method: 'deviceSettings',
+        changeBrightness: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith(
+      'ApplySettings',
+      'Success',
+      expect.objectContaining({ change_brightness: true })
+    );
+    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['settings'] });
+    expect(typedCall.mock.invocationCallOrder[0]).toBeLessThan(
+      getDeviceState.mock.invocationCallOrder[0]
+    );
+    expect(updateState).not.toHaveBeenCalled();
+  });
+
+  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({
+      id: 2,
+      payload: {
+        method: 'deviceSettings',
+        label: 'Shared Label',
+        language: 'ja',
+        autoLockDelayMs: 60_000,
+        hapticFeedback: true,
+        bluetoothEnabled: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsSet', 'Success', {
+      settings: {
+        label: 'Shared Label',
+        language: 'ja-Jpan-JP',
+        bt_enable: true,
+        autolock_delay_ms: 60_000,
+        haptic_feedback: true,
+      },
+    });
+    expect(getDeviceState).toHaveBeenCalledWith({
+      refreshSections: ['status', 'settings'],
+    });
+    expect(updateState).not.toHaveBeenCalled();
+  });
+
+  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', 'settings'],
+    });
+  });
+
+  it('reloads Protocol V2 status and settings after changing air-gap mode', async () => {
+    const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState
+      .mockResolvedValueOnce({
+        settings: { airgapMode: false },
+      })
+      .mockResolvedValueOnce({
+        status: { unlocked: true },
+        settings: { airgapMode: true },
+      });
+    const method = new DeviceSettings({
+      id: 4,
+      payload: {
+        method: 'deviceSettings',
+        airgapMode: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
+      page: DeviceSettingsPage.DeviceAirgap,
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, { refreshSections: ['settings'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['status', 'settings'],
+    });
+  });
+
+  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('accepts a locked Pro2 as confirmation after disabling passphrase', async () => {
+    const { device, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState
+      .mockResolvedValueOnce({
+        status: { unlocked: true, passphraseProtection: true },
+      })
+      .mockResolvedValueOnce({
+        status: { unlocked: false, passphraseProtection: true },
+      });
+    const method = new DeviceSettings({
+      id: 6,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: false,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+  });
+
+  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).toHaveBeenCalledWith({ refreshSections: ['settings'] });
+  });
+
+  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();
+  });
+
+  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-contract.test.ts

@@ -0,0 +1,28 @@
+import { DEVICE } from '../src/events';
+
+import type { DeviceState, DeviceStateEvent } from '../src/types';
+
+describe('DeviceState contract', () => {
+  test('exports the unified device state event contract', () => {
+    expect(DEVICE.STATE).toBe('state');
+
+    const state = {} as DeviceState;
+    const event: DeviceStateEvent = {
+      connectId: 'usb-1',
+      state,
+      revision: 1,
+      source: 'initialize',
+      changedKeys: ['identity.label'],
+    };
+
+    expect(event.state).toBe(state);
+  });
+});
+
+// raw 仅供 SDK 内部兼容投影使用，不属于公共 DeviceState。
+// @ts-expect-error raw 不应成为外部接入者需要理解的字段
+type RemovedPublicRaw = DeviceState['raw'];
+
+// session 属于 SDK 运行时内部缓存，不应通过公共状态或事件暴露。
+// @ts-expect-error session 不属于公共 DeviceState
+type RemovedPublicSession = DeviceState['session'];