@onekeyfe/hd-core 1.2.0-alpha.0 → 1.2.0-alpha.10

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__/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,
+    });
+  });
+});