@onekeyfe/hd-core 1.2.2-alpha.9 → 1.2.2

package/__tests__/DeviceCommands.test.ts

@@ -1,5 +1,9 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionErrorCode } from '@onekeyfe/hd-transport';
 
+import { DataManager } from '../src/data-manager';
+import TransportManager from '../src/data-manager/TransportManager';
+import { Device } from '../src/device/Device';
 import { DeviceCommands } from '../src/device/DeviceCommands';
 import { DEVICE } from '../src/events';
 import { LoggerNames, getLogger } from '../src/utils';
@@ -807,6 +811,255 @@ describe('DeviceCommands Protocol V2 interactive response compatibility', () =>
   });
 });
 
+describe('DeviceCommands Protocol V2 session busy retry', () => {
+  const busy = {
+    type: 'Failure',
+    message: {
+      code: 'Failure_ProcessError',
+      subcode: DeviceSessionErrorCode.DeviceSessionError_Busy,
+      message: 'Another flow in progress',
+    },
+  } as const;
+  const success = { type: 'Success', message: {} } as const;
+  const flushCalls = () =>
+    new Promise<void>(resolve => {
+      setImmediate(resolve);
+    });
+
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['performance', 'setImmediate'] });
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  const setup = () => {
+    const commands = createCommands();
+    commands.device.wasInterruptedByUser = jest.fn(() => false);
+    commands.mainId = 'main-id';
+    const call = jest.fn();
+    commands.transport = { call } as DeviceCommands['transport'];
+    return { commands, call };
+  };
+
+  it.each(['DeviceSessionGet', 'DeviceSessionAskPin', 'DeviceSessionAskPassphrase'] as const)(
+    'retries %s busy responses at 100 ms intervals without matching their message',
+    async request => {
+      const { commands, call } = setup();
+      const response =
+        request === 'DeviceSessionGet' ? { type: 'DeviceSession' as const, message: {} } : success;
+      call
+        .mockResolvedValueOnce(busy)
+        .mockResolvedValueOnce({
+          type: 'Failure',
+          message: { ...busy.message, message: 'Passphrase entry busy' },
+        })
+        .mockResolvedValueOnce({
+          type: 'Failure',
+          message: { ...busy.message, message: 'Passphrase confirm busy' },
+        })
+        .mockResolvedValue(response);
+      const payload = request === 'DeviceSessionAskPassphrase' ? { on_device: true } : {};
+      const result = commands.typedCall(request, response.type, payload).catch(error => error);
+      await flushCalls();
+
+      for (let attempt = 1; attempt <= 3; attempt += 1) {
+        jest.advanceTimersByTime(99);
+        await flushCalls();
+        expect(call).toHaveBeenCalledTimes(attempt);
+        jest.advanceTimersByTime(1);
+        await flushCalls();
+        expect(call).toHaveBeenCalledTimes(attempt + 1);
+      }
+
+      await expect(result).resolves.toEqual(response);
+      expect(call.mock.calls).toEqual(
+        Array.from({ length: 4 }, () => [
+          commands.mainId,
+          request,
+          payload,
+          { expectedTypes: [response.type] },
+        ])
+      );
+      expect(jest.getTimerCount()).toBe(0);
+    }
+  );
+
+  it('preserves the final busy error after three retries', async () => {
+    const { commands, call } = setup();
+    call.mockResolvedValue(busy);
+    const result = commands.typedCall('DeviceSessionGet', 'DeviceSession').catch(error => error);
+    await flushCalls();
+    for (let retry = 0; retry < 3; retry += 1) {
+      jest.advanceTimersByTime(100);
+      await flushCalls();
+    }
+
+    expect(call).toHaveBeenCalledTimes(4);
+    await expect(result).resolves.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceBusy,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: DeviceSessionErrorCode.DeviceSessionError_Busy,
+        firmwareMessage: 'Another flow in progress',
+      },
+    });
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('does not delay a successful session request', async () => {
+    const { commands, call } = setup();
+    call.mockResolvedValue(success);
+    await expect(commands.typedCall('DeviceSessionAskPin', 'Success')).resolves.toEqual(success);
+    expect(call).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it.each([
+    ['DeviceSessionAskPin', 'Failure_ProcessError', 0],
+    [
+      'DeviceSessionGet',
+      'Failure_ProcessError',
+      DeviceSessionErrorCode.DeviceSessionError_InvalidSession,
+    ],
+    [
+      'DeviceSessionAskPassphrase',
+      'Failure_ProcessError',
+      DeviceSessionErrorCode.DeviceSessionError_UserCancelled,
+    ],
+    ['DeviceSessionGet', 'Failure_DataError', DeviceSessionErrorCode.DeviceSessionError_Busy],
+    ['DeviceSettingsSet', 'Failure_ProcessError', 5],
+    ['EthereumSignTx', 'Failure_ProcessError', 5],
+  ] as const)('does not retry %s with %s subcode %s', async (request, code, subcode) => {
+    const { commands, call } = setup();
+    call.mockResolvedValue({ type: 'Failure', message: { code, subcode, message: 'Busy' } });
+    await expect(commands.typedCall(request, 'Success')).rejects.toBeInstanceOf(Error);
+    expect(call).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('does not retry Protocol V1 busy responses', async () => {
+    const { commands, call } = setup();
+    commands.device.isProtocolV2 = () => false;
+    call.mockResolvedValue(busy);
+    await expect(commands.typedCall('DeviceSessionGet', 'DeviceSession')).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceBusy,
+    });
+    expect(call).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('stops retrying when the next attempt fails at the transport layer', async () => {
+    const { commands, call } = setup();
+    const error = ERRORS.TypedError(HardwareErrorCode.BridgeDeviceDisconnected);
+    call.mockResolvedValueOnce(busy).mockRejectedValue(error);
+    const result = commands.typedCall('DeviceSessionGet', 'DeviceSession').catch(err => err);
+    await flushCalls();
+    jest.advanceTimersByTime(100);
+    await flushCalls();
+    await expect(result).resolves.toBe(error);
+    expect(call).toHaveBeenCalledTimes(2);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it('stops a superseded retry when a React Native run reuses the commands', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const call = jest.fn().mockResolvedValueOnce(busy).mockResolvedValueOnce(busy);
+    call.mockResolvedValue(success);
+    const cancel = jest.fn();
+    jest.spyOn(TransportManager, 'getTransport').mockReturnValue({
+      call,
+      cancel,
+    } as DeviceCommands['transport']);
+    const device = Device.fromDescriptor({
+      id: 'ble-device',
+      path: 'ble-device',
+      name: 'OneKey Test',
+      debug: false,
+      commType: 'ble',
+      protocolType: 'V2',
+    });
+    const commands = new DeviceCommands(device, 'ble-device');
+    device.commands = commands;
+    const release = jest.spyOn(device, 'release');
+    const continued = jest.fn();
+    let staleCallResult: Promise<unknown> | undefined;
+    const staleRun = device
+      .run(
+        async () => {
+          const operation = commands.typedCall('DeviceSessionAskPassphrase', 'Success', {
+            on_device: true,
+          });
+          staleCallResult = operation.catch(error => error);
+          await operation;
+          continued();
+        },
+        { keepSession: true }
+      )
+      .catch(error => error);
+    await flushCalls();
+
+    const nextRun = device.run(
+      async () => {
+        await commands.typedCall('DeviceSessionAskPin', 'Success');
+      },
+      { keepSession: true }
+    );
+    await flushCalls();
+    expect(device.commands).toBe(commands);
+    expect(commands.disposed).toBe(false);
+    expect(cancel).toHaveBeenCalledTimes(1);
+    expect(call).toHaveBeenCalledTimes(2);
+
+    jest.advanceTimersByTime(100);
+    await flushCalls();
+
+    await expect(staleRun).resolves.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInterruptedFromOutside,
+    });
+    await expect(staleCallResult).resolves.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+    });
+    await expect(nextRun).resolves.toBeUndefined();
+    expect(call.mock.calls.map(([, request]) => request)).toEqual([
+      'DeviceSessionAskPassphrase',
+      'DeviceSessionAskPin',
+      'DeviceSessionAskPin',
+    ]);
+    expect(continued).not.toHaveBeenCalled();
+    expect(release).not.toHaveBeenCalled();
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  it.each(['cancelled', 'disposed'] as const)(
+    'does not resend when %s during backoff',
+    async state => {
+      const { commands, call } = setup();
+      call.mockResolvedValueOnce(busy).mockResolvedValue(success);
+      const result = commands.typedCall('DeviceSessionAskPin', 'Success').catch(error => error);
+      await flushCalls();
+      if (state === 'cancelled') {
+        commands.device.wasInterruptedByUser = () => true;
+      } else {
+        commands.disposed = true;
+      }
+      jest.advanceTimersByTime(100);
+      await flushCalls();
+
+      await expect(result).resolves.toMatchObject({
+        errorCode:
+          state === 'cancelled'
+            ? HardwareErrorCode.DeviceInterruptedFromUser
+            : HardwareErrorCode.RuntimeError,
+      });
+      expect(call).toHaveBeenCalledTimes(1);
+      expect(jest.getTimerCount()).toBe(0);
+    }
+  );
+});
+
 describe('DeviceCommands cancellation', () => {
   it('stops waiting after the bounded cancellation timeout', async () => {
     jest.useFakeTimers({ doNotFake: ['performance'] });

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

@@ -1,5 +1,11 @@
-import { initCore } from '../src/core';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { initConnector, initCore } from '../src/core';
+import { DataManager } from '../src/data-manager';
+import TransportManager from '../src/data-manager/TransportManager';
 import { IFRAME } from '../src/events';
+import SearchDevices from '../src/api/SearchDevices';
+import { DeviceList } from '../src/device/DeviceList';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0-test'),
@@ -9,12 +15,174 @@ jest.mock('../src/data/config', () => ({
 jest.mock('../src/data-manager/TransportManager', () => ({
   __esModule: true,
   default: {
+    load: jest.fn(),
     configure: jest.fn().mockResolvedValue(undefined),
     getTransport: jest.fn(() => undefined),
   },
 }));
 
 describe('Core 错误输出边界', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test.each([
+    ['webusb', false],
+    ['desktop-webusb', false],
+    ['desktop-webusb', true],
+  ] as const)(
+    '%s waits for discovery without masking initialization or cancellation (cancel=%s)',
+    async (env, shouldCancel) => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      const error = ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed, 'probe failed');
+      let finishSearch!: () => void;
+      let searchStarted!: () => void;
+      const started = new Promise<void>(resolve => {
+        searchStarted = resolve;
+      });
+      const search = jest.spyOn(SearchDevices.prototype, 'run').mockImplementation(async () => {
+        searchStarted();
+        await new Promise<void>(resolve => {
+          finishSearch = resolve;
+        });
+        return [];
+      });
+      const initialize = jest
+        .spyOn(DeviceList.prototype, 'getDeviceLists')
+        .mockRejectedValue(error);
+      const core = initCore();
+      initConnector();
+      try {
+        const discovery = core.handleMessage({
+          id: 10,
+          type: IFRAME.CALL,
+          payload: { method: 'searchDevices' },
+        } as never);
+        await started;
+        const request = core.handleMessage({
+          id: 11,
+          type: IFRAME.CALL,
+          payload: {
+            method: 'getDeviceState',
+            connectId: 'serial-V2',
+            retryCount: 1,
+            pollIntervalTime: 1,
+            timeout: 1000,
+          },
+        } as never);
+        await new Promise(resolve => {
+          setTimeout(resolve, 0);
+        });
+        expect(initialize).not.toHaveBeenCalled();
+        if (shouldCancel) {
+          await core.handleMessage({
+            type: IFRAME.CANCEL,
+            payload: { connectId: 'serial-V2' },
+          } as never);
+        }
+        finishSearch();
+        await expect(discovery).resolves.toMatchObject({ success: true });
+        const expectedError = shouldCancel
+          ? ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)
+          : error;
+        await expect(request).resolves.toMatchObject({
+          success: false,
+          payload: { code: expectedError.errorCode, error: expectedError.message },
+        });
+        await new Promise(resolve => {
+          setTimeout(resolve, 0);
+        });
+        expect(search).toHaveBeenCalledTimes(1);
+        expect(initialize).toHaveBeenCalledTimes(shouldCancel ? 0 : 2);
+      } finally {
+        finishSearch?.();
+        await core.dispose();
+      }
+    }
+  );
+
+  test.each([
+    HardwareErrorCode.BleDeviceNotBonded,
+    HardwareErrorCode.BleDeviceBondedCanceled,
+    HardwareErrorCode.BleDeviceDisconnected,
+    HardwareErrorCode.PollingTimeout,
+  ])(
+    'preserves terminal BLE error %s in the public response without polling again',
+    async errorCode => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+      const error = ERRORS.TypedError(errorCode);
+      const acquire = jest.fn().mockRejectedValue(error);
+      jest.spyOn(TransportManager, 'getTransport').mockReturnValue({
+        acquire,
+        release: jest.fn().mockResolvedValue(true),
+        stop: jest.fn().mockResolvedValue(undefined),
+      } as never);
+      const core = initCore();
+      initConnector();
+
+      try {
+        const response = await core.handleMessage({
+          id: 1,
+          event: IFRAME.CALL,
+          type: IFRAME.CALL,
+          payload: {
+            method: 'getDeviceState',
+            connectId: 'ble-pairing-test',
+            forceProtocolDetection: true,
+            retryCount: 1,
+            pollIntervalTime: 1,
+            timeout: 1000,
+          },
+        } as never);
+
+        expect(response).toMatchObject({
+          success: false,
+          payload: { code: errorCode, error: error.message },
+        });
+        expect(acquire).toHaveBeenCalledTimes(1);
+      } finally {
+        await core.dispose();
+      }
+    }
+  );
+
+  test('desktop BLE still polls after a transient disconnect instead of failing immediately', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('desktop-web-ble' as never);
+    const error = ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
+    const acquire = jest.fn().mockRejectedValue(error);
+    jest.spyOn(TransportManager, 'getTransport').mockReturnValue({
+      acquire,
+      release: jest.fn().mockResolvedValue(true),
+      stop: jest.fn().mockResolvedValue(undefined),
+    } as never);
+    const core = initCore();
+    initConnector();
+
+    try {
+      const response = await core.handleMessage({
+        id: 1,
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: {
+          method: 'getDeviceState',
+          connectId: 'desktop-ble-disconnect-test',
+          forceProtocolDetection: true,
+          retryCount: 1,
+          pollIntervalTime: 1,
+          timeout: 1000,
+        },
+      } as never);
+
+      expect(response).toMatchObject({
+        success: false,
+        payload: { code: HardwareErrorCode.DeviceNotFound },
+      });
+      expect(acquire.mock.calls.length).toBeGreaterThan(1);
+    } finally {
+      await core.dispose();
+    }
+  });
+
   test('连接失败只返回结构化错误，不直接写入 stdout', async () => {
     const stdout = jest.spyOn(console, 'log').mockImplementation(() => undefined);
     const core = initCore();