@onekeyfe/hd-core 1.2.0-alpha.2 → 1.2.0-alpha.21

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

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

@@ -0,0 +1,39 @@
+import { initCore } from '../src/core';
+import { IFRAME } from '../src/events';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  __esModule: true,
+  default: {
+    configure: jest.fn().mockResolvedValue(undefined),
+    getTransport: jest.fn(() => undefined),
+  },
+}));
+
+describe('Core 错误输出边界', () => {
+  test('连接失败只返回结构化错误，不直接写入 stdout', async () => {
+    const stdout = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    const core = initCore();
+
+    const response = await core.handleMessage({
+      id: 1,
+      event: IFRAME.CALL,
+      type: IFRAME.CALL,
+      payload: {
+        method: 'getDeviceState',
+        connectId: 'missing-device',
+        retryCount: 0,
+        pollIntervalTime: 1,
+        timeout: 10,
+      },
+    } as never);
+
+    expect(response).toMatchObject({ success: false });
+    expect(stdout).not.toHaveBeenCalled();
+    await core.dispose();
+  });
+});

package/__tests__/device-features-state.test.ts

@@ -0,0 +1,78 @@
+import { mergeDeviceFeaturesPatch } from '../src/device/DeviceFeaturesState';
+
+import type { Features } from '../src/types';
+
+const baseFeatures = {
+  protocol: 'V2',
+  deviceType: 'pro2',
+  firmwareType: 'universal',
+  model: 'pro2',
+  vendor: 'onekey.so',
+  deviceId: null,
+  serialNo: 'P20001',
+  label: 'Old Label',
+  bleName: 'Pro2 0001',
+  capabilities: [],
+  mode: 'normal',
+  initialized: true,
+  bootloaderMode: false,
+  unlocked: true,
+  firmwarePresent: true,
+  passphraseProtection: false,
+  pinProtection: true,
+  backupRequired: false,
+  noBackup: false,
+  unfinishedBackup: false,
+  recoveryMode: false,
+  language: 'en-US',
+  bleEnabled: true,
+  sdCardPresent: null,
+  sdProtection: null,
+  wipeCodeProtection: null,
+  passphraseAlwaysOnDevice: null,
+  safetyChecks: null,
+  autoLockDelayMs: 60_000,
+  displayRotation: null,
+  experimentalFeatures: false,
+  firmwareVersion: '1.0.0',
+  bootloaderVersion: '1.0.0',
+  boardVersion: '1.0.0',
+  bleVersion: '1.0.0',
+  sessionId: null,
+} as Features;
+
+describe('mergeDeviceFeaturesPatch', () => {
+  it('ignores undefined fields instead of clearing cached values', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, {
+      label: undefined,
+      language: 'ja-JP',
+    });
+
+    expect(next).toMatchObject({
+      label: 'Old Label',
+      language: 'ja-JP',
+    });
+  });
+
+  it('allows null to explicitly clear a cached value', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, { label: null });
+
+    expect(next.label).toBeNull();
+  });
+
+  it('returns the same object when no value changes', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, {
+      label: 'Old Label',
+      language: undefined,
+    });
+
+    expect(next).toBe(baseFeatures);
+  });
+
+  it('returns a new object when a defined value changes', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, { label: 'New Label' });
+
+    expect(next).not.toBe(baseFeatures);
+    expect(next.label).toBe('New Label');
+  });
+});

package/__tests__/device-identity.test.ts

@@ -0,0 +1,30 @@
+import { checkLiveDeviceId } from '../src/device/deviceIdentity';
+
+describe('live device identity', () => {
+  test('refreshes Protocol V2 status before comparing the expected device id', async () => {
+    let currentDeviceId = 'OLD_DEVICE_ID';
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState: jest.fn().mockImplementation(async () => {
+        currentDeviceId = 'NEW_DEVICE_ID';
+        return { identity: { deviceId: currentDeviceId } };
+      }),
+      checkDeviceId: jest.fn((expected: string) => currentDeviceId === expected),
+    };
+
+    await expect(checkLiveDeviceId(device as never, 'OLD_DEVICE_ID')).resolves.toBe(false);
+    expect(device.getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status'] });
+    expect(device.checkDeviceId).toHaveBeenCalledWith('OLD_DEVICE_ID');
+  });
+
+  test('keeps Protocol V1 identity checks on the Initialize/GetFeatures state', async () => {
+    const device = {
+      isProtocolV2: () => false,
+      getDeviceState: jest.fn(),
+      checkDeviceId: jest.fn(() => true),
+    };
+
+    await expect(checkLiveDeviceId(device as never, 'V1_DEVICE_ID')).resolves.toBe(true);
+    expect(device.getDeviceState).not.toHaveBeenCalled();
+  });
+});