@onekeyfe/hd-core 1.1.34-alpha.3 → 1.1.34-alpha.4

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

@@ -1,132 +0,0 @@
-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.resetState();
-  });
-
-  afterEach(() => {
-    DevicePool.resetState();
-  });
-
-  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('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('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

@@ -1,286 +0,0 @@
-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';
-
-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',
-      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({
-      id: 1,
-      payload: {
-        method: 'deviceSettings',
-        label: 'Shared Label',
-        language: 'ja',
-      },
-    });
-    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,
-      haptic_feedback: undefined,
-    });
-    expect(updateState).toHaveBeenCalledWith(
-      {
-        identity: { label: 'Shared Label' },
-        settings: { language: 'ja' },
-      },
-      'apply-settings'
-    );
-  });
-
-  it('uses DeviceSettingsSet and commits the confirmed patch for Protocol V2', async () => {
-    const { device, typedCall, updateState } = createDevice({ protocol: 'V2' });
-    const method = new DeviceSettings({
-      id: 2,
-      payload: {
-        method: 'deviceSettings',
-        label: 'Shared Label',
-        language: 'ja',
-        autoLockDelayMs: 60_000,
-        hapticFeedback: 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',
-        autolock_delay_ms: 60_000,
-        haptic_feedback: true,
-      },
-    });
-    expect(updateState).toHaveBeenCalledWith(
-      {
-        identity: { label: 'Shared Label' },
-        settings: {
-          language: 'ja-Jpan-JP',
-          autoLockDelayMs: 60_000,
-          hapticFeedback: true,
-        },
-      },
-      'apply-settings'
-    );
-    expect(typedCall.mock.calls.map(call => call[0])).not.toEqual(
-      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-mapper.test.ts

@@ -1,229 +0,0 @@
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
-
-import {
-  mapApplySettingsToState,
-  mapDeviceSettingsToState,
-  mapProtocolV1FeaturesToState,
-  mapProtocolV2DeviceInfoToState,
-  mapProtocolV2DeviceStatusToState,
-} from '../src/device/DeviceStateMapper';
-
-import type { PROTO } from '../src/constants';
-import type { DeviceSettings, DeviceStatus, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
-
-describe('DeviceStateMapper', () => {
-  test('maps Protocol V1 Features into structured state sections', () => {
-    const patch = mapProtocolV1FeaturesToState({
-      onekey_device_type: 'PRO',
-      device_id: 'device-1',
-      label: 'Pro Wallet',
-      initialized: true,
-      unlocked: true,
-      language: 'en-US',
-      major_version: 4,
-      minor_version: 10,
-      patch_version: 1,
-      se_ver: '1.1.0.2',
-    } as PROTO.Features);
-
-    expect(patch).toMatchObject({
-      protocol: 'V1',
-      identity: {
-        deviceType: EDeviceType.Pro,
-        deviceId: 'device-1',
-        label: 'Pro Wallet',
-      },
-      status: { mode: 'normal', initialized: true, unlocked: true },
-      settings: { language: 'en-US' },
-      versions: { firmware: '4.10.1', se: '1.1.0.2', se01: '1.1.0.2' },
-    });
-  });
-
-  test.each([
-    ['CLASSIC1S', EDeviceType.Classic1s],
-    ['TOUCH', EDeviceType.Touch],
-    ['PRO', EDeviceType.Pro],
-  ] as const)(
-    'keeps the real label separate from display fallbacks for Protocol V1 %s',
-    (onekeyDeviceType, expectedDeviceType) => {
-      const patch = mapProtocolV1FeaturesToState({
-        onekey_device_type: onekeyDeviceType,
-        onekey_ble_name: `${onekeyDeviceType} BLE`,
-        initialized: true,
-      } as PROTO.Features);
-
-      expect(patch.identity).toMatchObject({
-        deviceType: expectedDeviceType,
-        label: null,
-        bleName: `${onekeyDeviceType} BLE`,
-      });
-    }
-  );
-
-  test.each([
-    ['CLASSIC1S', EDeviceType.Classic1s],
-    ['TOUCH', EDeviceType.Touch],
-    ['PRO', EDeviceType.Pro],
-  ] as const)(
-    'preserves Protocol V1 backup mode semantics for %s',
-    (onekeyDeviceType, expectedDeviceType) => {
-      const patch = mapProtocolV1FeaturesToState({
-        onekey_device_type: onekeyDeviceType,
-        initialized: true,
-        no_backup: true,
-      } as PROTO.Features);
-
-      expect(patch.identity?.deviceType).toBe(expectedDeviceType);
-      expect(patch.status?.mode).toBe('backupMode');
-    }
-  );
-
-  test('normalizes legacy Bitcoin-only and Attach PIN fields from Protocol V1', () => {
-    const patch = mapProtocolV1FeaturesToState({
-      onekey_device_type: 'PRO',
-      capabilities: [1],
-      attach_to_pin_user: true,
-      unlocked_attach_pin: true,
-      initialized: true,
-    } as PROTO.Features);
-
-    expect(patch.identity?.firmwareType).toBe(EFirmwareType.BitcoinOnly);
-    expect(patch.status).toMatchObject({
-      attachToPinEnabled: true,
-      unlockedAttachPin: true,
-    });
-  });
-
-  test('keeps Protocol V1 universal firmware when the decoded Bitcoin-like capability is present', () => {
-    const patch = mapProtocolV1FeaturesToState({
-      onekey_device_type: 'CLASSIC1S',
-      capabilities: ['Capability_Bitcoin_like'],
-      initialized: true,
-    } as PROTO.Features);
-
-    expect(patch.identity?.firmwareType).toBe(EFirmwareType.Universal);
-  });
-
-  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,
-      'normal'
-    );
-
-    expect(patch.identity).toMatchObject({
-      deviceType: EDeviceType.Pro2,
-      serialNo: 'SERIAL-1',
-      bleName: 'Pro2 1234',
-    });
-    expect(patch.versions).toMatchObject({
-      firmware: '5.0.0',
-      bootloader: '2.0.0',
-      ble: '1.2.3',
-    });
-    expect(patch).toMatchObject({ protocolVersion: 2 });
-    expect(patch.status?.unlocked).toBeUndefined();
-  });
-
-  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,
-      'normal'
-    );
-
-    expect(patch.status?.mode).toBe('normal');
-    expect(patch.verification).toMatchObject({
-      se01BuildId: 'se-app',
-      se01Hash: '0102',
-      se01BootBuildId: 'se-boot',
-      se01BootHash: '0304',
-    });
-  });
-
-  test.each([
-    [
-      'bootloader',
-      {
-        hw: { serial_no: 'SERIAL-BOOT' },
-        fw: { bootloader: { version: '2.0.0' } },
-        se1: {},
-      },
-    ],
-    [
-      'romloader',
-      {
-        hw: { serial_no: 'SERIAL-ROM' },
-        fw: {
-          romloader: { version: '1.0.0' },
-          bootloader: { version: '2.0.0' },
-        },
-      },
-    ],
-  ] as const)('clears stale device identity in Protocol V2 %s mode', (mode, info) => {
-    const patch = mapProtocolV2DeviceInfoToState(info as ProtocolV2DeviceInfo, mode);
-
-    expect(patch.status?.mode).toBe(mode);
-    expect(patch.identity).toMatchObject({ deviceId: null });
-  });
-
-  test('maps Protocol V2 status separately and ignores locked passphrase value', () => {
-    const locked = mapProtocolV2DeviceStatusToState({
-      device_id: 'device-2',
-      init_states: true,
-      unlocked: false,
-      passphrase_enabled: true,
-      backup_required: true,
-    } as DeviceStatus);
-
-    expect(locked.identity?.deviceId).toBe('device-2');
-    expect(locked.status).toMatchObject({
-      mode: 'normal',
-      initialized: true,
-      unlocked: false,
-      backupRequired: true,
-    });
-    expect(locked.status).not.toHaveProperty('passphraseProtection');
-  });
-
-  test('maps common settings into identity, status and settings sections', () => {
-    expect(
-      mapApplySettingsToState({ label: 'Renamed', use_passphrase: true, haptic_feedback: false })
-    ).toEqual({
-      identity: { label: 'Renamed' },
-      status: { passphraseProtection: true },
-      settings: { hapticFeedback: false },
-    });
-
-    expect(
-      mapDeviceSettingsToState({
-        label: 'Pro2',
-        brightness: 80,
-        autolock_delay_ms: 30_000,
-      } as DeviceSettings)
-    ).toEqual({
-      identity: { label: 'Pro2' },
-      settings: { brightness: 80, autoLockDelayMs: 30_000 },
-    });
-  });
-});