@onekeyfe/hd-core 1.2.0-alpha.17 → 1.2.0-alpha.170

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

@@ -0,0 +1,103 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import GetDeviceState from '../src/api/GetDeviceState';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('live device state reads', () => {
+  test('public getDeviceState defaults to a runtime refresh and ignores raw controls', async () => {
+    const getDeviceState = jest.fn().mockResolvedValue({ revision: 1 });
+    const method = new GetDeviceState({
+      id: 1,
+      payload: {
+        method: 'getDeviceState',
+        refresh: ['status'],
+        includeRaw: true,
+      },
+    });
+    method.init();
+    (method as any).device = { getDeviceState };
+
+    await method.run();
+
+    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status'] });
+    expect(method.unlockPolicy).toBe('none');
+  });
+
+  test.each([
+    ['firmware', ['status', 'identity', 'versions', 'verification']],
+    ['settings', ['status', 'settings']],
+    ['runtime', ['status']],
+  ] as const)('maps the %s scope to internal refresh sections', async (scope, refreshSections) => {
+    const getDeviceState = jest.fn().mockResolvedValue({
+      revision: 2,
+      status: { mode: 'normal' },
+    });
+    const method = new GetDeviceState({
+      id: 1,
+      payload: { method: 'getDeviceState', scope },
+    });
+    method.init();
+    (method as any).device = {
+      isProtocolV2: () => true,
+      getDeviceState,
+    };
+
+    await method.run();
+
+    expect(getDeviceState).toHaveBeenCalledWith({
+      refreshSections: [...refreshSections],
+    });
+  });
+
+  test.each(['bootloader', 'romloader'] as const)(
+    'returns loader state without rejecting the default runtime read in %s mode',
+    async mode => {
+      const state = { status: { mode } };
+      const getDeviceState = jest.fn().mockResolvedValue(state);
+      const method = new GetDeviceState({
+        id: 1,
+        payload: { method: 'getDeviceState' },
+      });
+      method.init();
+      (method as any).device = {
+        isProtocolV2: () => true,
+        getDeviceState,
+      };
+
+      await expect(method.run()).resolves.toBe(state);
+      expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status'] });
+    }
+  );
+
+  test('rejects settings scope in loader mode after minimal mode detection', async () => {
+    const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'bootloader' } });
+    const method = new GetDeviceState({
+      id: 1,
+      payload: { method: 'getDeviceState', scope: 'settings' },
+    });
+    method.init();
+    (method as any).device = {
+      isProtocolV2: () => true,
+      getCurrentFirmwareType: () => 'universal',
+      getDeviceState,
+    };
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+    });
+    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status', 'settings'] });
+  });
+
+  test('rejects an unknown scope', () => {
+    const method = new GetDeviceState({
+      id: 1,
+      payload: { method: 'getDeviceState', scope: 'unknown' as any },
+    });
+
+    expect(() => method.init()).toThrow();
+  });
+});

package/__tests__/request-context-logging.test.ts

@@ -0,0 +1,16 @@
+import { LoggerNames, getLogger } from '../src/utils/logger';
+import { completeRequestContext, createRequestContext } from '../src/utils/tracing';
+
+describe('RequestContext 错误日志', () => {
+  test('已作为 API 响应返回的请求错误不写入 console.error 级别', () => {
+    const logger = getLogger(LoggerNames.Core);
+    const errorSpy = jest.spyOn(logger, 'error').mockImplementation(() => undefined);
+    const debugSpy = jest.spyOn(logger, 'debug').mockImplementation(() => undefined);
+
+    createRequestContext(1001, 'searchDevices', { sdkInstanceId: 'SDK-test' });
+    completeRequestContext(1001, new Error('device did not respond'));
+
+    expect(errorSpy).not.toHaveBeenCalled();
+    expect(debugSpy).toHaveBeenCalledWith(expect.stringContaining('method=searchDevices'));
+  });
+});

package/__tests__/resourceBase64Boundary.test.ts

@@ -0,0 +1,48 @@
+import { HardwareTopLevelSdk } from '../src';
+import { findMethod } from '../src/api/utils';
+
+import type { LowLevelCoreApi } from '../src';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+const crossJsonOnlyBridge = (value: unknown): unknown => JSON.parse(JSON.stringify(value));
+
+describe('Base64 resource boundary', () => {
+  test('keeps Portfolio, wallpaper and NFT payloads JSON-safe across TopLevel and LowLevel', async () => {
+    const restoredPayloads: Array<Record<string, any>> = [];
+    const lowLevelApi = {
+      call: jest.fn(params => {
+        const method = findMethod({ id: 1, payload: crossJsonOnlyBridge(params) } as any);
+        restoredPayloads.push(method.payload);
+        return Promise.resolve({ success: true, payload: {} });
+      }),
+      init: jest.fn(() => Promise.resolve(true)),
+    } as unknown as LowLevelCoreApi;
+    const sdk = HardwareTopLevelSdk();
+    await sdk.init({}, lowLevelApi);
+
+    await sdk.uploadPortfolio('connect-id', { packageBase64: 'AQID' });
+    await sdk.deviceUploadWallpaper('connect-id', { jpegBase64: '/9j/' });
+    await sdk.deviceUploadNft('connect-id', {
+      imageJpegBase64: '/9j/',
+      thumbnailJpegBase64: '/9j/',
+      title: 'NFT',
+      subtitle: '',
+    });
+
+    expect(restoredPayloads.map(payload => payload.method)).toEqual([
+      'uploadPortfolio',
+      'deviceUploadWallpaper',
+      'deviceUploadNft',
+    ]);
+    expect(restoredPayloads[0].packageBase64).toBe('AQID');
+    expect(restoredPayloads[1].jpegBase64).toBe('/9j/');
+    expect(restoredPayloads[2]).toMatchObject({
+      imageJpegBase64: '/9j/',
+      thumbnailJpegBase64: '/9j/',
+    });
+  });
+});

package/__tests__/search-devices.test.ts

@@ -0,0 +1,192 @@
+import SearchDevices from '../src/api/SearchDevices';
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  __esModule: true,
+  default: {
+    configure: jest.fn(),
+  },
+}));
+
+jest.mock('../src/data-manager', () => ({
+  DataManager: {
+    getSettings: jest.fn(() => 'webusb'),
+    isBleConnect: jest.fn(() => false),
+  },
+}));
+
+jest.mock('../src/device/DevicePool', () => ({
+  DevicePool: {
+    getDevices: jest.fn(),
+  },
+}));
+
+const transportManagerMock: { default: { configure: jest.Mock } } = jest.requireMock(
+  '../src/data-manager/TransportManager'
+);
+const devicePoolMock: { DevicePool: { getDevices: jest.Mock } } = jest.requireMock(
+  '../src/device/DevicePool'
+);
+const dataManagerMock: {
+  DataManager: {
+    getSettings: jest.Mock;
+    isBleConnect: jest.Mock;
+  };
+} = jest.requireMock('../src/data-manager');
+const { configure: mockConfigureTransport } = transportManagerMock.default;
+const { getDevices: mockGetDevices } = devicePoolMock.DevicePool;
+const { isBleConnect: mockIsBleConnect } = dataManagerMock.DataManager;
+
+describe('SearchDevices', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockIsBleConnect.mockReturnValue(false);
+  });
+
+  test('搜索忽略调用方协议并主动探测，单个无响应设备不阻断后续结果', async () => {
+    const unresponsiveDescriptor = {
+      path: 'stale-usb-device',
+      id: 'stale-usb-device',
+    } as any;
+    const availableDescriptor = {
+      path: 'available-usb-device',
+      id: 'available-usb-device',
+    } as any;
+    const availableDeviceInfo = {
+      connectId: 'available-usb-device',
+      deviceType: 'pro2',
+    };
+    const availableDevice = {
+      toMessageObject: jest.fn(() => availableDeviceInfo),
+    } as any;
+
+    mockGetDevices
+      .mockRejectedValueOnce(
+        new Error(
+          'Unable to detect USB protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping'
+        )
+      )
+      .mockResolvedValueOnce({
+        devices: { 'available-usb-device': availableDevice },
+        deviceList: [availableDevice],
+      });
+
+    const method = new SearchDevices({
+      id: 1,
+      payload: {
+        method: 'searchDevices',
+        connectProtocol: 'V2',
+      },
+    } as any);
+    method.init();
+    method.connector = {
+      enumerate: jest.fn().mockResolvedValue({
+        descriptors: [unresponsiveDescriptor, availableDescriptor],
+      }),
+    } as any;
+
+    await expect(method.run()).resolves.toEqual([availableDeviceInfo]);
+    expect(mockConfigureTransport).toHaveBeenCalledTimes(1);
+    expect(mockGetDevices).toHaveBeenNthCalledWith(
+      1,
+      [unresponsiveDescriptor],
+      unresponsiveDescriptor.path,
+      {
+        connectProtocol: undefined,
+        forceProtocolDetection: true,
+        refreshRuntimeState: true,
+      }
+    );
+    expect(mockGetDevices).toHaveBeenNthCalledWith(
+      2,
+      [availableDescriptor],
+      availableDescriptor.path,
+      {
+        connectProtocol: undefined,
+        forceProtocolDetection: true,
+        refreshRuntimeState: true,
+      }
+    );
+  });
+
+  test.each([
+    ['OneKey Pro', 'pro'],
+    ['OneKey Pro 2', 'pro2'],
+    ['Neo A1B2', 'neo'],
+  ])(
+    'BLE discovery keeps the %s transport identity separate from device identity',
+    async (name, deviceType) => {
+      mockIsBleConnect.mockReturnValue(true);
+
+      const descriptor = {
+        id: 'ble-peripheral-id',
+        path: 'ble-peripheral-id',
+        name,
+        commType: 'ble',
+      };
+      const method = new SearchDevices({
+        id: 1,
+        payload: {
+          method: 'searchDevices',
+        },
+      } as any);
+      method.init();
+      method.connector = {
+        enumerate: jest.fn().mockResolvedValue({
+          descriptors: [descriptor],
+        }),
+      } as any;
+
+      await expect(method.run()).resolves.toEqual([
+        {
+          ...descriptor,
+          connectId: 'ble-peripheral-id',
+          serialNo: null,
+          uuid: '',
+          deviceId: null,
+          deviceType,
+        },
+      ]);
+      expect(mockGetDevices).not.toHaveBeenCalled();
+    }
+  );
+
+  test.each([
+    ['Pro2 A1B2 - Find My', undefined, 'Pro 2 A1B2'],
+    ['Pro2 5E9D - Finde My', undefined, 'Pro 2 5E9D'],
+    ['Pro2 22D8FindMy', undefined, 'Pro 2 22D8'],
+    ['Pro 2 A1B2 - Find My', undefined, 'Pro 2 A1B2'],
+    [undefined, 'OneKey Pro 2 A1B2 - Find My', 'OneKey Pro 2 A1B2'],
+  ])(
+    'BLE discovery normalizes the Find My display name from name=%s localName=%s',
+    async (name, localName, expectedName) => {
+      mockIsBleConnect.mockReturnValue(true);
+
+      const method = new SearchDevices({
+        id: 1,
+        payload: { method: 'searchDevices' },
+      } as any);
+      method.init();
+      method.connector = {
+        enumerate: jest.fn().mockResolvedValue({
+          descriptors: [
+            {
+              id: 'ble-peripheral-id',
+              path: 'ble-peripheral-id',
+              name,
+              localName,
+              commType: 'ble',
+            },
+          ],
+        }),
+      } as any;
+
+      await expect(method.run()).resolves.toEqual([
+        expect.objectContaining({
+          connectId: 'ble-peripheral-id',
+          name: expectedName,
+          deviceType: 'pro2',
+        }),
+      ]);
+    }
+  );
+});

package/__tests__/ton-sign-message.test.ts

@@ -0,0 +1,84 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import TonSignMessage from '../src/api/ton/TonSignMessage';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+const createMethod = (deviceType: EDeviceType) => {
+  const method = new TonSignMessage({
+    id: 1,
+    payload: {
+      method: 'tonSignMessage',
+    },
+  });
+
+  Object.defineProperty(method, 'device', {
+    value: {
+      getCurrentDeviceType: () => deviceType,
+    },
+  });
+
+  return method;
+};
+
+describe('TonSignMessage response compatibility', () => {
+  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
+    'uses the corrected signing_message field for %s',
+    async deviceType => {
+      const method = createMethod(deviceType);
+
+      await expect(
+        method.processTxRequest(
+          {
+            signature: 'signature',
+            signing_message: 'serialized-message',
+          },
+          ''
+        )
+      ).resolves.toEqual({
+        signature: 'signature',
+        signing_message: 'serialized-message',
+        skip_validate: false,
+      });
+    }
+  );
+
+  test('normalizes the legacy Protocol V1 field without removing it', async () => {
+    const method = createMethod(EDeviceType.Classic1s);
+
+    await expect(
+      method.processTxRequest(
+        {
+          signature: 'signature',
+          signning_message: 'message-hash',
+        },
+        ''
+      )
+    ).resolves.toEqual({
+      signature: 'signature',
+      signning_message: 'message-hash',
+      signing_message: 'message-hash',
+      skip_validate: true,
+    });
+  });
+
+  test('skips validation when blind signing omits the signing message', async () => {
+    const method = createMethod(EDeviceType.Pro2);
+
+    await expect(
+      method.processTxRequest(
+        {
+          signature: 'signature',
+        },
+        ''
+      )
+    ).resolves.toEqual({
+      signature: 'signature',
+      signing_message: undefined,
+      skip_validate: true,
+    });
+  });
+});

package/__tests__/tron-sign-message-init.test.ts

@@ -0,0 +1,74 @@
+import { EFirmwareType, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import TronSignMessage from '../src/api/tron/TronSignMessage';
+
+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/',
+}));
+
+describe('TronSignMessage legacy message validation', () => {
+  test.each([EFirmwareType.BitcoinOnly, EFirmwareType.Universal])(
+    'reports the current device firmware type after binding: %s',
+    async firmwareType => {
+      const method = new TronSignMessage({
+        id: 1,
+        payload: {
+          method: 'tronSignMessage',
+          path: "m/44'/195'/0'/0/0",
+          messageHex: '00',
+          messageType: 'V1',
+        },
+      });
+
+      method.init();
+      method.device = {
+        getCurrentFirmwareType: jest.fn(() => firmwareType),
+      } as unknown as Device;
+
+      try {
+        await method.run();
+        throw new Error('Expected run to reject the legacy message type');
+      } catch (error: unknown) {
+        expect(error).toBeInstanceOf(HardwareError);
+        if (!(error instanceof HardwareError)) return;
+
+        expect(error.errorCode).toBe(HardwareErrorCode.DeviceNotSupportMethod);
+        expect(error.params).toMatchObject({
+          firmwareType,
+          method: 'TronSignMessage',
+        });
+      }
+    }
+  );
+
+  test('allows Protocol V2 message signing on the Pro2 product family', async () => {
+    const method = new TronSignMessage({
+      id: 1,
+      payload: {
+        method: 'tronSignMessage',
+        path: "m/44'/195'/0'/0/0",
+        messageHex: '00',
+        messageType: 'V2',
+      },
+    });
+    method.init();
+
+    const typedCall = jest.fn().mockResolvedValue({ message: { signature: 'signature' } });
+    method.device = {
+      commands: { typedCall },
+      getCurrentFirmwareVersionString: jest.fn(() => '0.0.0'),
+      getCurrentMethodVersionRange: jest.fn(selector => selector('model_pro2')),
+      getCurrentFirmwareType: jest.fn(() => EFirmwareType.Universal),
+    } as unknown as Device;
+
+    await expect(method.run()).resolves.toEqual({ signature: 'signature' });
+    expect(typedCall).toHaveBeenCalledWith('TronSignMessage', 'TronMessageSignature', {
+      address_n: [2147483692, 2147483843, 2147483648, 0, 0],
+      message: '00',
+      message_type: 2,
+    });
+  });
+});

package/__tests__/uiProgressThrottle.test.ts

@@ -0,0 +1,74 @@
+import { createUiMessage } from '../src/events';
+import { UI_REQUEST } from '../src/events/ui-request';
+import { createUiProgressMessageFilter } from '../src/utils/uiProgressThrottle';
+
+import type { KnownDevice } from '../src/types';
+
+describe('createUiProgressMessageFilter', () => {
+  let currentTime: number;
+  let shouldPostMessage: ReturnType<typeof createUiProgressMessageFilter>;
+
+  beforeEach(() => {
+    currentTime = 1_000;
+    shouldPostMessage = createUiProgressMessageFilter(250, () => currentTime);
+  });
+
+  const firmwareProgress = (
+    progress: number,
+    progressType: 'transferData' | 'installingFirmware' = 'transferData'
+  ) =>
+    createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
+      device: {} as KnownDevice,
+      progress,
+      progressType,
+    });
+
+  test('limits firmware progress to one event per interval', () => {
+    expect(shouldPostMessage(firmwareProgress(1))).toBe(true);
+
+    currentTime += 100;
+    expect(shouldPostMessage(firmwareProgress(1))).toBe(false);
+
+    currentTime += 150;
+    expect(shouldPostMessage(firmwareProgress(1))).toBe(true);
+  });
+
+  test('limits transfer and install progress independently', () => {
+    expect(shouldPostMessage(firmwareProgress(1, 'transferData'))).toBe(true);
+    expect(shouldPostMessage(firmwareProgress(1, 'installingFirmware'))).toBe(true);
+
+    currentTime += 10;
+    expect(shouldPostMessage(firmwareProgress(2, 'transferData'))).toBe(false);
+    expect(shouldPostMessage(firmwareProgress(2, 'installingFirmware'))).toBe(false);
+  });
+
+  test('emits phase boundaries immediately and suppresses duplicate boundaries', () => {
+    expect(shouldPostMessage(firmwareProgress(0))).toBe(true);
+    expect(shouldPostMessage(firmwareProgress(0))).toBe(false);
+
+    currentTime += 10;
+    expect(shouldPostMessage(firmwareProgress(50))).toBe(false);
+    expect(shouldPostMessage(firmwareProgress(100))).toBe(true);
+    expect(shouldPostMessage(firmwareProgress(100))).toBe(false);
+
+    expect(shouldPostMessage(firmwareProgress(0))).toBe(true);
+  });
+
+  test('treats decreasing progress as a new phase', () => {
+    expect(shouldPostMessage(firmwareProgress(80))).toBe(true);
+
+    currentTime += 10;
+    expect(shouldPostMessage(firmwareProgress(20))).toBe(true);
+  });
+
+  test('also limits device progress and leaves other UI events unchanged', () => {
+    const deviceProgress = (progress: number) =>
+      createUiMessage(UI_REQUEST.DEVICE_PROGRESS, { progress });
+
+    expect(shouldPostMessage(deviceProgress(1))).toBe(true);
+    currentTime += 10;
+    expect(shouldPostMessage(deviceProgress(2))).toBe(false);
+
+    expect(shouldPostMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW))).toBe(true);
+  });
+});