@onekeyfe/hd-core 1.2.0-alpha.20 → 1.2.0-alpha.22

package/__tests__/DeviceCommands.test.ts

@@ -19,7 +19,7 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
-  it('does not log DeviceSessionGet response secrets', async () => {
+  it('does not log DeviceSessionOpen response secrets', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);
     log.messages.length = 0;
@@ -33,7 +33,7 @@ describe('DeviceCommands failure mapping', () => {
             btc_test_address: 'secret-wallet-address',
           },
         } as any,
-        'DeviceSessionGet'
+        'DeviceSessionOpen'
       )
     ).resolves.toMatchObject({ type: 'DeviceSession' });
 
@@ -41,6 +41,68 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
+  it('maps an invalid DeviceSessionOpen resume to WalletSessionInvalid', async () => {
+    const commands = createCommands();
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'Failure',
+          message: {
+            code: 'Failure_ProcessError',
+            subcode: 2,
+            message: 'Invalid session',
+          },
+        } as any,
+        'DeviceSessionOpen'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.WalletSessionInvalid,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: 2,
+        firmwareMessage: 'Invalid session',
+      },
+    });
+  });
+
+  it('maps DeviceSessionOpen 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,
+        'DeviceSessionOpen'
+      )
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.ActionCancelled,
+    });
+  });
+
+  it.each([
+    [3, HardwareErrorCode.DeviceCheckUnlockTypeError],
+    [4, HardwareErrorCode.DeviceNotOpenedPassphrase],
+  ])('maps DeviceSessionOpen 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,
+        'DeviceSessionOpen'
+      )
+    ).rejects.toMatchObject({ errorCode: code });
+  });
+
   it('rejects the Pro2 bootloader DeviceStatusGet unsupported response', async () => {
     const commands = createCommands();
 
@@ -382,3 +444,26 @@ describe('DeviceCommands Protocol V2 interactive response compatibility', () =>
     });
   });
 });
+
+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__/connectSettings.test.ts

@@ -1,19 +1,61 @@
+import DataManager from '../src/data-manager/DataManager';
 import { parseConnectSettings } from '../src/data-manager/connectSettings';
 
+import type { RemoteConfigResponse } from '../src/types';
+
+jest.mock('axios', () => ({
+  get: jest.fn(),
+}));
+
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
+const mockAxiosGet: jest.Mock = jest.requireMock('axios').get;
+
 describe('parseConnectSettings', () => {
-  it('keeps custom configFetcher in parsed settings', () => {
-    const configFetcher = jest.fn();
+  const preloadedConfig = {
+    bridge: {},
+    classic: { firmware: [], ble: [] },
+    classic1s: { firmware: [], ble: [] },
+    classicpure: { firmware: [], ble: [] },
+    mini: { firmware: [], ble: [] },
+    touch: { firmware: [], ble: [] },
+    pro: { firmware: [], ble: [] },
+    pro2: { firmware: [], ble: [] },
+  } as unknown as RemoteConfigResponse;
+
+  it('keeps a serializable preloaded config in parsed settings', () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    expect(settings.firmwareManifestMode).toBe('sdk-managed');
+    expect(settings.preloadedConfig).toBe(preloadedConfig);
+  });
+
+  it('uses the preloaded config before the SDK network client', async () => {
+    const settings = parseConnectSettings({
+      firmwareManifestMode: 'sdk-managed',
+      preloadedConfig,
+    });
+
+    await DataManager.load(settings);
+
+    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(DataManager.deviceMap.classic).toEqual({ firmware: [], ble: [] });
+  });
 
+  it('fails closed without a preloaded config in external-only mode', async () => {
     const settings = parseConnectSettings({
-      fetchConfig: true,
-      configFetcher,
+      firmwareManifestMode: 'external-only',
     });
 
-    expect(settings.configFetcher).toBe(configFetcher);
+    await expect(DataManager.load(settings)).rejects.toThrow(
+      'External firmware config snapshot is required'
+    );
+    expect(mockAxiosGet).not.toHaveBeenCalled();
   });
 });

package/__tests__/device-identity.test.ts

@@ -1,13 +1,35 @@
 import { checkLiveDeviceId } from '../src/device/deviceIdentity';
+import ConfluxGetAddress from '../src/api/conflux/ConfluxGetAddress';
+import ConfluxSignMessage from '../src/api/conflux/ConfluxSignMessage';
+import ConfluxSignMessageCIP23 from '../src/api/conflux/ConfluxSignMessageCIP23';
+import ConfluxSignTransaction from '../src/api/conflux/ConfluxSignTransaction';
+import NexaSignTransaction from '../src/api/nexa/NexaSignTransaction';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
 
 describe('live device identity', () => {
+  test.each([
+    ['confluxGetAddress', ConfluxGetAddress],
+    ['confluxSignMessage', ConfluxSignMessage],
+    ['confluxSignMessageCIP23', ConfluxSignMessageCIP23],
+    ['confluxSignTransaction', ConfluxSignTransaction],
+    ['nexaSignTransaction', NexaSignTransaction],
+  ])('%s requires a live device id check', (methodName, Method) => {
+    const method = new Method({ payload: { method: methodName } });
+
+    expect(method.checkDeviceId).toBe(true);
+  });
+
   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 () => {
+      getDeviceState: jest.fn().mockImplementation(() => {
         currentDeviceId = 'NEW_DEVICE_ID';
-        return { identity: { deviceId: currentDeviceId } };
+        return Promise.resolve({ identity: { deviceId: currentDeviceId } });
       }),
       checkDeviceId: jest.fn((expected: string) => currentDeviceId === expected),
     };

package/__tests__/device-lifecycle-events.test.ts

@@ -83,7 +83,7 @@ describe('public device lifecycle events', () => {
       const internalDevice = createInitializedDevice(protocol);
 
       DevicePool.emitter.emit(DEVICE.CONNECT, internalDevice);
-      internalDevice.updateState({ identity: { label: 'Updated label' } }, 'apply-settings');
+      internalDevice.updateState({ identity: { label: 'Updated label' } }, 'settings-write');
       DevicePool.emitter.emit(DEVICE.DISCONNECT, internalDevice);
 
       const connectMessage = messages.find(message => message.type === DEVICE.CONNECT);

package/__tests__/device-settings.test.ts

@@ -1,4 +1,4 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import DeviceSettings from '../src/api/device/DeviceSettings';
@@ -24,6 +24,7 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
     device: {
       features,
       isProtocolV2: () => protocol === 'V2',
+      getCurrentDeviceType: () => (protocol === 'V2' ? EDeviceType.Pro2 : EDeviceType.Pro),
       commands: { typedCall },
       updateState,
       getDeviceState,
@@ -69,7 +70,7 @@ describe('DeviceSettings protocol routing', () => {
 
     method.init();
 
-    expect(method.unlockPolicy).toBe('retry-on-locked');
+    expect(method.unlockPolicy).toBe('unlock-before-run');
   });
 
   it('uses ApplySettings and commits the confirmed patch for Protocol V1', async () => {
@@ -80,6 +81,7 @@ describe('DeviceSettings protocol routing', () => {
         method: 'deviceSettings',
         label: 'Shared Label',
         language: 'ja',
+        bluetoothEnabled: true,
       },
     });
     method.init();
@@ -98,14 +100,15 @@ describe('DeviceSettings protocol routing', () => {
       safety_checks: undefined,
       experimental_features: undefined,
       auto_shutdown_delay_ms: undefined,
+      use_ble: true,
       haptic_feedback: undefined,
     });
     expect(updateState).toHaveBeenCalledWith(
       {
         identity: { label: 'Shared Label' },
-        settings: { language: 'ja' },
+        settings: { language: 'ja', bleEnabled: true },
       },
-      'apply-settings'
+      'settings-write'
     );
   });
 
@@ -119,6 +122,7 @@ describe('DeviceSettings protocol routing', () => {
         language: 'ja',
         autoLockDelayMs: 60_000,
         hapticFeedback: true,
+        bluetoothEnabled: true,
       },
     });
     method.init();
@@ -129,6 +133,7 @@ describe('DeviceSettings protocol routing', () => {
       settings: {
         label: 'Shared Label',
         language: 'ja-Jpan-JP',
+        bt_enable: true,
         autolock_delay_ms: 60_000,
         haptic_feedback: true,
       },
@@ -137,12 +142,13 @@ describe('DeviceSettings protocol routing', () => {
       {
         identity: { label: 'Shared Label' },
         settings: {
-          language: 'ja-Jpan-JP',
+          language: 'ja',
+          bleEnabled: true,
           autoLockDelayMs: 60_000,
           hapticFeedback: true,
         },
       },
-      'apply-settings'
+      'settings-write'
     );
     expect(typedCall.mock.calls.map(call => call[0])).not.toEqual(
       expect.arrayContaining(['DeviceInfoGet', 'DeviceStatusGet', 'DeviceSettingsGet'])
@@ -283,4 +289,103 @@ describe('DeviceSettings protocol routing', () => {
     });
     expect(typedCall).not.toHaveBeenCalled();
   });
+
+  it('rejects Protocol V1-only settings on Protocol V2 without partially applying the request', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 9,
+      payload: {
+        method: 'deviceSettings',
+        label: 'Must not be partially applied',
+        safetyChecks: 0,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      message: 'Protocol V2 does not support settings: safetyChecks.',
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('rejects Protocol V2-only settings on Protocol V1 without partially applying the request', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 10,
+      payload: {
+        method: 'deviceSettings',
+        label: 'Must not be partially applied',
+        brightness: 80,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      message: 'Protocol V1 does not support settings: brightness.',
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('accepts the Protocol V2 never timeout wire value', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 11,
+      payload: {
+        method: 'deviceSettings',
+        autoLockDelayMs: 0x10000000,
+        autoShutdownDelayMs: 0x10000000,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await method.run();
+
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsSet', 'Success', {
+      settings: {
+        autolock_delay_ms: 0x10000000,
+        autoshutdown_delay_ms: 0x10000000,
+      },
+    });
+  });
+
+  it('rejects unsupported Protocol V2 timeout values before sending a command', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 12,
+      payload: {
+        method: 'deviceSettings',
+        autoLockDelayMs: 0,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('rejects unknown Protocol V1 safety check levels before sending a command', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 13,
+      payload: {
+        method: 'deviceSettings',
+        safetyChecks: 3,
+      },
+    } as never);
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
 });

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

@@ -27,7 +27,7 @@ describe('Device state events', () => {
           protocolV2DeviceInfo: { protocol_version: 2 },
         },
       },
-      'apply-settings'
+      'settings-write'
     );
 
     expect(state?.identity.label).toBe('Renamed');
@@ -36,7 +36,7 @@ describe('Device state events', () => {
       expect.objectContaining({
         state: expect.objectContaining({ revision: 1 }),
         revision: 1,
-        source: 'apply-settings',
+        source: 'settings-write',
       })
     );
     expect(onFeatures).not.toHaveBeenCalled();
@@ -96,7 +96,7 @@ describe('Device state events', () => {
         protocol: 'V1',
         identity: { label: 'Legacy' },
       },
-      'apply-settings'
+      'settings-write'
     );
 
     expect(onFeatures).toHaveBeenCalledWith(device, expect.objectContaining({ label: 'Legacy' }));

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

@@ -1,5 +1,6 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
 import {
   mapApplySettingsToState,
   mapDeviceSettingsToState,
@@ -208,22 +209,33 @@ describe('DeviceStateMapper', () => {
 
   test('maps common settings into identity, status and settings sections', () => {
     expect(
-      mapApplySettingsToState({ label: 'Renamed', use_passphrase: true, haptic_feedback: false })
+      mapApplySettingsToState({
+        label: 'Renamed',
+        use_passphrase: true,
+        haptic_feedback: false,
+        use_ble: true,
+        safety_checks: 'Strict',
+      })
     ).toEqual({
       identity: { label: 'Renamed' },
       status: { passphraseProtection: true },
-      settings: { hapticFeedback: false },
+      settings: {
+        hapticFeedback: false,
+        bleEnabled: true,
+        safetyChecks: Enum_SafetyCheckLevel.Strict,
+      },
     });
 
     expect(
       mapDeviceSettingsToState({
         label: 'Pro2',
+        language: 'en-Latn-US',
         brightness: 80,
         autolock_delay_ms: 30_000,
       } as DeviceSettings)
     ).toEqual({
       identity: { label: 'Pro2' },
-      settings: { brightness: 80, autoLockDelayMs: 30_000 },
+      settings: { language: 'en', brightness: 80, autoLockDelayMs: 30_000 },
     });
   });
 });

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

@@ -14,7 +14,7 @@ describe('DeviceStateStore', () => {
     store.update({ identity: { bleName: 'Pro2 1234', label: null } }, 'initialize');
     const result = store.update(
       { identity: { label: 'My Wallet', bleName: undefined } },
-      'apply-settings'
+      'settings-write'
     );
 
     expect(result.state.identity).toMatchObject({

package/__tests__/device-wallet-session-store.test.ts

@@ -1,3 +1,5 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import ClearSessionCache from '../src/api/ClearSessionCache';
 import {
   DeviceWalletSessionStore,
@@ -5,6 +7,7 @@ import {
 } from '../src/device/DeviceWalletSessionStore';
 import { Device } from '../src/device/Device';
 import { createCoreApi } from '../src/inject';
+import TransportManager from '../src/data-manager/TransportManager';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -116,7 +119,19 @@ describe('ClearSessionCache', () => {
     expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
   });
 
-  test('keeps legacy Features session fields as projections of the store', async () => {
+  test('rejects passphraseState without a deviceId instead of clearing every device', () => {
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+    deviceWalletSessionStore.set('device-2', 'hidden-a', 'session-b');
+    const method = new ClearSessionCache({
+      payload: { method: 'clearSessionCache', passphraseState: 'hidden-a' },
+    });
+
+    expect(() => method.init()).toThrow('Parameter [deviceId] is required with [passphraseState].');
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-a')).toBe('session-a');
+    expect(deviceWalletSessionStore.get('device-2', 'hidden-a')).toBe('session-b');
+  });
+
+  test('keeps wallet sessions internal instead of projecting them through Features', async () => {
     const device = Device.fromDescriptor({ id: 'one', path: 'one' } as never);
     device.features = {
       protocol: 'V1',
@@ -133,11 +148,14 @@ describe('ClearSessionCache', () => {
     } as never;
 
     expect(device.state).not.toHaveProperty('session');
+    expect(device.getInternalState()).toBe('session-a');
     expect(device.features).toMatchObject({
-      sessionId: 'session-a',
-      session_id: 'session-a',
-      passphraseState: 'hidden-a',
+      sessionId: null,
+      session_id: null,
     });
+    expect(device.features).not.toHaveProperty('passphraseState');
+    expect(device.features?.raw?.protocolV1Features).not.toHaveProperty('sessionId');
+    expect(device.features?.raw?.protocolV1Features).not.toHaveProperty('session_id');
 
     const method = new ClearSessionCache({
       payload: {
@@ -151,10 +169,20 @@ describe('ClearSessionCache', () => {
 
     expect(device.features?.sessionId).toBeNull();
     expect(device.features?.session_id).toBeNull();
-    expect(device.state?.raw?.protocolV1Features).toMatchObject({
+    expect(device.state?.raw?.protocolV1Features).not.toHaveProperty('sessionId');
+    expect(device.state?.raw?.protocolV1Features).not.toHaveProperty('session_id');
+  });
+
+  test('uses only the transport path as the temporary Protocol V2 cache key', () => {
+    const device = Device.fromDescriptor({ id: 'descriptor-id' } as never);
+    device.features = {
+      protocol: 'V2',
+      passphraseState: 'hidden-a',
       sessionId: 'session-a',
-      session_id: 'session-a',
-    });
+    } as never;
+
+    expect(device.getInternalState()).toBeUndefined();
+    expect(deviceWalletSessionStore.get('descriptor-id', 'hidden-a')).toBeUndefined();
   });
 
   test('clears one wallet without using a device', async () => {
@@ -211,3 +239,79 @@ describe('ClearSessionCache', () => {
     });
   });
 });
+
+describe('Protocol V1 wallet identity initialization', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+    jest.restoreAllMocks();
+  });
+
+  test('verifies the live device id before sending a cached wallet session', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'cached-device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'live-device-b' },
+    });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await expect(
+      device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      expect.not.objectContaining({ session_id: 'session-a' }),
+      expect.any(Object)
+    );
+  });
+
+  test('resumes a cached V1 wallet only after the live device id matches', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
+      .mockResolvedValueOnce({
+        type: 'Features',
+        message: { device_id: 'device-a', session_id: 'session-a' },
+      });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'Initialize',
+      'Features',
+      expect.not.objectContaining({ session_id: 'session-a' }),
+      expect.any(Object)
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'Initialize',
+      'Features',
+      expect.objectContaining({
+        session_id: 'session-a',
+        passphrase_state: 'hidden-a',
+      }),
+      expect.any(Object)
+    );
+  });
+});