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

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

@@ -1,6 +1,8 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionOpen_FailureSubCodes } from '@onekeyfe/hd-transport';
 
 import { DeviceCommands } from '../src/device/DeviceCommands';
+import { DEVICE } from '../src/events';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -11,11 +13,148 @@ const createCommands = () => {
   const commands = Object.create(DeviceCommands.prototype) as DeviceCommands;
   commands.device = {
     clearCancelableAction: jest.fn(),
+    isProtocolV2: jest.fn(() => true),
   } as any;
   return commands;
 };
 
 describe('DeviceCommands failure mapping', () => {
+  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();
+
+    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('maps DeviceSessionOpen InvalidSession subcode to a structured hardware error', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: DeviceSessionOpen_FailureSubCodes.InvalidSession,
+            message: 'Invalid session',
+          },
+        } as any,
+        'DeviceSessionOpen'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.WalletSessionInvalid,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: DeviceSessionOpen_FailureSubCodes.InvalidSession,
+        firmwareMessage: 'Invalid session',
+      },
+    });
+  });
+
+  it('does not reuse DeviceSessionOpen subcodes for another command', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: DeviceSessionOpen_FailureSubCodes.InvalidSession,
+            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 => {
+      const commands = createCommands();
+
+      await expect(
+        commands._filterCommonTypes(
+          {
+            type: 'Failure',
+            message: {
+              code: 'Failure_ProcessError',
+              message,
+            },
+          } as any,
+          'PortfolioUpdate'
+        )
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.DeviceLocked,
+        params: {
+          failureCode: 'Failure_ProcessError',
+          firmwareMessage: message,
+        },
+      });
+    }
+  );
+
+  it('does not use the legacy locked-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: 'Device is locked',
+          },
+        } as any,
+        'ApplySettings'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+    });
+  });
+
   it.each([
     ['ButtonAck', 'Not in Ethereum signing mode'],
     ['PinMatrixAck', 'Not in Conflux signing mode'],
@@ -97,3 +236,81 @@ 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,
+      listenerCount: jest.fn(() => 0),
+    } as any;
+    commands._commonCall = commonCall as any;
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'ButtonRequest',
+          message: { code: 'ButtonRequest_PinEntry' },
+        } as any,
+        'GetAddress'
+      )
+    ).resolves.toMatchObject({ type: 'Success' });
+
+    expect(emit).toHaveBeenCalledWith(
+      DEVICE.BUTTON,
+      commands.device,
+      expect.objectContaining({ code: 'ButtonRequest_PinEntry' })
+    );
+    expect(commonCall).toHaveBeenCalledWith('ButtonAck', {}, undefined);
+  });
+
+  it('rejects PassphraseRequest when the Pro2 UI listener is not registered', async () => {
+    const commands = createCommands();
+    commands.device = {
+      ...commands.device,
+      listenerCount: jest.fn(() => 0),
+    } as any;
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'PassphraseRequest',
+          message: { exists_attach_pin_user: true },
+        } as any,
+        'GetAddress'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: '_promptPassphrase: Passphrase callback not configured',
+    });
+  });
+
+  it('rejects PinMatrixRequest when the Pro2 UI listener is not registered', async () => {
+    const commands = createCommands();
+    commands.device = {
+      ...commands.device,
+      instanceId: 'pro2-test-device',
+      listenerCount: jest.fn(() => 0),
+    } as any;
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'PinMatrixRequest',
+          message: { type: 'PinMatrixRequestType_Current' },
+        } as any,
+        'GetAddress'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+    });
+  });
+});

package/__tests__/RequestQueue.test.ts

@@ -0,0 +1,140 @@
+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 {
+    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();
+    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);
+  });
+
+  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__/connectSettings.test.ts

@@ -0,0 +1,61 @@
+import DataManager from '../src/data-manager/DataManager';
+import { parseConnectSettings } from '../src/data-manager/connectSettings';
+
+import type { RemoteConfigResponse } from '../src/types';
+
+jest.mock('axios', () => ({
+  get: jest.fn(),
+}));
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+const mockAxiosGet: jest.Mock = jest.requireMock('axios').get;
+
+describe('parseConnectSettings', () => {
+  const preloadedConfig = {
+    bridge: {},
+    classic: { firmware: [], ble: [] },
+    classic1s: { firmware: [], ble: [] },
+    classicpure: { firmware: [], ble: [] },
+    mini: { firmware: [], ble: [] },
+    touch: { firmware: [], ble: [] },
+    pro: { firmware: [], ble: [] },
+    pro2: { firmware: [], ble: [] },
+  } as unknown as RemoteConfigResponse;
+
+  it('keeps a serializable preloaded config in parsed settings', () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    expect(settings.firmwareManifestMode).toBe('sdk-managed');
+    expect(settings.preloadedConfig).toBe(preloadedConfig);
+  });
+
+  it('uses the preloaded config before the SDK network client', async () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    await DataManager.load(settings);
+
+    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(DataManager.deviceMap.classic).toEqual({ firmware: [], ble: [] });
+  });
+
+  it('fails closed without a preloaded config in external-only mode', async () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'external-only',
+    });
+
+    await expect(DataManager.load(settings)).rejects.toThrow(
+      'External firmware config snapshot is required'
+    );
+    expect(mockAxiosGet).not.toHaveBeenCalled();
+  });
+});

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');
+    }
+  );
+});