@onekeyfe/hd-core 1.2.0-alpha.13 → 1.2.0-alpha.130

package/__tests__/check-firmware-release-protocol-v2.test.ts

@@ -0,0 +1,270 @@
+import { EFirmwareType } from '@onekeyfe/hd-shared';
+
+import CheckAllFirmwareRelease from '../src/api/CheckAllFirmwareRelease';
+import CheckBLEFirmwareRelease from '../src/api/CheckBLEFirmwareRelease';
+import CheckBootloaderRelease from '../src/api/CheckBootloaderRelease';
+import CheckFirmwareRelease from '../src/api/CheckFirmwareRelease';
+import { DataManager } from '../src/data-manager';
+
+import type { IFirmwareReleaseInfo } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+const release: IFirmwareReleaseInfo = {
+  required: false,
+  version: [2, 0, 0],
+  url: 'https://example.com/application-p1.okpkg',
+  fingerprint: 'release-fingerprint',
+  changelog: {
+    'zh-CN': '更新',
+    'en-US': 'Update',
+  },
+  bootloaderChangelog: {
+    'zh-CN': '旧版 Bootloader 更新',
+    'en-US': 'Legacy bootloader update',
+  },
+  installOrder: ['bootloader', 'applicationP1', 'coprocessor'],
+  components: {
+    bootloader: {
+      target: 'BOOTLOADER',
+      url: 'https://example.com/bootloader.okpkg',
+      version: [2, 0, 0],
+    },
+    applicationP1: {
+      target: 'APPLICATION_P1',
+      url: 'https://example.com/application-p1.okpkg',
+      version: [2, 0, 0],
+    },
+    coprocessor: {
+      target: 'COPROCESSOR',
+      url: 'https://example.com/coprocessor.okpkg',
+      version: [2, 0, 0],
+    },
+  },
+};
+
+const createDevice = (deviceType: 'pro2' | 'neo') => ({
+  isProtocolV2: () => true,
+  features: {
+    deviceType,
+    firmwareVersion: '1.0.0',
+  },
+  getDeviceState: jest.fn().mockResolvedValue({
+    identity: {
+      deviceType,
+      firmwareType: EFirmwareType.Universal,
+    },
+    status: { mode: 'normal' },
+    versions: {
+      firmware: '1.0.0',
+      applicationP1: '1.0.0',
+      bootloader: '1.0.0',
+      board: '1.0.0',
+      ble: '1.0.0',
+    },
+  }),
+});
+
+const createFeaturelessDevice = (protocolV2: boolean) => {
+  const device = {
+    isProtocolV2: jest.fn(() => protocolV2),
+    features: undefined,
+    getDeviceState: jest.fn(),
+  };
+  device.getDeviceState.mockImplementation(() => {
+    Object.assign(device, {
+      features: {
+        deviceType: 'pro2',
+        firmwareVersion: '1.0.0',
+      },
+    });
+    return Promise.resolve({
+      identity: {
+        deviceType: 'pro2',
+        firmwareType: EFirmwareType.Universal,
+      },
+      status: { mode: 'bootloader' },
+      versions: {
+        firmware: '1.0.0',
+        applicationP1: '1.0.0',
+        bootloader: '1.0.0',
+        board: '1.0.0',
+        ble: '1.0.0',
+      },
+    });
+  });
+  return device;
+};
+
+describe.each(['pro2', 'neo'] as const)('Protocol V2 release checks for %s', deviceType => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('supports firmware, BLE, bootloader, and aggregate release checks', async () => {
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue({
+      archiveUrl: `https://example.com/${deviceType}/pro2-resource.zip`,
+      archiveSha256: 'a'.repeat(64),
+      archiveSize: 16_815_479,
+    });
+
+    const firmwareMethod = new CheckFirmwareRelease({
+      id: 1,
+      payload: { method: 'checkFirmwareRelease' },
+    });
+    firmwareMethod.init();
+    firmwareMethod.device = createDevice(deviceType) as unknown as CheckFirmwareRelease['device'];
+
+    const bleMethod = new CheckBLEFirmwareRelease({
+      id: 2,
+      payload: { method: 'checkBLEFirmwareRelease' },
+    });
+    bleMethod.init();
+    bleMethod.device = createDevice(deviceType) as unknown as CheckBLEFirmwareRelease['device'];
+
+    const bootloaderMethod = new CheckBootloaderRelease({
+      id: 3,
+      payload: { method: 'checkBootloaderRelease' },
+    });
+    bootloaderMethod.init();
+    bootloaderMethod.device = createDevice(
+      deviceType
+    ) as unknown as CheckBootloaderRelease['device'];
+
+    const allMethod = new CheckAllFirmwareRelease({
+      id: 4,
+      payload: { method: 'checkAllFirmwareRelease' },
+    });
+    allMethod.init();
+    allMethod.device = createDevice(deviceType) as unknown as CheckAllFirmwareRelease['device'];
+
+    await expect(firmwareMethod.run()).resolves.toMatchObject({
+      status: 'outdated',
+      shouldUpdate: true,
+      release,
+    });
+    await expect(bleMethod.run()).resolves.toMatchObject({
+      status: 'outdated',
+      shouldUpdate: true,
+      release: {
+        protocol: 'V2',
+        configKey: 'coprocessor',
+        componentTarget: 'COPROCESSOR',
+        target: 'COPROCESSOR',
+        url: 'https://example.com/coprocessor.okpkg',
+        version: [2, 0, 0],
+      },
+    });
+    await expect(bootloaderMethod.run()).resolves.toMatchObject({
+      status: 'outdated',
+      shouldUpdate: true,
+      changelog: [release.changelog],
+      release: {
+        protocol: 'V2',
+        configKey: 'bootloader',
+        componentTarget: 'BOOTLOADER',
+        target: 'BOOTLOADER',
+        url: 'https://example.com/bootloader.okpkg',
+        version: [2, 0, 0],
+        changelog: release.changelog,
+      },
+    });
+    await expect(allMethod.run()).resolves.toMatchObject({
+      protocol: 'V2',
+      deviceType,
+      status: 'outdated',
+      hasUpgrade: true,
+      targetsToUpdate: ['boot', 'app_v1', 'coprocessor', 'resource'],
+      firmware: { status: 'outdated', shouldUpdate: true },
+      ble: {
+        status: 'outdated',
+        shouldUpdate: true,
+        release: { componentTarget: 'COPROCESSOR' },
+      },
+      bootloader: {
+        status: 'outdated',
+        shouldUpdate: true,
+        release: { componentTarget: 'BOOTLOADER' },
+      },
+    });
+
+    expect(firmwareMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(bleMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(bootloaderMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(allMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+  });
+});
+
+test('probes Protocol V2 loader state before requiring initialized features', async () => {
+  jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
+  const firmwareDevice = createFeaturelessDevice(true);
+  const bleDevice = createFeaturelessDevice(true);
+  const bootloaderDevice = createFeaturelessDevice(true);
+  const firmwareMethod = new CheckFirmwareRelease({
+    id: 1,
+    payload: { method: 'checkFirmwareRelease' },
+  });
+  const bleMethod = new CheckBLEFirmwareRelease({
+    id: 2,
+    payload: { method: 'checkBLEFirmwareRelease' },
+  });
+  const bootloaderMethod = new CheckBootloaderRelease({
+    id: 3,
+    payload: { method: 'checkBootloaderRelease' },
+  });
+
+  firmwareMethod.device = firmwareDevice as unknown as CheckFirmwareRelease['device'];
+  bleMethod.device = bleDevice as unknown as CheckBLEFirmwareRelease['device'];
+  bootloaderMethod.device = bootloaderDevice as unknown as CheckBootloaderRelease['device'];
+
+  await expect(firmwareMethod.run()).resolves.toMatchObject({
+    status: 'outdated',
+    shouldUpdate: true,
+  });
+  await expect(bleMethod.run()).resolves.toMatchObject({
+    status: 'outdated',
+    shouldUpdate: true,
+  });
+  await expect(bootloaderMethod.run()).resolves.toMatchObject({
+    status: 'outdated',
+    shouldUpdate: true,
+  });
+  for (const device of [firmwareDevice, bleDevice, bootloaderDevice]) {
+    expect(device.isProtocolV2).toHaveBeenCalled();
+    expect(device.getDeviceState).toHaveBeenCalledTimes(1);
+  }
+});
+
+test('keeps featureless Protocol V1 release probes optional', async () => {
+  const firmwareDevice = createFeaturelessDevice(false);
+  const bleDevice = createFeaturelessDevice(false);
+  const bootloaderDevice = createFeaturelessDevice(false);
+  const firmwareMethod = new CheckFirmwareRelease({
+    id: 1,
+    payload: { method: 'checkFirmwareRelease' },
+  });
+  const bleMethod = new CheckBLEFirmwareRelease({
+    id: 2,
+    payload: { method: 'checkBLEFirmwareRelease' },
+  });
+  const bootloaderMethod = new CheckBootloaderRelease({
+    id: 3,
+    payload: { method: 'checkBootloaderRelease' },
+  });
+
+  firmwareMethod.device = firmwareDevice as unknown as CheckFirmwareRelease['device'];
+  bleMethod.device = bleDevice as unknown as CheckBLEFirmwareRelease['device'];
+  bootloaderMethod.device = bootloaderDevice as unknown as CheckBootloaderRelease['device'];
+
+  await expect(firmwareMethod.run()).resolves.toBeNull();
+  await expect(bleMethod.run()).resolves.toBeNull();
+  await expect(bootloaderMethod.run()).resolves.toBeNull();
+  for (const device of [firmwareDevice, bleDevice, bootloaderDevice]) {
+    expect(device.isProtocolV2).toHaveBeenCalled();
+    expect(device.getDeviceState).not.toHaveBeenCalled();
+  }
+});

package/__tests__/connectSettings.test.ts

@@ -1,19 +1,59 @@
+import DataManager from '../src/data-manager/DataManager';
 import { parseConnectSettings } from '../src/data-manager/connectSettings';
 
+import type { RemoteConfigResponse } from '../src/types';
+
+jest.mock('axios', () => ({
+  get: jest.fn(),
+}));
+
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
+const mockAxiosGet: jest.Mock = jest.requireMock('axios').get;
+
 describe('parseConnectSettings', () => {
-  it('keeps custom configFetcher in parsed settings', () => {
-    const configFetcher = jest.fn();
+  const preloadedConfig = {
+    bridge: {},
+    classic: { firmware: [], ble: [] },
+    classic1s: { firmware: [], ble: [] },
+    classicpure: { firmware: [], ble: [] },
+    mini: { firmware: [], ble: [] },
+    touch: { firmware: [], ble: [] },
+    pro: { firmware: [], ble: [] },
+    pro2: { firmware: [], ble: [] },
+  } as unknown as RemoteConfigResponse;
+
+  it('keeps a serializable preloaded config in parsed settings', () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    expect(settings.firmwareManifestMode).toBe('sdk-managed');
+    expect(settings.preloadedConfig).toBe(preloadedConfig);
+  });
+
+  it('uses the preloaded config before the SDK network client', async () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    await DataManager.load(settings);
+
+    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(DataManager.deviceMap.classic).toEqual({ firmware: [], ble: [] });
+  });
 
+  it('keeps the SDK offline and available without an external manifest snapshot', async () => {
     const settings = parseConnectSettings({
-      fetchConfig: true,
-      configFetcher,
+      firmwareManifestMode: 'external-only',
     });
 
-    expect(settings.configFetcher).toBe(configFetcher);
+    await expect(DataManager.load(settings)).resolves.toBe(false);
+    expect(mockAxiosGet).not.toHaveBeenCalled();
   });
 });

package/__tests__/core-dispose.test.ts

@@ -0,0 +1,34 @@
+import Core, { initConnector } from '../src/core';
+import TransportManager from '../src/data-manager/TransportManager';
+import { DevicePool } from '../src/device/DevicePool';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+describe('Core.dispose', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('幂等停止 Connector 和 Transport，并重置共享设备状态', async () => {
+    const connector = initConnector();
+    const connectorStop = jest.spyOn(connector, 'stop');
+    const transportStop = jest.fn().mockResolvedValue(undefined);
+    jest.spyOn(TransportManager, 'getTransport').mockReturnValue({ stop: transportStop } as never);
+    const disposeDevicePool = jest.spyOn(DevicePool, 'dispose');
+    const core = new Core();
+
+    const firstDispose = core.dispose();
+    expect(connectorStop).toHaveBeenCalledTimes(1);
+    expect(transportStop).toHaveBeenCalledTimes(1);
+    expect(disposeDevicePool).toHaveBeenCalledTimes(1);
+
+    await firstDispose;
+    await core.dispose();
+    expect(connectorStop).toHaveBeenCalledTimes(1);
+    expect(transportStop).toHaveBeenCalledTimes(1);
+    expect(disposeDevicePool).toHaveBeenCalledTimes(1);
+  });
+});

package/__tests__/core-error-output.test.ts

@@ -0,0 +1,39 @@
+import { initCore } from '../src/core';
+import { IFRAME } from '../src/events';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  __esModule: true,
+  default: {
+    configure: jest.fn().mockResolvedValue(undefined),
+    getTransport: jest.fn(() => undefined),
+  },
+}));
+
+describe('Core 错误输出边界', () => {
+  test('连接失败只返回结构化错误，不直接写入 stdout', async () => {
+    const stdout = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    const core = initCore();
+
+    const response = await core.handleMessage({
+      id: 1,
+      event: IFRAME.CALL,
+      type: IFRAME.CALL,
+      payload: {
+        method: 'getDeviceState',
+        connectId: 'missing-device',
+        retryCount: 0,
+        pollIntervalTime: 1,
+        timeout: 10,
+      },
+    } as never);
+
+    expect(response).toMatchObject({ success: false });
+    expect(stdout).not.toHaveBeenCalled();
+    await core.dispose();
+  });
+});

package/__tests__/core-initialization.test.ts

@@ -0,0 +1,23 @@
+import { DataManager } from '../src/data-manager';
+import { init } from '../src/core';
+
+import type { ConnectSettings } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+describe('Core initialization', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('does not create a partially initialized core when settings loading fails', async () => {
+    jest.spyOn(DataManager, 'load').mockRejectedValue(new Error('settings load failed'));
+
+    await expect(init({} as ConnectSettings, class TestTransport {})).rejects.toThrow(
+      'settings load failed'
+    );
+  });
+});

package/__tests__/device-connector-protocol.test.ts

@@ -0,0 +1,102 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { createProtocolV2LinkDisabledError } from '@onekeyfe/hd-transport';
+
+import DeviceConnector from '../src/device/DeviceConnector';
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  __esModule: true,
+  default: {
+    load: jest.fn(),
+    getTransport: jest.fn(),
+  },
+}));
+
+jest.mock('../src/data-manager', () => ({
+  DataManager: {
+    getSettings: jest.fn(() => 'desktop-web-ble'),
+    isBleConnect: jest.fn(() => true),
+  },
+}));
+
+jest.mock('../src/device/DevicePool', () => ({
+  DevicePool: {
+    setConnector: jest.fn(),
+  },
+}));
+
+const transportManagerMock: {
+  default: {
+    getTransport: jest.Mock;
+  };
+} = jest.requireMock('../src/data-manager/TransportManager');
+
+describe('DeviceConnector protocol validation', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('reports an explicit transport error when connector initialization ran too early', async () => {
+    transportManagerMock.default.getTransport.mockReturnValue(undefined);
+    const connector = new DeviceConnector();
+
+    await expect(connector.enumerate()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.TransportNotConfigured,
+    });
+  });
+
+  it('uses the actively probed protocol returned by acquire when the cache was cleared', async () => {
+    const acquire = jest.fn().mockResolvedValue({
+      id: 'pro2-id',
+      path: 'pro2-id',
+      protocolType: 'V2',
+    });
+    transportManagerMock.default.getTransport.mockReturnValue({
+      acquire,
+      getProtocolType: jest.fn(() => undefined),
+    });
+    const connector = new DeviceConnector();
+
+    await expect(connector.acquire('pro2-id', undefined, undefined, 'V2')).resolves.toEqual(
+      expect.objectContaining({ protocolType: 'V2' })
+    );
+    expect(acquire).toHaveBeenCalledWith(
+      expect.objectContaining({ uuid: 'pro2-id', expectedProtocol: 'V2' })
+    );
+  });
+
+  it('still rejects a real mismatch reported by the active protocol probe', async () => {
+    transportManagerMock.default.getTransport.mockReturnValue({
+      acquire: jest.fn().mockResolvedValue({
+        id: 'classic-id',
+        path: 'classic-id',
+        protocolType: 'V1',
+      }),
+      getProtocolType: jest.fn(() => 'V1'),
+    });
+    const connector = new DeviceConnector();
+
+    await expect(connector.acquire('classic-id', undefined, undefined, 'V2')).rejects.toThrow(
+      'Device protocol mismatch: expected V2, detected V1'
+    );
+  });
+
+  it('preserves the Protocol V2 USB-priority failure as public BLE error 723', async () => {
+    transportManagerMock.default.getTransport.mockReturnValue({
+      acquire: jest
+        .fn()
+        .mockRejectedValue(
+          createProtocolV2LinkDisabledError('Failure_ProcessError', 'link disabled')
+        ),
+      getProtocolType: jest.fn(() => undefined),
+    });
+    const connector = new DeviceConnector();
+
+    await expect(connector.acquire('pro2-id', undefined, undefined, 'V2')).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleUnavailableWhileUsbConnected,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        firmwareMessage: 'link disabled',
+      },
+    });
+  });
+});

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

@@ -0,0 +1,78 @@
+import { mergeDeviceFeaturesPatch } from '../src/device/DeviceFeaturesState';
+
+import type { Features } from '../src/types';
+
+const baseFeatures = {
+  protocol: 'V2',
+  deviceType: 'pro2',
+  firmwareType: 'universal',
+  model: 'pro2',
+  vendor: 'onekey.so',
+  deviceId: null,
+  serialNo: 'P20001',
+  label: 'Old Label',
+  bleName: 'Pro2 0001',
+  capabilities: [],
+  mode: 'normal',
+  initialized: true,
+  bootloaderMode: false,
+  unlocked: true,
+  firmwarePresent: true,
+  passphraseProtection: false,
+  pinProtection: true,
+  backupRequired: false,
+  noBackup: false,
+  unfinishedBackup: false,
+  recoveryMode: false,
+  language: 'en-US',
+  bleEnabled: true,
+  sdCardPresent: null,
+  sdProtection: null,
+  wipeCodeProtection: null,
+  passphraseAlwaysOnDevice: null,
+  safetyChecks: null,
+  autoLockDelayMs: 60_000,
+  displayRotation: null,
+  experimentalFeatures: false,
+  firmwareVersion: '1.0.0',
+  bootloaderVersion: '1.0.0',
+  boardVersion: '1.0.0',
+  bleVersion: '1.0.0',
+  sessionId: null,
+} as Features;
+
+describe('mergeDeviceFeaturesPatch', () => {
+  it('ignores undefined fields instead of clearing cached values', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, {
+      label: undefined,
+      language: 'ja-JP',
+    });
+
+    expect(next).toMatchObject({
+      label: 'Old Label',
+      language: 'ja-JP',
+    });
+  });
+
+  it('allows null to explicitly clear a cached value', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, { label: null });
+
+    expect(next.label).toBeNull();
+  });
+
+  it('returns the same object when no value changes', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, {
+      label: 'Old Label',
+      language: undefined,
+    });
+
+    expect(next).toBe(baseFeatures);
+  });
+
+  it('returns a new object when a defined value changes', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, { label: 'New Label' });
+
+    expect(next).not.toBe(baseFeatures);
+    expect(next.label).toBe('New Label');
+  });
+});

package/__tests__/device-identity.test.ts

@@ -0,0 +1,52 @@
+import { checkLiveDeviceId } from '../src/device/deviceIdentity';
+import ConfluxGetAddress from '../src/api/conflux/ConfluxGetAddress';
+import ConfluxSignMessage from '../src/api/conflux/ConfluxSignMessage';
+import ConfluxSignMessageCIP23 from '../src/api/conflux/ConfluxSignMessageCIP23';
+import ConfluxSignTransaction from '../src/api/conflux/ConfluxSignTransaction';
+import NexaSignTransaction from '../src/api/nexa/NexaSignTransaction';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('live device identity', () => {
+  test.each([
+    ['confluxGetAddress', ConfluxGetAddress],
+    ['confluxSignMessage', ConfluxSignMessage],
+    ['confluxSignMessageCIP23', ConfluxSignMessageCIP23],
+    ['confluxSignTransaction', ConfluxSignTransaction],
+    ['nexaSignTransaction', NexaSignTransaction],
+  ])('%s requires a live device id check', (methodName, Method) => {
+    const method = new Method({ payload: { method: methodName } });
+
+    expect(method.checkDeviceId).toBe(true);
+  });
+
+  test('refreshes Protocol V2 status before comparing the expected device id', async () => {
+    let currentDeviceId = 'OLD_DEVICE_ID';
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState: jest.fn().mockImplementation(() => {
+        currentDeviceId = 'NEW_DEVICE_ID';
+        return Promise.resolve({ identity: { deviceId: currentDeviceId } });
+      }),
+      checkDeviceId: jest.fn((expected: string) => currentDeviceId === expected),
+    };
+
+    await expect(checkLiveDeviceId(device as never, 'OLD_DEVICE_ID')).resolves.toBe(false);
+    expect(device.getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status'] });
+    expect(device.checkDeviceId).toHaveBeenCalledWith('OLD_DEVICE_ID');
+  });
+
+  test('keeps Protocol V1 identity checks on the Initialize/GetFeatures state', async () => {
+    const device = {
+      isProtocolV2: () => false,
+      getDeviceState: jest.fn(),
+      checkDeviceId: jest.fn(() => true),
+    };
+
+    await expect(checkLiveDeviceId(device as never, 'V1_DEVICE_ID')).resolves.toBe(true);
+    expect(device.getDeviceState).not.toHaveBeenCalled();
+  });
+});