@onekeyfe/hd-core 1.2.0-alpha.3 → 1.2.0-alpha.30

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -0,0 +1,77 @@
+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({}),
+      assertProtocolSupported: jest.fn(),
+      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(),
+      getProtocol: jest.fn().mockReturnValue('V1'),
+      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,341 @@ 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('maps an invalid DeviceSessionGet resume to WalletSessionInvalid', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 2,
+            message: 'Invalid session',
+          },
+        } as any,
+        'DeviceSessionGet'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.WalletSessionInvalid,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: 2,
+        firmwareMessage: 'Invalid session',
+      },
+    });
+  });
+
+  it('maps wallet-session user cancellation to ActionCancelled', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 1,
+            message: 'Cancelled on device',
+          },
+        } as any,
+        'DeviceSessionAskPassphrase'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.ActionCancelled,
+    });
+  });
+
+  it.each([
+    [3, HardwareErrorCode.DeviceCheckUnlockTypeError],
+    [4, HardwareErrorCode.DeviceNotOpenedPassphrase],
+  ])('maps wallet-session subcode %s to its canonical wallet error', async (subcode, code) => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: { code: 'Failure_ProcessError', subcode, message: 'Session selection failed' },
+        } as any,
+        'DeviceSessionAskPin'
+      )
+    ).rejects.toMatchObject({ errorCode: code });
+  });
+
+  it.each([
+    ['DeviceSessionGet', 5, 'Another flow in progress'],
+    ['DeviceSessionAskPin', 0, 'Busy'],
+  ])('maps %s firmware busy failures to DeviceBusy', async (callType, subcode, message) => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: { code: 'Failure_ProcessError', subcode, message },
+        } as any,
+        callType
+      )
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceBusy });
+  });
+
+  it('maps the current AskPin passphrase-disabled response without relying on a subcode', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 0,
+            message: 'Passphrase disabled',
+          },
+        } as any,
+        'DeviceSessionAskPin'
+      )
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceNotOpenedPassphrase });
+  });
+
+  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.each(['Cancelled', 'User cancelled typed data signing'])(
+    'maps the Protocol V2 MP engine cancellation response "%s" to ActionCancelled',
+    async message => {
+      const commands = createCommands();
+
+      await expect(
+        commands._filterCommonTypes(
+          {
+            type: 'Failure',
+            message: {
+              code: 'Failure_ProcessError',
+              subcode: 1,
+              message,
+            },
+          } as any,
+          'SignTx'
+        )
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.ActionCancelled,
+        params: {
+          failureCode: 'Failure_ProcessError',
+          subcode: 1,
+          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 +429,104 @@ 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,
+    });
+  });
+});
+
+describe('DeviceCommands cancellation', () => {
+  it('stops waiting after the bounded cancellation timeout', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    try {
+      const commands = createCommands();
+      commands.disposed = false;
+      commands.callPromise = new Promise(() => {});
+      const dispose = jest.fn().mockResolvedValue(undefined);
+      commands.dispose = dispose;
+
+      const cancellation = commands.cancel();
+      jest.advanceTimersByTime(10_000);
+      await Promise.resolve();
+
+      await expect(cancellation).resolves.toBeUndefined();
+      expect(dispose).toHaveBeenCalledWith(true);
+      expect(commands.callPromise).toBeUndefined();
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+});

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