@onekeyfe/hd-core 1.2.0-alpha.1 → 1.2.0-alpha.11

package/__tests__/DeviceCommands.test.ts

@@ -16,6 +16,31 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
+  it('maps Protocol V2 DeviceLocked failure to a structured hardware error', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 9,
+            message: 'Device locked',
+          },
+        } as any,
+        'DeviceSettingsPageShow'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceLocked,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: 9,
+        firmwareMessage: 'Device locked',
+      },
+    });
+  });
+
   it.each([
     ['ButtonAck', 'Not in Ethereum signing mode'],
     ['PinMatrixAck', 'Not in Conflux signing mode'],

package/__tests__/RequestQueue.test.ts

@@ -0,0 +1,34 @@
+import RequestQueue from '../src/core/RequestQueue';
+
+import type { BaseMethod } from '../src/api/BaseMethod';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+function buildMethod(responseID: number, operationId?: string) {
+  return {
+    payload: { operationId },
+    responseID,
+  } as unknown as BaseMethod;
+}
+
+describe('RequestQueue operation cancellation', () => {
+  test('aborts only the request matching the operation id', () => {
+    const queue = new RequestQueue();
+    const portfolio = queue.createTask(buildMethod(1, 'portfolio-1'));
+    const userAction = queue.createTask(buildMethod(2, 'user-action'));
+
+    expect(queue.abortOperation('portfolio-1')).toBe(true);
+    expect(portfolio.abortController?.signal.aborted).toBe(true);
+    expect(userAction.abortController?.signal.aborted).toBe(false);
+  });
+
+  test('returns false for an unknown operation id', () => {
+    const queue = new RequestQueue();
+    queue.createTask(buildMethod(1, 'portfolio-1'));
+
+    expect(queue.abortOperation('missing')).toBe(false);
+  });
+});

package/__tests__/connectSettings.test.ts

@@ -0,0 +1,19 @@
+import { parseConnectSettings } from '../src/data-manager/connectSettings';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('parseConnectSettings', () => {
+  it('keeps custom configFetcher in parsed settings', () => {
+    const configFetcher = jest.fn();
+
+    const settings = parseConnectSettings({
+      fetchConfig: true,
+      configFetcher,
+    });
+
+    expect(settings.configFetcher).toBe(configFetcher);
+  });
+});

package/__tests__/device-wallet-session-store.test.ts

@@ -0,0 +1,131 @@
+import ClearSessionCache from '../src/api/ClearSessionCache';
+import {
+  DeviceWalletSessionStore,
+  deviceWalletSessionStore,
+} from '../src/device/DeviceWalletSessionStore';
+import { createCoreApi } from '../src/inject';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('DeviceWalletSessionStore', () => {
+  test('requires passphraseState for wallet session lookup', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'session-a');
+
+    expect(store.get('device-1', undefined)).toBeUndefined();
+    expect(store.get('device-1', 'hidden-a')).toBe('session-a');
+  });
+
+  test('isolates wallets and devices', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'session-a');
+    store.set('device-1', 'hidden-b', 'session-b');
+    store.set('device-2', 'hidden-a', 'session-c');
+
+    expect(store.get('device-1', 'hidden-a')).toBe('session-a');
+    expect(store.get('device-1', 'hidden-b')).toBe('session-b');
+    expect(store.get('device-2', 'hidden-a')).toBe('session-c');
+  });
+
+  test('keeps pending sessions unreadable until wallet binding', () => {
+    const store = new DeviceWalletSessionStore();
+    store.setPending('device-1', 'pending-session');
+
+    expect(store.get('device-1', undefined)).toBeUndefined();
+    expect(store.getPending('device-1')).toBe('pending-session');
+  });
+
+  test('migrates descriptor keys to stable device ids', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('ble-path', 'hidden-a', 'session-a');
+    store.setPending('ble-path', 'pending-session');
+
+    store.migrateDeviceKey('ble-path', 'stable-device-id');
+
+    expect(store.get('ble-path', 'hidden-a')).toBeUndefined();
+    expect(store.get('stable-device-id', 'hidden-a')).toBe('session-a');
+    expect(store.getPending('ble-path')).toBeUndefined();
+    expect(store.getPending('stable-device-id')).toBe('pending-session');
+  });
+
+  test('clears one wallet, one device, or all sessions', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'session-a');
+    store.set('device-1', 'hidden-b', 'session-b');
+    store.set('device-2', 'hidden-a', 'session-c');
+
+    store.delete('device-1', 'hidden-a');
+    expect(store.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(store.get('device-1', 'hidden-b')).toBe('session-b');
+
+    store.deleteDevice('device-1');
+    expect(store.get('device-1', 'hidden-b')).toBeUndefined();
+    expect(store.get('device-2', 'hidden-a')).toBe('session-c');
+
+    store.clear();
+    expect(store.get('device-2', 'hidden-a')).toBeUndefined();
+  });
+});
+
+describe('ClearSessionCache', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+  });
+
+  test('clears one wallet without using a device', async () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-1', 'hidden-b', 'session-b');
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
+      },
+    });
+
+    method.init();
+
+    expect(method.useDevice).toBe(false);
+    await expect(method.run()).resolves.toEqual({ cleared: true });
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-b')).toBe('session-b');
+  });
+
+  test('clears one device or the full runtime store', async () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
+
+    const clearDevice = new ClearSessionCache({
+      payload: { method: 'clearSessionCache', deviceId: 'device-1' },
+    });
+    clearDevice.init();
+    await clearDevice.run();
+
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
+
+    const clearAll = new ClearSessionCache({
+      payload: { method: 'clearSessionCache' },
+    });
+    clearAll.init();
+    await clearAll.run();
+
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBeUndefined();
+  });
+
+  test('routes cache clearing through the active CoreApi call channel', async () => {
+    const call = jest.fn().mockResolvedValue({ success: true, payload: { cleared: true } });
+    const api = createCoreApi(call as any);
+
+    await api.clearSessionCache({ deviceId: 'device-1', passphraseState: 'hidden-a' });
+
+    expect(call).toHaveBeenCalledWith({
+      method: 'clearSessionCache',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-a',
+    });
+  });
+});

package/__tests__/preInitialize.test.ts

@@ -1,4 +1,9 @@
 import { Device } from '../src/device/Device';
+import { initCore } from '../src/core';
+import PreInitialize from '../src/api/device/PreInitialize';
+import { IFRAME } from '../src/events';
+
+import type Core from '../src/core';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -6,6 +11,10 @@ jest.mock('../src/data/config', () => ({
 }));
 
 describe('preInitialize', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
   it('matches pre-initialized state by passphraseState only', () => {
     const device = Object.create(Device.prototype) as Device;
 
@@ -19,4 +28,28 @@ describe('preInitialize', () => {
       })
     ).toBe(true);
   });
+
+  it('cleans request lifecycle when preInitialize is acknowledged without connectId', async () => {
+    const core: Core = initCore();
+    const disposeSpy = jest.spyOn(PreInitialize.prototype, 'dispose');
+
+    try {
+      const response = await core.handleMessage({
+        id: 1001,
+        type: IFRAME.CALL,
+        payload: {
+          method: 'preInitialize',
+        },
+      } as any);
+
+      expect(response).toMatchObject({
+        success: true,
+        payload: true,
+      });
+      expect((core as any).tracingContext.activeRequests.has(1001)).toBe(false);
+      expect(disposeSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      core.dispose();
+    }
+  });
 });

package/__tests__/pro2Wallpaper.test.ts

@@ -0,0 +1,50 @@
+import { encodePro2Wallpaper } from '../src/utils/pro2Wallpaper';
+
+describe('encodePro2Wallpaper', () => {
+  test('encodes opaque pixels as aligned LVGL v9 RGB565 data', () => {
+    const result = encodePro2Wallpaper({
+      width: 2,
+      height: 1,
+      rgba: new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255]),
+    });
+
+    expect(result.colorFormat).toBe('RGB565');
+    expect(Array.from(result.data.slice(0, 12))).toEqual([
+      0x19,
+      0x12,
+      0,
+      0,
+      2,
+      0,
+      1,
+      0,
+      4,
+      0,
+      0,
+      0,
+    ]);
+    expect(Array.from(result.data.slice(12))).toEqual([0x00, 0xf0, 0xc0, 0x07]);
+  });
+
+  test('encodes transparent pixels as RGB565A8 with alpha plane after RGB data', () => {
+    const result = encodePro2Wallpaper({
+      width: 2,
+      height: 1,
+      rgba: new Uint8Array([0, 0, 255, 128, 255, 255, 255, 255]),
+    });
+
+    expect(result.colorFormat).toBe('RGB565A8');
+    expect(result.data[1]).toBe(0x14);
+    expect(Array.from(result.data.slice(8, 10))).toEqual([4, 0]);
+    expect(Array.from(result.data.slice(12))).toEqual([0x1f, 0x00, 0xff, 0xff, 128, 255]);
+  });
+
+  test('rejects invalid dimensions and RGBA byte length', () => {
+    expect(() =>
+      encodePro2Wallpaper({ width: 0, height: 1, rgba: new Uint8Array() })
+    ).toThrow('width');
+    expect(() =>
+      encodePro2Wallpaper({ width: 2, height: 1, rgba: new Uint8Array(4) })
+    ).toThrow('8');
+  });
+});

package/__tests__/protocol-v2-firmware-targets.test.ts

@@ -0,0 +1,19 @@
+import { ProtocolV2FirmwareTargetType } from '../src/protocols/protocol-v2/firmware';
+
+describe('Protocol V2 firmware target contract', () => {
+  test('matches the current firmware-pro2 target ids', () => {
+    expect(ProtocolV2FirmwareTargetType).toEqual({
+      FW_MGMT_TARGET_INVALID: 0,
+      FW_MGMT_TARGET_CRATE: 1,
+      FW_MGMT_TARGET_ROMLOADER: 2,
+      FW_MGMT_TARGET_BOOTLOADER: 3,
+      FW_MGMT_TARGET_APPLICATION_P1: 4,
+      FW_MGMT_TARGET_APPLICATION_P2: 5,
+      FW_MGMT_TARGET_COPROCESSOR: 6,
+      FW_MGMT_TARGET_SE01: 7,
+      FW_MGMT_TARGET_SE02: 8,
+      FW_MGMT_TARGET_SE03: 9,
+      FW_MGMT_TARGET_SE04: 10,
+    });
+  });
+});