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

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__/device-lifecycle-events.test.ts

@@ -5,10 +5,11 @@ import {
   cancel,
   initConnector,
   initCore,
+  isDeviceIdentityMismatchError,
   isMissingDetectedProtocolV2Error,
-  isProtocolV2PeerRemovedPairingError,
   isRetryableBleConnectionError,
   isRetryableBleProtocolV2ProbeError,
+  isTerminalBleStaleBondError,
   resolveBleConnectProtocol,
 } from '../src/core';
 import { DataManager } from '../src/data-manager';
@@ -157,6 +158,22 @@ describe('public device lifecycle events', () => {
     expect(deviceB.interruptionFromUser).not.toHaveBeenCalled();
   });
 
+  test('aborts every request before cancel-all rejects WebUSB tasks', () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    core = initCore();
+    const context = (core as any).getCoreContext();
+    const task = context.requestQueue.createTask({
+      responseID: 103,
+      connectId: 'webusb-device',
+    } as never);
+    const signal = task.abortController?.signal;
+
+    cancel(context);
+
+    expect(signal?.aborted).toBe(true);
+    expect(context.requestQueue.getTask(task.id)).toBeUndefined();
+  });
+
   test('keeps shared device lifecycle listeners across a device cache reset', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -351,6 +368,7 @@ describe('public device lifecycle events', () => {
     [HardwareErrorCode.PollingTimeout, false],
     [HardwareErrorCode.BleDeviceBondError, false],
     [HardwareErrorCode.BlePeerRemovedPairingInformation, false],
+    [HardwareErrorCode.BleBondInvalid, false],
   ] as const)('retries a BLE connection error with error code %s: %s', (errorCode, expected) => {
     const method = { payload: { connectProtocol: 'V2' } } as never;
     const error = {
@@ -361,21 +379,35 @@ describe('public device lifecycle events', () => {
     expect(isRetryableBleConnectionError(method, error)).toBe(expected);
   });
 
+  test('does not retry the desktop acquire deadline fallback', () => {
+    const method = { payload: { connectProtocol: 'V2' } } as never;
+    const error = {
+      errorCode: HardwareErrorCode.BleTimeoutError,
+      params: { acquireDeadlineExceeded: true },
+    };
+
+    expect(isRetryableBleConnectionError(method, error)).toBe(false);
+  });
+
   test.each([
-    ['V2', true],
-    ['V1', false],
-    [undefined, false],
-  ] as const)(
-    'treats peer-removed pairing as terminal only for Protocol %s: %s',
-    (connectProtocol, expected) => {
-      const method = { payload: { connectProtocol } } as never;
-      const error = {
-        errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
-      };
+    [HardwareErrorCode.BleDeviceBondError, true],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, true],
+    [HardwareErrorCode.BleBondInvalid, true],
+    [HardwareErrorCode.DeviceNotFound, false],
+  ] as const)('treats BLE stale-bond error code %s as terminal: %s', (errorCode, expected) => {
+    const error = {
+      errorCode,
+    };
 
-      expect(isProtocolV2PeerRemovedPairingError(method, error)).toBe(expected);
-    }
-  );
+    expect(isTerminalBleStaleBondError(error)).toBe(expected);
+  });
+
+  test.each([
+    [HardwareErrorCode.DeviceCheckDeviceIdError, true],
+    [HardwareErrorCode.DeviceNotFound, false],
+  ] as const)('treats device identity error code %s as a mismatch: %s', (errorCode, expected) => {
+    expect(isDeviceIdentityMismatchError({ errorCode })).toBe(expected);
+  });
 
   test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);

package/__tests__/logBlockEvent.test.ts

@@ -7,36 +7,6 @@ import {
 } from '../src/events';
 
 describe('getLogBlockLabel', () => {
-  it('blocks evmSignTypedData params before logging large typed data', () => {
-    expect(
-      getLogBlockLabel({
-        method: 'evmSignTypedData',
-        data: {
-          message: {
-            data: `0x${'ab'.repeat(4096)}`,
-          },
-        },
-      })
-    ).toBe('evmSignTypedData');
-  });
-
-  it('blocks evmSignTypedData iframe call payload before bridge logging', () => {
-    expect(
-      getLogBlockLabel({
-        event: 'iframe-call',
-        type: 'iframe-call',
-        payload: {
-          method: 'evmSignTypedData',
-          data: {
-            message: {
-              data: `0x${'ab'.repeat(4096)}`,
-            },
-          },
-        },
-      })
-    ).toBe('evmSignTypedData');
-  });
-
   it('keeps existing sensitive UI response blocking', () => {
     expect(getLogBlockLabel({ type: UI_RESPONSE.RECEIVE_PIN })).toBe(UI_RESPONSE.RECEIVE_PIN);
   });
@@ -53,119 +23,72 @@ describe('getLogBlockLabel', () => {
           },
         })
       ).toBe(type);
-    }
-  );
-
-  it('blocks openWalletSession wallet identifiers in direct and iframe call logging', () => {
-    const payload = {
-      method: 'openWalletSession',
-      mode: 'resume-hidden',
-      deviceId: 'device-id',
-      passphraseState: 'wallet-identifier',
-    };
-
-    expect(getLogBlockLabel(payload)).toBe('openWalletSession');
-    expect(
-      getLogBlockLabel({
-        event: 'iframe-call',
-        type: 'iframe-call',
-        payload,
-      })
-    ).toBe('openWalletSession');
-  });
-
-  it('keeps openWalletSession metadata while redacting wallet session identifiers', () => {
-    const safeResponse = getSafeLogPayload(
-      {
-        success: true,
-        payload: {
-          protocol: 'V2',
-          walletType: 'hidden',
-          deviceId: 'device-id',
-          passphraseState: 'wallet-identifier',
-          sessionId: 'wallet-session-id',
-          resumed: false,
-        },
-      },
-      'openWalletSession'
-    );
-
-    expect(safeResponse).toEqual({
-      method: 'openWalletSession',
-      success: true,
-      payload: {
-        protocol: 'V2',
-        walletType: 'hidden',
-        deviceId: 'device-id',
-        passphraseState: '[REDACTED]',
-        sessionId: '[REDACTED]',
-        resumed: false,
-      },
-    });
-  });
-
-  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio'])(
-    'skips large Base64 resource payload logging for %s',
-    method => {
-      const request = { method, path: 'resource.bin', data: 'A'.repeat(1024 * 1024) };
-      expect(getLogBlockLabel(request)).toBe(method);
-      expect(getSafeLogPayload(request, method)).toEqual({
-        method,
+      expect(
+        getSafeLogPayload(
+          {
+            type,
+            payload: {
+              passphraseState: 'wallet-identifier',
+            },
+          },
+          type
+        )
+      ).toEqual({
+        method: type,
         payload: '[REDACTED]',
       });
     }
   );
 
-  it.each(['fileWrite', 'fileRead'])(
-    'keeps metadata and replaces binary payloads with their size for %s',
+  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
+    'skips large resource or binary payload logging for %s',
     method => {
-      const request = { method, path: 'resource.bin', data: new Uint8Array(1024) };
+      const request = { method, path: 'resource.bin', data: 'A'.repeat(1024) };
       expect(getLogBlockLabel(request)).toBe(method);
       expect(getSafeLogPayload(request, method)).toEqual({
         method,
-        path: 'resource.bin',
-        data: '[BINARY:1024]',
+        payload: '[REDACTED]',
       });
     }
   );
 
-  it.each(['evmSignMessage', 'btcSignMessage', 'evmSignTransaction'])(
-    'blocks request and response payload logging for signing method %s',
-    method => {
-      expect(getLogBlockLabel({ method, message: 'sensitive signing payload' })).toBe(method);
-      expect(
-        getLogBlockLabel({
-          event: 'iframe-call',
-          payload: { method, message: 'sensitive signing payload' },
-        })
-      ).toBe(method);
-    }
-  );
+  it('logs signing requests and responses as-is', () => {
+    const request = {
+      method: 'btcSignMessage',
+      path: "m/44'/0'/0'/0/0",
+      messageHex: '68656c6c6f',
+      coin: 'Bitcoin',
+    };
+    const iframeRequest = {
+      event: 'iframe-call',
+      payload: request,
+    };
+    const response = {
+      success: true,
+      payload: {
+        signature: 'signature-bytes',
+        address: 'bc1qexample',
+      },
+    };
+
+    expect(getLogBlockLabel(request)).toBeUndefined();
+    expect(getLogBlockLabel(iframeRequest)).toBeUndefined();
+    expect(getSafeLogPayload(request)).toBe(request);
+    expect(getSafeLogPayload(response)).toBe(response);
+  });
 
   it('keeps ordinary API requests and responses visible', () => {
     const request = { method: 'getDeviceState', connectId: 'connect-id', scope: 'runtime' };
     const response = { success: true, payload: { protocol: 'V2', initialized: true } };
 
     expect(getLogBlockLabel(request)).toBeUndefined();
-    expect(getSafeLogPayload(request)).toEqual(request);
-    expect(getSafeLogPayload(response)).toEqual(response);
-  });
-
-  it('redacts sensitive keys even for ordinary API payloads', () => {
-    expect(
-      getSafeLogPayload({
-        method: 'ordinaryMethod',
-        payload: { session_id: 'session-secret', nested: { pin: '1234' } },
-      })
-    ).toEqual({
-      method: 'ordinaryMethod',
-      payload: { session_id: '[REDACTED]', nested: { pin: '[REDACTED]' } },
-    });
+    expect(getSafeLogPayload(request)).toBe(request);
+    expect(getSafeLogPayload(response)).toBe(response);
   });
 
-  it('puts sensitive API method names in the log label', () => {
-    expect(formatLogMethodLabel('response:', 'openWalletSession')).toBe(
-      'response: [openWalletSession]'
+  it('puts blocked method names in the log label', () => {
+    expect(formatLogMethodLabel('response:', 'deviceUploadNft')).toBe(
+      'response: [deviceUploadNft]'
     );
     expect(formatLogMethodLabel('response:')).toBe('response:');
   });

package/__tests__/open-wallet-session.test.ts

@@ -2080,6 +2080,59 @@ describe('openWalletSession', () => {
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
   });
 
+  test('recovers the current Attach PIN wallet when the cached session is invalid', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockRejectedValueOnce(
+        Object.assign(new Error('Invalid session'), {
+          errorCode: HardwareErrorCode.WalletSessionInvalid,
+        })
+      )
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'renewed-session',
+        },
+      });
+    const promptPassphrase = jest.fn();
+    const method = new OpenWalletSession({
+      payload: {
+        method: 'openWalletSession',
+        connectId: 'connect-id',
+        mode: 'resume-hidden',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-state',
+      },
+    });
+    method.init();
+    deviceWalletSessionStore.set('device-1', 'hidden-state', 'expired-session');
+    const device = createDevice({ unlockedAttachPin: true, typedCall, promptPassphrase });
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toEqual({
+      protocol: 'V2',
+      walletType: 'hidden',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-state',
+      resumed: false,
+    });
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toEqual([
+      [
+        'DeviceSessionGet',
+        'DeviceSession',
+        {
+          session_id: 'expired-session',
+          btc_test_address: 'hidden-state',
+        },
+      ],
+      ['DeviceSessionGet', 'DeviceSession', {}],
+    ]);
+    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(device.lockDevice).not.toHaveBeenCalled();
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
+  });
+
   test('selects the expected hidden wallet when Protocol V2 has no cached session', async () => {
     const typedCall = jest
       .fn()