@onekeyfe/hd-core 1.2.0-alpha.19 → 1.2.0-alpha.20

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -0,0 +1,75 @@
+import AllNetworkGetAddressBase from '../src/api/allnetwork/AllNetworkGetAddressBase';
+import { findMethod } from '../src/api/utils';
+import { getActiveRequestsByDeviceInstance } from '../src/utils/tracing';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+jest.mock('../src/api/utils', () => ({
+  findMethod: jest.fn(),
+}));
+
+class TestAllNetworkMethod extends AllNetworkGetAddressBase {
+  async getAllNetworkAddress() {
+    return Promise.resolve([]);
+  }
+}
+
+describe('AllNetworkGetAddressBase tracing', () => {
+  test('releases the nested request context when an unhandled error escapes', async () => {
+    const deviceInstanceId = 'device-instance';
+    const innerMethod = {
+      checkSafetyLevelOnTestNet: jest.fn().mockResolvedValue(false),
+      connectId: 'connect-id',
+      deviceId: 'device-id',
+      getVersionRange: jest.fn().mockReturnValue({}),
+      init: jest.fn(),
+      name: 'xrpGetAddress',
+      responseID: 42,
+      run: jest.fn().mockRejectedValue(new Error('address failed')),
+      setDevice: jest.fn(),
+      strictCheckDeviceSupport: false,
+    };
+    (findMethod as jest.Mock).mockReturnValue(innerMethod);
+    const method = new TestAllNetworkMethod({
+      id: 1,
+      payload: {
+        method: 'allNetworkGetAddress',
+        connectId: 'connect-id',
+        deviceId: 'device-id',
+        bundle: [],
+      },
+    });
+    method.device = {
+      instanceId: deviceInstanceId,
+      getCurrentFirmwareType: jest.fn(),
+      getCurrentFirmwareVersionString: jest.fn().mockReturnValue('1.0.0'),
+      getCurrentMethodVersionRange: jest
+        .fn()
+        .mockImplementation((getRange: (type: string) => unknown) => getRange('classic')),
+      off: jest.fn(),
+      on: jest.fn(),
+    } as any;
+
+    await expect(
+      method.callMethod(
+        'xrpGetAddress',
+        {
+          bundle: [
+            {
+              _originRequestParams: {
+                network: 'xrp',
+                path: "m/44'/144'/0'/0/0",
+              },
+            },
+          ],
+        },
+        0
+      )
+    ).rejects.toThrow('address failed');
+
+    expect(getActiveRequestsByDeviceInstance(deviceInstanceId)).toEqual([]);
+  });
+});

package/__tests__/DeviceCommands.test.ts

@@ -2,6 +2,7 @@ import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { DeviceCommands } from '../src/device/DeviceCommands';
 import { DEVICE } from '../src/events';
+import { LoggerNames, getLogger } from '../src/utils';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -18,6 +19,48 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
+  it('does not log DeviceSessionGet response secrets', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.DeviceCommands);
+    log.messages.length = 0;
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'DeviceSession',
+          message: {
+            session_id: 'secret-session-id',
+            btc_test_address: 'secret-wallet-address',
+          },
+        } as any,
+        'DeviceSessionGet'
+      )
+    ).resolves.toMatchObject({ type: 'DeviceSession' });
+
+    expect(JSON.stringify(log.messages)).not.toContain('secret-session-id');
+    expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
+  });
+
+  it('rejects the Pro2 bootloader DeviceStatusGet unsupported response', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_InvalidMessage',
+            message: 'Handler not registered',
+          },
+        } as any,
+        'DeviceStatusGet'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: 'Failure_InvalidMessage,Handler not registered',
+    });
+  });
+
   it('maps Protocol V2 DeviceLocked failure to a structured hardware error', async () => {
     const commands = createCommands();
 
@@ -43,6 +86,97 @@ describe('DeviceCommands failure mapping', () => {
     });
   });
 
+  it('maps Protocol V2 action-cancelled subcode to the canonical cancellation error', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 3,
+            message: 'Cancelled on device',
+          },
+        } as any,
+        'DeviceSettingsSet'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.ActionCancelled,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: 3,
+        firmwareMessage: 'Cancelled on device',
+      },
+    });
+  });
+
+  it.each(['Cancelled on device', 'Confirm dismissed'])(
+    'maps legacy Protocol V2 cancellation message "%s" without a subcode',
+    async message => {
+      const commands = createCommands();
+
+      await expect(
+        commands._filterCommonTypes(
+          {
+            type: 'Failure',
+            message: {
+              code: 'Failure_ProcessError',
+              message,
+            },
+          } as any,
+          'DeviceSettingsSet'
+        )
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.ActionCancelled,
+        params: {
+          failureCode: 'Failure_ProcessError',
+          firmwareMessage: message,
+        },
+      });
+    }
+  );
+
+  it('does not use the legacy cancellation-message fallback for Protocol V1', async () => {
+    const commands = createCommands();
+    (commands.device.isProtocolV2 as jest.Mock).mockReturnValue(false);
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            message: 'Cancelled on device',
+          },
+        } as any,
+        'ApplySettings'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+    });
+  });
+
+  it('keeps an unrecognized Protocol V2 process subcode generic', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 1,
+            message: 'Another process error',
+          },
+        } as any,
+        'DeviceSettingsPageShow'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+    });
+  });
+
   it.each(['Device locked', 'Device is locked'])(
     'maps legacy Protocol V2 locked message "%s" without a subcode',
     async message => {
@@ -174,17 +308,19 @@ describe('DeviceCommands failure mapping', () => {
 describe('DeviceCommands Protocol V2 interactive response compatibility', () => {
   it('still auto-acks ButtonRequest when no hardware UI listener is registered', async () => {
     const commands = createCommands();
+    const emit = jest.fn();
+    const commonCall = jest.fn().mockResolvedValue({
+      type: 'Success',
+      message: {},
+    });
     commands.device = {
       ...commands.device,
       getCurrentDeviceType: jest.fn(() => 'pro2'),
       setCancelableAction: jest.fn(),
-      emit: jest.fn(),
+      emit,
       listenerCount: jest.fn(() => 0),
     } as any;
-    commands._commonCall = jest.fn().mockResolvedValue({
-      type: 'Success',
-      message: {},
-    }) as any;
+    commands._commonCall = commonCall as any;
 
     await expect(
       commands._filterCommonTypes(
@@ -196,12 +332,12 @@ describe('DeviceCommands Protocol V2 interactive response compatibility', () =>
       )
     ).resolves.toMatchObject({ type: 'Success' });
 
-    expect(commands.device.emit).toHaveBeenCalledWith(
+    expect(emit).toHaveBeenCalledWith(
       DEVICE.BUTTON,
       commands.device,
       expect.objectContaining({ code: 'ButtonRequest_PinEntry' })
     );
-    expect(commands._commonCall).toHaveBeenCalledWith('ButtonAck', {}, undefined);
+    expect(commonCall).toHaveBeenCalledWith('ButtonAck', {}, undefined);
   });
 
   it('rejects PassphraseRequest when the Pro2 UI listener is not registered', async () => {

package/__tests__/RequestQueue.test.ts

@@ -9,11 +9,20 @@ jest.mock('../src/data/config', () => ({
 
 function buildMethod(responseID: number, operationId?: string) {
   return {
+    connectId: 'device-1',
+    executionPriority: 'normal',
     payload: { operationId },
     responseID,
   } as unknown as BaseMethod;
 }
 
+function buildBackgroundMethod(responseID: number, operationId?: string) {
+  return {
+    ...buildMethod(responseID, operationId),
+    executionPriority: 'background',
+  } as unknown as BaseMethod;
+}
+
 describe('RequestQueue operation cancellation', () => {
   test('aborts only the request matching the operation id', () => {
     const queue = new RequestQueue();
@@ -31,4 +40,101 @@ describe('RequestQueue operation cancellation', () => {
 
     expect(queue.abortOperation('missing')).toBe(false);
   });
+
+  test('honors cancellation that arrives before the request is registered', () => {
+    const queue = new RequestQueue();
+
+    expect(queue.abortOperation('portfolio-1')).toBe(false);
+
+    const portfolio = queue.createTask(buildMethod(1, 'portfolio-1'));
+    const userAction = queue.createTask(buildMethod(2, 'user-action'));
+
+    expect(portfolio.abortController?.signal.aborted).toBe(true);
+    expect(userAction.abortController?.signal.aborted).toBe(false);
+  });
+
+  test('expires a cancellation that is never matched', () => {
+    const nowSpy = jest.spyOn(Date, 'now');
+    nowSpy.mockReturnValueOnce(1_000);
+    const queue = new RequestQueue();
+    queue.abortOperation('portfolio-1');
+    nowSpy.mockReturnValue(31_001);
+
+    const portfolio = queue.createTask(buildMethod(1, 'portfolio-1'));
+
+    expect(portfolio.abortController?.signal.aborted).toBe(false);
+    nowSpy.mockRestore();
+  });
+
+  test('rejects a background request while the device has an active user request', async () => {
+    const queue = new RequestQueue();
+    queue.createTask(buildMethod(1, 'user-action'));
+
+    await expect(
+      queue.admitTask(buildBackgroundMethod(2, 'portfolio-1'), {
+        backgroundPreemptTimeoutMs: 100,
+      })
+    ).resolves.toMatchObject({ status: 'busy' });
+    expect(queue.getTask(2)).toBeUndefined();
+  });
+
+  test('aborts and waits for an active background request before admitting a user request', async () => {
+    const queue = new RequestQueue();
+    const portfolio = queue.createTask(buildBackgroundMethod(1, 'portfolio-1'));
+
+    const admission = queue.admitTask(buildMethod(2, 'user-action'), {
+      backgroundPreemptTimeoutMs: 100,
+    });
+    await Promise.resolve();
+
+    expect(portfolio.abortController?.signal.aborted).toBe(true);
+    expect(queue.getTask(2)).toBeUndefined();
+
+    portfolio.settled.resolve();
+    await Promise.resolve();
+    expect(queue.getTask(2)).toBeUndefined();
+
+    queue.releaseTask(1);
+
+    await expect(admission).resolves.toMatchObject({
+      status: 'reserved',
+      task: { id: 2 },
+    });
+  });
+
+  test('uses the background method abort latency when no admission override is provided', async () => {
+    const queue = new RequestQueue();
+    const portfolio = queue.createTask(buildBackgroundMethod(1, 'portfolio-1'));
+    portfolio.method.maxAbortLatencyMs = 12_000;
+    const waitForTasksReleased = jest
+      .spyOn(queue as any, 'waitForTasksReleased')
+      .mockResolvedValue(false);
+
+    await expect(queue.admitTask(buildMethod(2, 'user-action'))).resolves.toMatchObject({
+      status: 'busy',
+    });
+    expect(waitForTasksReleased).toHaveBeenCalledWith([portfolio], 12_000);
+  });
+
+  test('returns busy when an aborted background request does not release in time', async () => {
+    const queue = new RequestQueue();
+    const portfolio = queue.createTask(buildBackgroundMethod(1, 'portfolio-1'));
+
+    await expect(
+      queue.admitTask(buildMethod(2, 'user-action'), {
+        backgroundPreemptTimeoutMs: 1,
+      })
+    ).resolves.toMatchObject({
+      status: 'busy',
+      blockingTask: { id: 1 },
+    });
+    expect(portfolio.abortController?.signal.aborted).toBe(true);
+    expect(queue.getTask(2)).toBeUndefined();
+
+    queue.releaseTask(1);
+    await expect(queue.admitTask(buildMethod(3, 'user-retry'))).resolves.toMatchObject({
+      status: 'reserved',
+      task: { id: 3 },
+    });
+  });
 });

package/__tests__/UploadPortfolio.test.ts

@@ -0,0 +1,46 @@
+import UploadPortfolio from '../src/api/UploadPortfolio';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('UploadPortfolio timeout', () => {
+  test('applies the command timeout to staging and PortfolioUpdate', async () => {
+    const packageBytes = new Uint8Array([1, 2, 3]);
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { processed_byte: 3 } })
+      .mockResolvedValueOnce({ message: {} });
+    const method = new UploadPortfolio({
+      id: 1,
+      payload: {
+        method: 'uploadPortfolio',
+        packageBytes,
+      },
+    });
+    method.device = {
+      commands: { typedCall },
+    } as any;
+    method.postMessage = jest.fn();
+
+    method.init();
+    await method.run();
+
+    expect(method.executionPriority).toBe('background');
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'FilesystemFileWrite',
+      'FilesystemFile',
+      expect.any(Object),
+      { timeoutMs: 5_000 }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'PortfolioUpdate',
+      'Success',
+      {},
+      { timeoutMs: 5_000 }
+    );
+  });
+});

package/__tests__/core-dispose.test.ts

@@ -0,0 +1,34 @@
+import Core, { initConnector } from '../src/core';
+import TransportManager from '../src/data-manager/TransportManager';
+import { DevicePool } from '../src/device/DevicePool';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+describe('Core.dispose', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('幂等停止 Connector 和 Transport，并重置共享设备状态', async () => {
+    const connector = initConnector();
+    const connectorStop = jest.spyOn(connector, 'stop');
+    const transportStop = jest.fn().mockResolvedValue(undefined);
+    jest.spyOn(TransportManager, 'getTransport').mockReturnValue({ stop: transportStop } as never);
+    const resetDevicePool = jest.spyOn(DevicePool, 'resetState');
+    const core = new Core();
+
+    const firstDispose = core.dispose();
+    expect(connectorStop).toHaveBeenCalledTimes(1);
+    expect(transportStop).toHaveBeenCalledTimes(1);
+    expect(resetDevicePool).toHaveBeenCalledTimes(1);
+
+    await firstDispose;
+    await core.dispose();
+    expect(connectorStop).toHaveBeenCalledTimes(1);
+    expect(transportStop).toHaveBeenCalledTimes(1);
+    expect(resetDevicePool).toHaveBeenCalledTimes(1);
+  });
+});

package/__tests__/core-error-output.test.ts

@@ -0,0 +1,39 @@
+import { initCore } from '../src/core';
+import { IFRAME } from '../src/events';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  __esModule: true,
+  default: {
+    configure: jest.fn().mockResolvedValue(undefined),
+    getTransport: jest.fn(() => undefined),
+  },
+}));
+
+describe('Core 错误输出边界', () => {
+  test('连接失败只返回结构化错误，不直接写入 stdout', async () => {
+    const stdout = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    const core = initCore();
+
+    const response = await core.handleMessage({
+      id: 1,
+      event: IFRAME.CALL,
+      type: IFRAME.CALL,
+      payload: {
+        method: 'getDeviceState',
+        connectId: 'missing-device',
+        retryCount: 0,
+        pollIntervalTime: 1,
+        timeout: 10,
+      },
+    } as never);
+
+    expect(response).toMatchObject({ success: false });
+    expect(stdout).not.toHaveBeenCalled();
+    await core.dispose();
+  });
+});

package/__tests__/device-lifecycle-events.test.ts

@@ -0,0 +1,117 @@
+import { initConnector, initCore } from '../src/core';
+import { DataManager } from '../src/data-manager';
+import TransportManager from '../src/data-manager/TransportManager';
+import { Device } from '../src/device/Device';
+import { DevicePool } from '../src/device/DevicePool';
+import { CORE_EVENT, DEVICE, IFRAME } from '../src/events';
+
+import type Core from '../src/core';
+import type { CoreMessage } from '../src/events';
+import type { KnownDevice } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+const createInitializedDevice = (protocol: 'V1' | 'V2') => {
+  const device = Device.fromDescriptor({
+    id: 'ble-discovery-id',
+    path: 'ble-discovery-id',
+    commType: 'ble',
+    protocolType: protocol,
+  } as never);
+  device.mainId = 'ble-connect-id';
+  device.features = {
+    protocol,
+    deviceType: protocol === 'V2' ? 'pro2' : 'classic',
+    firmwareType: 'universal',
+    deviceId: 'wallet-device-id',
+    serialNo: 'SERIAL-001',
+    label: 'OneKey Test',
+    bleName: 'OneKey Test BLE',
+    capabilities: [],
+    mode: 'normal',
+    initialized: true,
+    bootloaderMode: false,
+    firmwareVersion: '1.2.3',
+    bootloaderVersion: '1.0.0',
+    boardVersion: '1.0.0',
+    bleVersion: '2.3.4',
+  } as never;
+  return device;
+};
+
+describe('public device lifecycle events', () => {
+  let core: Core | undefined;
+
+  beforeEach(() => {
+    DevicePool.resetState();
+    jest.spyOn(TransportManager, 'load').mockImplementation();
+    TransportManager.transport = {
+      stop: jest.fn().mockResolvedValue(undefined),
+    } as never;
+  });
+
+  afterEach(async () => {
+    await core?.dispose();
+    core = undefined;
+    jest.restoreAllMocks();
+  });
+
+  test.each([
+    ['react-native', 'V1'],
+    ['react-native', 'V2'],
+    ['lowlevel', 'V1'],
+    ['lowlevel', 'V2'],
+  ] as const)(
+    'emits KnownDevice snapshots for %s Protocol %s connect and disconnect events',
+    async (env, protocol) => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      core = initCore();
+      initConnector();
+
+      await core.handleMessage({
+        id: 'register-device-connect-listener',
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: { method: 'clearSessionCache' },
+      } as CoreMessage);
+
+      const messages: CoreMessage[] = [];
+      core.on(CORE_EVENT, message => messages.push(message));
+      const internalDevice = createInitializedDevice(protocol);
+
+      DevicePool.emitter.emit(DEVICE.CONNECT, internalDevice);
+      internalDevice.updateState({ identity: { label: 'Updated label' } }, 'apply-settings');
+      DevicePool.emitter.emit(DEVICE.DISCONNECT, internalDevice);
+
+      const connectMessage = messages.find(message => message.type === DEVICE.CONNECT);
+      const disconnectMessage = messages.find(message => message.type === DEVICE.DISCONNECT);
+      const connectedDevice = connectMessage?.payload.device as KnownDevice;
+      const disconnectedDevice = disconnectMessage?.payload.device as KnownDevice;
+
+      expect(connectedDevice).toMatchObject({
+        connectId: 'ble-connect-id',
+        serialNo: 'SERIAL-001',
+        uuid: 'SERIAL-001',
+        label: 'OneKey Test',
+        state: { protocol },
+      });
+      expect(disconnectedDevice).toMatchObject({
+        connectId: 'ble-connect-id',
+        serialNo: 'SERIAL-001',
+        uuid: 'SERIAL-001',
+        label: 'Updated label',
+        state: { protocol },
+      });
+      expect(connectedDevice).not.toBe(internalDevice);
+      expect(connectedDevice).not.toBe(disconnectedDevice);
+      expect(connectedDevice).not.toHaveProperty('run');
+      expect(connectedDevice).not.toHaveProperty('acquire');
+      expect(connectedDevice).not.toHaveProperty('commands');
+      expect(() => JSON.stringify(connectedDevice)).not.toThrow();
+      expect(connectedDevice.label).toBe('OneKey Test');
+    }
+  );
+});

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

@@ -34,7 +34,26 @@ describe('DevicePool state lifecycle', () => {
     });
 
     expect(device.run).toHaveBeenCalledTimes(1);
-    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status'] });
+    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', () => {