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

package/__tests__/chain-params-onekey-compatibility.test.ts

@@ -0,0 +1,229 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import BenfenGetAddress from '../src/api/benfen/BenfenGetAddress';
+import ConfluxSignTransaction from '../src/api/conflux/ConfluxSignTransaction';
+import EVMSignTransaction from '../src/api/evm/EVMSignTransaction';
+import EVMSignMessageEIP712 from '../src/api/evm/EVMSignMessageEIP712';
+import KaspaSignTransaction from '../src/api/kaspa/KaspaSignTransaction';
+import XrpSignTransaction from '../src/api/xrp/XrpSignTransaction';
+
+import type { Device } from '../src/device/Device';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  getProtocolV1MessageSchema: jest.fn(() => 'v1CurrentSchema'),
+}));
+
+jest.mock('../src/device/Device', () => ({
+  Device: jest.fn(),
+}));
+
+const KASPA_PATH = "m/44'/111111'/0'/0/0";
+const KASPA_SCRIPT = `20${'ab'.repeat(32)}ac`;
+const KASPA_ADDRESS = 'kaspa:qr0lr4ml9fn3chekrqmjdkergxl93l4wrk3dankcgvjq776s9wn9jkdskewva';
+
+const buildKaspaPayload = () => ({
+  method: 'kaspaSignTransaction',
+  version: 0,
+  lockTime: 0,
+  inputs: [
+    {
+      path: KASPA_PATH,
+      prevTxId: 'aa'.repeat(32),
+      outputIndex: 0,
+      sequenceNumber: 0,
+      output: { satoshis: 200000, script: KASPA_SCRIPT },
+    },
+  ],
+  outputs: [{ satoshis: 100000, script: KASPA_SCRIPT, scriptVersion: 0 }],
+});
+
+describe('onekey public-chain parameter compatibility', () => {
+  it('keeps the historical EVM contract-deployment representation', () => {
+    const transaction = {
+      to: '',
+      value: '0x0',
+      gasPrice: '0x1',
+      gasLimit: '0x5208',
+      nonce: '0x0',
+      chainId: 1,
+      data: '0x6000',
+    };
+
+    const method = new EVMSignTransaction({
+      id: 1,
+      payload: {
+        method: 'evmSignTransaction',
+        path: "m/44'/60'/0'/0/0",
+        transaction,
+      },
+    });
+
+    expect(() => method.init()).not.toThrow();
+
+    const { to: _to, ...transactionWithoutTo } = transaction;
+    const missingTo = new EVMSignTransaction({
+      id: 2,
+      payload: {
+        method: 'evmSignTransaction',
+        path: "m/44'/60'/0'/0/0",
+        transaction: transactionWithoutTo,
+      },
+    });
+
+    expect(() => missingTo.init()).toThrow('Missing required parameter: to');
+  });
+
+  it('keeps Conflux to validation aligned with onekey', () => {
+    const method = new ConfluxSignTransaction({
+      id: 1,
+      payload: {
+        method: 'confluxSignTransaction',
+        path: "m/44'/503'/0'/0/0",
+        transaction: {
+          to: 'cfx:aak2rra2njvd77ezwjvx04kkds9fzagfe6d5r8e957',
+          value: '0x0',
+          gasLimit: '0x5208',
+          gasPrice: '0x1',
+          nonce: '0x0',
+          epochHeight: '0x1',
+          storageLimit: '0x0',
+          chainId: 1029,
+        },
+      },
+    });
+
+    expect(() => method.init()).toThrow('should be [hexString]');
+  });
+
+  it('keeps XRP payment amount as the historical number input', () => {
+    const createMethod = (amount: number | string) =>
+      new XrpSignTransaction({
+        id: 1,
+        payload: {
+          method: 'xrpSignTransaction',
+          path: "m/44'/144'/0'/0/0",
+          transaction: {
+            payment: {
+              amount,
+              destination: 'rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn',
+            },
+          },
+        },
+      });
+
+    expect(() => createMethod(1).init()).not.toThrow();
+    expect(() => createMethod('1').init()).toThrow('should be [number]');
+  });
+
+  it('keeps the Kaspa legacy schema while allowing the additive streaming shape', () => {
+    const legacyWithoutSigHash = new KaspaSignTransaction({
+      id: 1,
+      payload: buildKaspaPayload(),
+    });
+    expect(() => legacyWithoutSigHash.init()).toThrow('Missing required parameter: sigHashType');
+
+    const legacyWithoutScript = new KaspaSignTransaction({
+      id: 2,
+      payload: {
+        ...buildKaspaPayload(),
+        sigHashType: 0x41,
+        outputs: [{ satoshis: 100000, scriptVersion: 0 }],
+      },
+    });
+    expect(() => legacyWithoutScript.init()).toThrow('Missing required parameter: script');
+
+    const streaming = new KaspaSignTransaction({
+      id: 3,
+      payload: {
+        ...buildKaspaPayload(),
+        inputs: [
+          {
+            ...buildKaspaPayload().inputs[0],
+            output: { satoshis: 200000 },
+          },
+        ],
+        outputs: [{ satoshis: 100000, address: KASPA_ADDRESS }],
+      },
+    });
+    expect(() => streaming.init()).not.toThrow();
+  });
+
+  it('keeps validating the Kaspa legacy input amount', () => {
+    const payload = buildKaspaPayload();
+    const method = new KaspaSignTransaction({
+      id: 1,
+      payload: {
+        ...payload,
+        sigHashType: 0x41,
+        inputs: [
+          {
+            ...payload.inputs[0],
+            output: { script: KASPA_SCRIPT },
+          },
+        ],
+      },
+    });
+
+    expect(() => method.init()).toThrow('Missing required parameter: satoshis');
+  });
+
+  it('keeps the deprecated EIP-712 method callable on existing Protocol V1 devices', async () => {
+    const method = new EVMSignMessageEIP712({
+      id: 1,
+      payload: {
+        method: 'evmSignMessageEIP712',
+        path: "m/44'/60'/0'/0/0",
+        domainHash: `0x${'11'.repeat(32)}`,
+        messageHash: `0x${'22'.repeat(32)}`,
+      },
+    });
+    method.init();
+
+    const typedCall = jest.fn().mockResolvedValue({
+      message: {
+        address: '0x1234',
+        signature: 'abcd',
+      },
+    });
+    method.device = {
+      commands: { typedCall },
+      getCurrentFirmwareVersionString: jest.fn(() => '4.10.0'),
+      getCurrentMethodVersionRange: jest.fn(() => undefined),
+      getCurrentFirmwareType: jest.fn(() => EFirmwareType.Universal),
+      getProtocol: jest.fn(() => 'V1'),
+    } as unknown as Device;
+
+    await expect(method.run()).resolves.toEqual({
+      address: '0x1234',
+      signature: 'abcd',
+    });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  it('rejects a Benfen response that omits the address', async () => {
+    const method = new BenfenGetAddress({
+      id: 1,
+      payload: {
+        method: 'benfenGetAddress',
+        path: "m/44'/728'/0'/0'/0'",
+        showOnOneKey: false,
+      },
+    });
+    method.init();
+    method.device = {
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: {} }),
+      },
+      getCurrentFirmwareVersionString: jest.fn(() => '1.0.0'),
+      getCurrentDeviceType: jest.fn(() => EDeviceType.Classic),
+      isProtocolV2: jest.fn(() => false),
+    } as unknown as Device;
+
+    await expect(method.run()).rejects.toThrow(/address/i);
+  });
+});

package/__tests__/connectSettings.test.ts

@@ -0,0 +1,61 @@
+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', () => {
+  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('fails closed without a preloaded config in external-only mode', async () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'external-only',
+    });
+
+    await expect(DataManager.load(settings)).rejects.toThrow(
+      'External firmware config snapshot is required'
+    );
+    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 resetDevicePool = jest.spyOn(DevicePool, 'resetState');
+    const core = new Core();
+
+    const firstDispose = core.dispose();
+    expect(connectorStop).toHaveBeenCalledTimes(1);
+    expect(transportStop).toHaveBeenCalledTimes(1);
+    expect(resetDevicePool).toHaveBeenCalledTimes(1);
+
+    await firstDispose;
+    await core.dispose();
+    expect(connectorStop).toHaveBeenCalledTimes(1);
+    expect(transportStop).toHaveBeenCalledTimes(1);
+    expect(resetDevicePool).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__/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();
+  });
+});

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

@@ -0,0 +1,197 @@
+import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+
+import { initConnector, initCore } from '../src/core';
+import { DataManager } from '../src/data-manager';
+import TransportManager from '../src/data-manager/TransportManager';
+import { Device } from '../src/device/Device';
+import { DevicePool } from '../src/device/DevicePool';
+import { CORE_EVENT, DEVICE, IFRAME } from '../src/events';
+
+import type Core from '../src/core';
+import type { CoreMessage } from '../src/events';
+import type { KnownDevice } 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/',
+}));
+
+const createInitializedDevice = (protocol: 'V1' | 'V2') => {
+  const device = Device.fromDescriptor({
+    id: 'ble-discovery-id',
+    path: 'ble-discovery-id',
+    commType: 'ble',
+    protocolType: protocol,
+  } as never);
+  device.mainId = 'ble-connect-id';
+  device.features = {
+    protocol,
+    deviceType: protocol === 'V2' ? 'pro2' : 'classic',
+    firmwareType: 'universal',
+    deviceId: 'wallet-device-id',
+    serialNo: 'SERIAL-001',
+    label: 'OneKey Test',
+    bleName: 'OneKey Test BLE',
+    capabilities: [],
+    mode: 'normal',
+    initialized: true,
+    bootloaderMode: false,
+    firmwareVersion: '1.2.3',
+    bootloaderVersion: '1.0.0',
+    boardVersion: '1.0.0',
+    bleVersion: '2.3.4',
+  } as never;
+  return device;
+};
+
+describe('public device lifecycle events', () => {
+  let core: Core | undefined;
+
+  beforeEach(() => {
+    DevicePool.resetState();
+    jest.spyOn(TransportManager, 'load').mockImplementation();
+    TransportManager.transport = {
+      stop: jest.fn().mockResolvedValue(undefined),
+    } as never;
+  });
+
+  afterEach(async () => {
+    await core?.dispose();
+    core = undefined;
+    jest.restoreAllMocks();
+  });
+
+  test('registers the shared device lifecycle listeners exactly once', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    core = initCore();
+    initConnector();
+
+    for (const id of ['first-call', 'second-call']) {
+      await core.handleMessage({
+        id,
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: { method: 'clearSessionCache' },
+      } as CoreMessage);
+    }
+
+    expect(DevicePool.emitter.listenerCount(DEVICE.CONNECT)).toBe(1);
+    expect(DevicePool.emitter.listenerCount(DEVICE.DISCONNECT)).toBe(1);
+  });
+
+  test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    core = initCore();
+    initConnector();
+    const messages: CoreMessage[] = [];
+    core.on(CORE_EVENT, message => messages.push(message));
+    const device = createInitializedDevice('V2');
+    DevicePool.devicesCache['ble-connect-id'] = device;
+
+    DevicePool.emitter.emit(TRANSPORT_EVENT.DEVICE_DISCONNECT, {
+      id: 'ble-connect-id',
+      connectId: 'ble-connect-id',
+      name: 'OneKey Test BLE',
+    });
+
+    const disconnectMessage = messages.find(message => message.type === DEVICE.DISCONNECT);
+    expect(disconnectMessage?.payload.device).toMatchObject({
+      connectId: 'ble-connect-id',
+      serialNo: 'SERIAL-001',
+      state: { protocol: 'V2' },
+    });
+    expect(() => JSON.stringify(disconnectMessage?.payload.device)).not.toThrow();
+  });
+
+  test('treats an acquired BLE device as reusable until the transport disconnects', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('desktop-web-ble' as never);
+    const device = createInitializedDevice('V2');
+    const acquire = jest.spyOn(device, 'acquire').mockResolvedValue(undefined);
+    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+    (device as any).commands = { disposed: false };
+
+    expect(device.isUsedHere()).toBe(true);
+    await expect(device.connect('V2')).resolves.toBe(true);
+    expect(acquire).not.toHaveBeenCalled();
+
+    device.markTransportDisconnected();
+    expect(device.isUsedHere()).toBe(false);
+  });
+
+  test('exposes the current transport usage state in public device snapshots', () => {
+    const getSettings = jest
+      .spyOn(DataManager, 'getSettings')
+      .mockReturnValue('desktop-web-ble' as never);
+    const device = createInitializedDevice('V2');
+
+    expect(device.toMessageObject()?.status).toBe('available');
+
+    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+    expect(device.toMessageObject()?.status).toBe('used');
+
+    device.markTransportDisconnected();
+    expect(device.toMessageObject()?.status).toBe('available');
+
+    getSettings.mockReturnValue('web' as never);
+    device.originalDescriptor.session = 'external-session';
+    expect(device.toMessageObject()?.status).toBe('occupied');
+  });
+
+  test.each([
+    ['react-native', 'V1'],
+    ['react-native', 'V2'],
+    ['lowlevel', 'V1'],
+    ['lowlevel', 'V2'],
+  ] as const)(
+    'emits KnownDevice snapshots for %s Protocol %s connect and disconnect events',
+    async (env, protocol) => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      core = initCore();
+      initConnector();
+
+      await core.handleMessage({
+        id: 'register-device-connect-listener',
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: { method: 'clearSessionCache' },
+      } as CoreMessage);
+
+      const messages: CoreMessage[] = [];
+      core.on(CORE_EVENT, message => messages.push(message));
+      const internalDevice = createInitializedDevice(protocol);
+
+      DevicePool.emitter.emit(DEVICE.CONNECT, internalDevice);
+      internalDevice.updateState({ identity: { label: 'Updated label' } }, 'settings-write');
+      DevicePool.emitter.emit(DEVICE.DISCONNECT, internalDevice);
+
+      const connectMessage = messages.find(message => message.type === DEVICE.CONNECT);
+      const disconnectMessage = messages.find(message => message.type === DEVICE.DISCONNECT);
+      const connectedDevice = connectMessage?.payload.device as KnownDevice;
+      const disconnectedDevice = disconnectMessage?.payload.device as KnownDevice;
+
+      expect(connectedDevice).toMatchObject({
+        connectId: 'ble-connect-id',
+        serialNo: 'SERIAL-001',
+        uuid: 'SERIAL-001',
+        status: 'available',
+        label: 'OneKey Test',
+        state: { protocol },
+      });
+      expect(disconnectedDevice).toMatchObject({
+        connectId: 'ble-connect-id',
+        serialNo: 'SERIAL-001',
+        uuid: 'SERIAL-001',
+        status: 'available',
+        label: 'Updated label',
+        state: { protocol },
+      });
+      expect(connectedDevice).not.toBe(internalDevice);
+      expect(connectedDevice).not.toBe(disconnectedDevice);
+      expect(connectedDevice).not.toHaveProperty('run');
+      expect(connectedDevice).not.toHaveProperty('acquire');
+      expect(connectedDevice).not.toHaveProperty('commands');
+      expect(() => JSON.stringify(connectedDevice)).not.toThrow();
+      expect(connectedDevice.label).toBe('OneKey Test');
+    }
+  );
+});