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

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

@@ -1,403 +0,0 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import { 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/',
-}));
-
-const createV2Device = (typedCall: jest.Mock) => {
-  const device = Device.fromDescriptor({
-    id: 'pro2',
-    path: 'pro2',
-    protocolType: 'V2',
-  } as never);
-  (device as any).commands = { typedCall };
-  return device;
-};
-
-const createV1Device = (typedCall: jest.Mock) => {
-  const device = Device.fromDescriptor({
-    id: 'pro',
-    path: 'pro',
-    protocolType: 'V1',
-  } as never);
-  (device as any).commands = { typedCall };
-  return device;
-};
-
-describe('getDeviceState', () => {
-  test('does not expose the internal wallet session', async () => {
-    const device = createV2Device(jest.fn());
-    device.updateState({ protocol: 'V2' }, 'initialize');
-
-    const state = await device.getDeviceState();
-
-    expect(state).not.toHaveProperty('session');
-  });
-
-  test('hydrates Protocol V2 with separate DeviceInfoGet and DeviceStatusGet', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => ({
-      message:
-        requestType === 'DeviceInfoGet'
-          ? {
-              protocol_version: 2,
-              hw: { serial_no: 'SERIAL-1' },
-              fw: { application: { version: '5.0.0' } },
-            }
-          : { init_states: true, unlocked: true },
-    }));
-    const device = createV2Device(typedCall);
-
-    const state = await device.getDeviceState();
-
-    expect(state.identity.serialNo).toBe('SERIAL-1');
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall.mock.calls[0][0]).toBe('DeviceInfoGet');
-    expect(typedCall.mock.calls[0][2]?.targets?.status).not.toBe(true);
-    expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
-  });
-
-  test('uses one full DeviceInfoGet plus DeviceStatusGet when firmware refresh initializes state', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => ({
-      message:
-        requestType === 'DeviceInfoGet'
-          ? {
-              protocol_version: 2,
-              hw: { serial_no: 'SERIAL-1' },
-              fw: { application: { version: '5.0.0', hash: 'HASH-1' } },
-            }
-          : { init_states: true, unlocked: true },
-    }));
-    const device = createV2Device(typedCall);
-
-    await device.getDeviceState({
-      refreshSections: ['identity', 'versions', 'verification'],
-    });
-
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenNthCalledWith(
-      1,
-      'DeviceInfoGet',
-      'DeviceInfo',
-      expect.objectContaining({
-        types: expect.objectContaining({ hash: true, build_id: true }),
-      }),
-      expect.anything()
-    );
-  });
-
-  test('does not overwrite confirmed notInitialized mode during a versions refresh', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        protocol_version: 2,
-        hw: { serial_no: 'SERIAL-1' },
-        fw: { application: { version: '5.0.0' } },
-        se1: { application: { version: '1.0.0' } },
-      },
-    });
-    const device = createV2Device(typedCall);
-    device.updateState(
-      {
-        protocol: 'V2',
-        status: { mode: 'notInitialized', initialized: false },
-      },
-      'device-status'
-    );
-
-    const state = await device.getDeviceState({ refreshSections: ['versions'] });
-
-    expect(state.status.mode).toBe('notInitialized');
-    expect(state.status.initialized).toBe(false);
-    expect(state.versions.se01).toBe('1.0.0');
-  });
-
-  test.each(['bootloader', 'romloader'] as const)(
-    'temporarily treats failed DeviceStatusGet with %s metadata as bootloader',
-    async mode => {
-      const typedCall = jest.fn().mockImplementation((requestType: string) => {
-        if (requestType === 'DeviceInfoGet') {
-          return {
-            message: {
-              hw: { serial_no: 'SERIAL-1' },
-              fw:
-                mode === 'romloader'
-                  ? { romloader: { version: '1.0.0' } }
-                  : { bootloader: { version: '1.0.0' } },
-            },
-          };
-        }
-        throw new Error('DeviceStatusGet unavailable');
-      });
-      const device = createV2Device(typedCall);
-      device.updateState({ protocol: 'V2', status: { mode } }, 'initialize');
-
-      const state = await device.getDeviceState({ refreshSections: ['status'] });
-
-      expect(state.status.mode).toBe('bootloader');
-      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-        'DeviceInfoGet',
-        'DeviceStatusGet',
-      ]);
-    }
-  );
-
-  test('refreshes Protocol V2 status only when explicitly requested in normal mode', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: { init_states: true, unlocked: true, device_id: 'device-1' },
-    });
-    const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
-
-    const state = await device.getDeviceState({ refreshSections: ['status'] });
-
-    expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
-    expect(state.status.unlocked).toBe(true);
-    expect(state.identity.deviceId).toBe('device-1');
-  });
-
-  test('refreshes Protocol V2 settings without requesting status', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        label: 'Renamed Pro 2',
-        language: 'ja-JP',
-        brightness: 70,
-      },
-    });
-    const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
-
-    const state = await device.getDeviceState({ refreshSections: ['settings'] });
-
-    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsGet', 'DeviceSettings', {});
-    expect(typedCall).not.toHaveBeenCalledWith(
-      'DeviceStatusGet',
-      expect.anything(),
-      expect.anything()
-    );
-    expect(state.identity.label).toBe('Renamed Pro 2');
-    expect(state.settings.language).toBe('ja-JP');
-    expect(state.settings.brightness).toBe(70);
-  });
-
-  test('refreshes Protocol V2 status before settings in a combined read', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => {
-      if (requestType === 'DeviceInfoGet') {
-        return {
-          message: {
-            hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
-          },
-        };
-      }
-      if (requestType === 'DeviceStatusGet') {
-        return {
-          message: { init_states: true, unlocked: false, device_id: 'device-1' },
-        };
-      }
-      if (requestType === 'DeviceSettingsGet') {
-        return { message: { label: 'Renamed Pro 2' } };
-      }
-      throw new Error(`Unexpected request: ${requestType}`);
-    });
-    const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
-
-    const state = await device.getDeviceState({ refreshSections: ['status', 'settings'] });
-
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceInfoGet',
-      'DeviceStatusGet',
-      'DeviceSettingsGet',
-    ]);
-    expect(state.status.unlocked).toBe(false);
-    expect(state.identity.label).toBe('Renamed Pro 2');
-  });
-
-  test('keeps the refreshed status when a following settings read fails', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => {
-      if (requestType === 'DeviceInfoGet') {
-        return {
-          message: {
-            hw: { serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
-          },
-        };
-      }
-      if (requestType === 'DeviceStatusGet') {
-        return {
-          message: { init_states: true, unlocked: false, device_id: 'device-1' },
-        };
-      }
-      throw Object.assign(new Error('Device locked'), {
-        errorCode: HardwareErrorCode.DeviceLocked,
-      });
-    });
-    const device = createV2Device(typedCall);
-    device.updateState(
-      { protocol: 'V2', status: { mode: 'normal', unlocked: true } },
-      'initialize'
-    );
-
-    await expect(
-      device.getDeviceState({ refreshSections: ['status', 'settings'] })
-    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceLocked });
-
-    const state = await device.getDeviceState();
-    expect(state.status.unlocked).toBe(false);
-    expect(state.identity.deviceId).toBe('device-1');
-  });
-
-  test('rejects an explicit settings refresh without mutating cached state', async () => {
-    const typedCall = jest.fn().mockRejectedValue(
-      Object.assign(new Error('Device locked'), {
-        errorCode: HardwareErrorCode.DeviceLocked,
-      })
-    );
-    const device = createV2Device(typedCall);
-    device.updateState(
-      {
-        protocol: 'V2',
-        identity: { label: 'Persisted label' },
-        status: { mode: 'normal', unlocked: false },
-        settings: { language: 'en-US' },
-      },
-      'initialize'
-    );
-
-    await expect(device.getDeviceState({ refreshSections: ['settings'] })).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceLocked,
-    });
-    const state = await device.getDeviceState();
-
-    expect(state.identity.label).toBe('Persisted label');
-    expect(state.settings.language).toBe('en-US');
-  });
-
-  test('aggregates OnekeyGetFeatures into a Protocol V1 firmware refresh', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => {
-      if (requestType === 'GetFeatures') {
-        return {
-          message: {
-            onekey_device_type: 'PRO',
-            label: 'Pro Wallet',
-            initialized: true,
-            onekey_firmware_version: '4.10.0',
-            onekey_firmware_build_id: 'firmware-build',
-          },
-        };
-      }
-      if (requestType === 'OnekeyGetFeatures') {
-        return {
-          message: {
-            onekey_firmware_version: '4.10.1',
-            onekey_board_build_id: 'board-build',
-            onekey_se01_boot_version: '1.0.0',
-            onekey_se01_boot_build_id: 'se-boot-build',
-            onekey_se01_boot_hash: 'abcd',
-          },
-        };
-      }
-      throw new Error(`Unexpected request: ${requestType}`);
-    });
-    const device = createV1Device(typedCall);
-
-    const state = await device.getDeviceState({
-      refreshSections: ['identity', 'versions', 'verification'],
-      includeRaw: true,
-    });
-
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['GetFeatures', 'OnekeyGetFeatures']);
-    expect(state.versions.firmware).toBe('4.10.1');
-    expect(state.versions.se01Boot).toBe('1.0.0');
-    expect(state.verification).toMatchObject({
-      firmwareBuildId: 'firmware-build',
-      boardBuildId: 'board-build',
-      se01BootBuildId: 'se-boot-build',
-      se01BootHash: 'abcd',
-    });
-    expect(state.raw?.protocolV1OneKeyFeatures).toMatchObject({
-      onekey_board_build_id: 'board-build',
-    });
-  });
-
-  test('does not clear Protocol V1 firmware details during a later runtime refresh', async () => {
-    let getFeaturesCount = 0;
-    const typedCall = jest.fn().mockImplementation((requestType: string) => {
-      if (requestType === 'GetFeatures') {
-        getFeaturesCount += 1;
-        return {
-          message: {
-            onekey_device_type: 'PRO',
-            initialized: true,
-            unlocked: getFeaturesCount === 1,
-            major_version: 4,
-            minor_version: 10,
-            patch_version: 1,
-          },
-        };
-      }
-      if (requestType === 'OnekeyGetFeatures') {
-        return {
-          message: {
-            onekey_se01_boot_version: '1.0.0',
-            onekey_se01_boot_build_id: 'se-boot-build',
-            onekey_se01_boot_hash: 'abcd',
-          },
-        };
-      }
-      throw new Error(`Unexpected request: ${requestType}`);
-    });
-    const device = createV1Device(typedCall);
-
-    await device.getDeviceState({
-      refreshSections: ['identity', 'versions', 'verification'],
-    });
-    const state = await device.getDeviceState({ refreshSections: ['status'] });
-
-    expect(state.status.unlocked).toBe(false);
-    expect(state.versions.se01Boot).toBe('1.0.0');
-    expect(state.verification).toMatchObject({
-      se01BootBuildId: 'se-boot-build',
-      se01BootHash: 'abcd',
-    });
-  });
-
-  test('reloads Protocol V2 DeviceInfo after a physical reconnect', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => {
-      if (requestType === 'DeviceInfoGet') {
-        return {
-          message: {
-            protocol_version: 1,
-            hw: { serial_no: 'SERIAL-1' },
-            fw: { bootloader: { version: '1.0.0' } },
-            se1: {},
-          },
-        };
-      }
-      throw new Error('DeviceStatusGet unavailable in bootloader');
-    });
-    const device = createV2Device(typedCall);
-    device.updateState(
-      {
-        protocol: 'V2',
-        identity: { deviceId: 'wallet-1', serialNo: 'SERIAL-1' },
-        status: { mode: 'normal', initialized: true, unlocked: true },
-      },
-      'initialize'
-    );
-
-    device.markTransportDisconnected();
-    await device.initialize();
-
-    expect(typedCall).toHaveBeenCalledWith(
-      'DeviceInfoGet',
-      'DeviceInfo',
-      expect.anything(),
-      expect.anything()
-    );
-    expect(device.state?.status.mode).toBe('bootloader');
-    expect(device.state?.identity.deviceId).toBeNull();
-  });
-});

package/__tests__/logBlockEvent.test.ts

@@ -1,61 +0,0 @@
-import { UI_RESPONSE, getLogBlockLabel } from '../src/events';
-
-describe('getLogBlockLabel', () => {
-  it('blocks evmSignTypedData params before logging large typed data', () => {
-    expect(
-      getLogBlockLabel({
-        method: 'evmSignTypedData',
-        data: {
-          message: {
-            data: `0x${'ab'.repeat(4096)}`,
-          },
-        },
-      })
-    ).toBe('evmSignTypedData');
-  });
-
-  it('blocks evmSignTypedData iframe call payload before bridge logging', () => {
-    expect(
-      getLogBlockLabel({
-        event: 'iframe-call',
-        type: 'iframe-call',
-        payload: {
-          method: 'evmSignTypedData',
-          data: {
-            message: {
-              data: `0x${'ab'.repeat(4096)}`,
-            },
-          },
-        },
-      })
-    ).toBe('evmSignTypedData');
-  });
-
-  it('keeps existing sensitive UI response blocking', () => {
-    expect(getLogBlockLabel({ type: UI_RESPONSE.RECEIVE_PIN })).toBe(UI_RESPONSE.RECEIVE_PIN);
-  });
-
-  it('blocks deviceSessionOpen secrets in direct and iframe call logging', () => {
-    const payload = {
-      method: 'deviceSessionOpen',
-      host_passphrase: 'hidden-wallet-secret',
-    };
-
-    expect(getLogBlockLabel(payload)).toBe('deviceSessionOpen');
-    expect(
-      getLogBlockLabel({
-        event: 'iframe-call',
-        type: 'iframe-call',
-        payload,
-      })
-    ).toBe('deviceSessionOpen');
-  });
-
-  it.each(['deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
-    'blocks binary payload logging for %s',
-    method => {
-      expect(getLogBlockLabel({ method, data: new Uint8Array(1024) })).toBe(method);
-      expect(getLogBlockLabel({ payload: { method, data: new Uint8Array(1024) } })).toBe(method);
-    }
-  );
-});

package/__tests__/logger.test.ts

@@ -1,34 +0,0 @@
-import { getLog, initLog, setLoggerPostMessage } from '../src/utils/logger';
-
-describe('logger', () => {
-  afterEach(() => {
-    jest.restoreAllMocks();
-    setLoggerPostMessage(() => undefined);
-  });
-
-  it('keeps diagnostic logs while console output is disabled', () => {
-    const prefix = `logger-test-${Date.now()}`;
-    const logger = initLog(prefix, false);
-    const postMessage = jest.fn();
-    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
-    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-    const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-    setLoggerPostMessage(postMessage);
-
-    logger.log('log-message');
-    logger.error('error-message');
-    logger.warn('warn-message');
-    logger.debug('debug-message');
-
-    expect(getLog().filter(item => item.prefix === prefix)).toEqual([
-      expect.objectContaining({ level: 'log', message: ['log-message'] }),
-      expect.objectContaining({ level: 'error', message: ['error-message'] }),
-      expect.objectContaining({ level: 'warn', message: ['warn-message'] }),
-      expect.objectContaining({ level: 'debug', message: ['debug-message'] }),
-    ]);
-    expect(consoleLogSpy).not.toHaveBeenCalled();
-    expect(consoleErrorSpy).not.toHaveBeenCalled();
-    expect(consoleWarnSpy).not.toHaveBeenCalled();
-    expect(postMessage).toHaveBeenCalledTimes(4);
-  });
-});