@onekeyfe/hd-core 1.2.0-alpha.2 → 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

@@ -1,6 +1,8 @@
 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'),
@@ -11,11 +13,216 @@ 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('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();
+
+    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 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 => {
+      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 +304,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__/DeviceEventRegistration.test.ts

@@ -0,0 +1,43 @@
+import { DEVICE } from '../src/events';
+import { registerHardwareUiEventListeners } from '../src/core/deviceEventRegistration';
+
+const handlers = {
+  pin: jest.fn(),
+  button: jest.fn(),
+  passphrase: jest.fn(),
+  passphraseOnDevice: jest.fn(),
+  attachPinOnDevice: jest.fn(),
+};
+
+const createDevice = (protocolV2: boolean) => ({
+  isProtocolV2: jest.fn(() => protocolV2),
+  on: jest.fn(),
+});
+
+describe('hardware UI event registration', () => {
+  test('keeps all interactive UI events for Protocol V2 devices during compatibility mode', () => {
+    const device = createDevice(true);
+
+    expect(registerHardwareUiEventListeners(device as any, handlers)).toBe(true);
+    expect(device.on.mock.calls.map(([type]) => type)).toEqual([
+      DEVICE.PIN,
+      DEVICE.BUTTON,
+      DEVICE.PASSPHRASE,
+      DEVICE.PASSPHRASE_ON_DEVICE,
+      DEVICE.ATTACH_PIN_ON_DEVICE,
+    ]);
+  });
+
+  test('keeps the existing interactive event listeners for Protocol V1 devices', () => {
+    const device = createDevice(false);
+
+    expect(registerHardwareUiEventListeners(device as any, handlers)).toBe(true);
+    expect(device.on.mock.calls.map(([type]) => type)).toEqual([
+      DEVICE.PIN,
+      DEVICE.BUTTON,
+      DEVICE.PASSPHRASE,
+      DEVICE.PASSPHRASE_ON_DEVICE,
+      DEVICE.ATTACH_PIN_ON_DEVICE,
+    ]);
+  });
+});

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