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

package/__tests__/DeviceCommands.test.ts

@@ -19,7 +19,7 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
-  it('does not log DeviceSessionOpen response secrets', async () => {
+  it('does not log DeviceSessionGet 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,
-        'DeviceSessionOpen'
+        'DeviceSessionGet'
       )
     ).resolves.toMatchObject({ type: 'DeviceSession' });
 
@@ -41,7 +41,7 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
-  it('maps an invalid DeviceSessionOpen resume to WalletSessionInvalid', async () => {
+  it('maps an invalid DeviceSessionGet resume to WalletSessionInvalid', async () => {
     const commands = createCommands();
 
     await expect(
@@ -54,7 +54,7 @@ describe('DeviceCommands failure mapping', () => {
             message: 'Invalid session',
           },
         } as any,
-        'DeviceSessionOpen'
+        'DeviceSessionGet'
       )
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.WalletSessionInvalid,
@@ -66,7 +66,7 @@ describe('DeviceCommands failure mapping', () => {
     });
   });
 
-  it('maps DeviceSessionOpen user cancellation to ActionCancelled', async () => {
+  it('maps wallet-session user cancellation to ActionCancelled', async () => {
     const commands = createCommands();
 
     await expect(
@@ -79,7 +79,7 @@ describe('DeviceCommands failure mapping', () => {
             message: 'Cancelled on device',
           },
         } as any,
-        'DeviceSessionOpen'
+        'DeviceSessionAskPassphrase'
       )
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.ActionCancelled,
@@ -89,7 +89,7 @@ describe('DeviceCommands failure mapping', () => {
   it.each([
     [3, HardwareErrorCode.DeviceCheckUnlockTypeError],
     [4, HardwareErrorCode.DeviceNotOpenedPassphrase],
-  ])('maps DeviceSessionOpen subcode %s to its canonical wallet error', async (subcode, code) => {
+  ])('maps wallet-session subcode %s to its canonical wallet error', async (subcode, code) => {
     const commands = createCommands();
 
     await expect(
@@ -98,11 +98,46 @@ describe('DeviceCommands failure mapping', () => {
           type: 'Failure',
           message: { code: 'Failure_ProcessError', subcode, message: 'Session selection failed' },
         } as any,
-        'DeviceSessionOpen'
+        '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();
 

package/__tests__/connectSettings.test.ts

@@ -1,61 +1,19 @@
-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', () => {
-  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('keeps custom configFetcher in parsed settings', () => {
+    const configFetcher = jest.fn();
 
-  it('fails closed without a preloaded config in external-only mode', async () => {
     const settings = parseConnectSettings({
-      firmwareManifestMode: 'external-only',
+      fetchConfig: true,
+      configFetcher,
     });
 
-    await expect(DataManager.load(settings)).rejects.toThrow(
-      'External firmware config snapshot is required'
-    );
-    expect(mockAxiosGet).not.toHaveBeenCalled();
+    expect(settings.configFetcher).toBe(configFetcher);
   });
 });

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

@@ -1,3 +1,5 @@
+import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+
 import { initConnector, initCore } from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
@@ -59,6 +61,63 @@ describe('public device lifecycle events', () => {
     jest.restoreAllMocks();
   });
 
+  test('registers the shared device lifecycle listeners exactly once', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    core = initCore();
+    initConnector();
+
+    for (const id of ['first-call', 'second-call']) {
+      await core.handleMessage({
+        id,
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: { method: 'clearSessionCache' },
+      } as CoreMessage);
+    }
+
+    expect(DevicePool.emitter.listenerCount(DEVICE.CONNECT)).toBe(1);
+    expect(DevicePool.emitter.listenerCount(DEVICE.DISCONNECT)).toBe(1);
+  });
+
+  test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    core = initCore();
+    initConnector();
+    const messages: CoreMessage[] = [];
+    core.on(CORE_EVENT, message => messages.push(message));
+    const device = createInitializedDevice('V2');
+    DevicePool.devicesCache['ble-connect-id'] = device;
+
+    DevicePool.emitter.emit(TRANSPORT_EVENT.DEVICE_DISCONNECT, {
+      id: 'ble-connect-id',
+      connectId: 'ble-connect-id',
+      name: 'OneKey Test BLE',
+    });
+
+    const disconnectMessage = messages.find(message => message.type === DEVICE.DISCONNECT);
+    expect(disconnectMessage?.payload.device).toMatchObject({
+      connectId: 'ble-connect-id',
+      serialNo: 'SERIAL-001',
+      state: { protocol: 'V2' },
+    });
+    expect(() => JSON.stringify(disconnectMessage?.payload.device)).not.toThrow();
+  });
+
+  test('treats an acquired BLE device as reusable until the transport disconnects', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('desktop-web-ble' as never);
+    const device = createInitializedDevice('V2');
+    const acquire = jest.spyOn(device, 'acquire').mockResolvedValue(undefined);
+    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+    (device as any).commands = { disposed: false };
+
+    expect(device.isUsedHere()).toBe(true);
+    await expect(device.connect('V2')).resolves.toBe(true);
+    expect(acquire).not.toHaveBeenCalled();
+
+    device.markTransportDisconnected();
+    expect(device.isUsedHere()).toBe(false);
+  });
+
   test.each([
     ['react-native', 'V1'],
     ['react-native', 'V2'],

package/__tests__/device-settings.test.ts

@@ -37,7 +37,6 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
 
 describe('DeviceSettings protocol routing', () => {
   it.each([
-    ['label', { label: 'Shared Label' }],
     ['language', { language: 'ja-JP' }],
     ['brightness', { brightness: 80 }],
     ['haptic feedback', { hapticFeedback: true }],
@@ -56,6 +55,7 @@ describe('DeviceSettings protocol routing', () => {
   });
 
   it.each([
+    ['label', { label: 'Shared Label' }],
     ['auto lock', { autoLockDelayMs: 60_000 }],
     ['auto shutdown', { autoShutdownDelayMs: 120_000 }],
     ['mixed settings', { brightness: 80, autoLockDelayMs: 60_000 }],

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

@@ -1,6 +1,7 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import ClearSessionCache from '../src/api/ClearSessionCache';
+import DeviceWipe from '../src/api/device/DeviceWipe';
 import {
   DeviceWalletSessionStore,
   deviceWalletSessionStore,
@@ -96,6 +97,46 @@ describe('DeviceWalletSessionStore', () => {
   });
 });
 
+describe('Device wipe lifecycle invalidation', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+  });
+
+  test('clears the old Protocol V2 identity and wallet sessions after wipe succeeds', async () => {
+    const device = Device.fromDescriptor({
+      id: 'pro2-descriptor',
+      path: 'pro2-path',
+      protocolType: 'V2',
+    } as never);
+    device.features = {
+      protocol: 'V2',
+      deviceId: 'old-device-id',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    device.passphraseState = 'hidden-a';
+    deviceWalletSessionStore.set('old-device-id', 'hidden-a', 'old-session');
+    deviceWalletSessionStore.set('pro2-path', 'hidden-a', 'temporary-session');
+    device.markPreInitialized({ passphraseState: 'hidden-a' });
+    device.commands = {
+      typedCall: jest.fn().mockResolvedValue({ message: { message: 'accepted' } }),
+    } as never;
+
+    const method = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'accepted' });
+
+    expect(device.features).toBeUndefined();
+    expect(device.passphraseState).toBeUndefined();
+    expect(device.needReloadDevice).toBe(true);
+    expect(device.isPreInitializedValid(60_000)).toBe(false);
+    expect(deviceWalletSessionStore.get('old-device-id', 'hidden-a')).toBeUndefined();
+    expect(deviceWalletSessionStore.get('pro2-path', 'hidden-a')).toBeUndefined();
+  });
+});
+
 describe('ClearSessionCache', () => {
   beforeEach(() => {
     deviceWalletSessionStore.clear();

package/__tests__/firmware-update/firmware-update-v2-download-before-boot.test.ts

@@ -2,7 +2,7 @@ import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shar
 
 import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
 import { getBinary } from '../../src/api/firmware/getBinary';
-import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
+import { uploadFirmware } from '../../src/api/firmware/uploadFirmware';
 import * as utils from '../../src/utils';
 
 jest.mock('../../src/data/config', () => ({
@@ -18,8 +18,7 @@ jest.mock('../../src/api/firmware/getBinary', () => ({
 
 jest.mock('../../src/api/firmware/uploadFirmware', () => ({
   updateResources: jest.fn(),
-  updateResourcesFromSources: jest.fn(),
-  uploadFirmwareFromSource: jest.fn(),
+  uploadFirmware: jest.fn(),
 }));
 
 jest.mock('../../src/device/DevicePool', () => ({
@@ -30,9 +29,7 @@ jest.mock('../../src/device/DevicePool', () => ({
 }));
 
 const mockGetBinary = getBinary as jest.MockedFunction<typeof getBinary>;
-const mockUploadFirmwareFromSource = uploadFirmwareFromSource as jest.MockedFunction<
-  typeof uploadFirmwareFromSource
->;
+const mockUploadFirmware = uploadFirmware as jest.MockedFunction<typeof uploadFirmware>;
 
 type DeviceType = 'CLASSIC1S' | 'PURE';
 
@@ -178,7 +175,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).toHaveBeenCalledTimes(1);
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -219,11 +216,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           binary: firmwareBinary,
         } as Awaited<ReturnType<typeof getBinary>>);
       });
-      mockUploadFirmwareFromSource.mockImplementation(() => {
+      mockUploadFirmware.mockImplementation(() => {
         callOrder.push('upload');
-        return Promise.resolve(
-          expectedResponse as Awaited<ReturnType<typeof uploadFirmwareFromSource>>
-        );
+        return Promise.resolve(expectedResponse as Awaited<ReturnType<typeof uploadFirmware>>);
       });
       const { method, typedCall } = createMethod({
         updateType,
@@ -253,15 +248,15 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           },
         })
       );
-      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
         updateType,
         expect.any(Function),
         expect.any(Function),
         method.device,
-        expect.objectContaining({
-          size: firmwareBinary.byteLength,
-        }),
-        true,
+        {
+          payload: firmwareBinary,
+          rebootOnSuccess: true,
+        },
         isUpdateBootloader
       );
     }
@@ -276,11 +271,11 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
         binary: firmwareBinary,
       } as Awaited<ReturnType<typeof getBinary>>);
     });
-    mockUploadFirmwareFromSource.mockImplementation(() => {
+    mockUploadFirmware.mockImplementation(() => {
       callOrder.push('upload');
       return Promise.resolve({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
     });
     const { method, typedCall, acquire } = createMethod({
       bootloaderMode: true,
@@ -305,9 +300,9 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
           resolveDownload = resolve;
         })
     );
-    mockUploadFirmwareFromSource.mockResolvedValue({
+    mockUploadFirmware.mockResolvedValue({
       success: true,
-    } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
     const { method, typedCall } = createMethod();
 
     const runPromise = method.run();
@@ -338,7 +333,7 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
 
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 
   it.each([
@@ -347,23 +342,23 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
   ])(
     'keeps the non-empty %s binary overload and never downloads it again',
     async (_kind, binary) => {
-      mockUploadFirmwareFromSource.mockResolvedValue({
+      mockUploadFirmware.mockResolvedValue({
         success: true,
-      } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>);
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
       const { method } = createMethod({ binary });
 
       await method.run();
 
       expect(mockGetBinary).not.toHaveBeenCalled();
-      expect(mockUploadFirmwareFromSource).toHaveBeenCalledWith(
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
         'firmware',
         expect.any(Function),
         expect.any(Function),
         method.device,
-        expect.objectContaining({
-          size: binary.byteLength,
-        }),
-        true,
+        {
+          payload: binary,
+          rebootOnSuccess: true,
+        },
         undefined
       );
     }
@@ -374,21 +369,17 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     ['DataView', new DataView(new Uint8Array([9, 3, 4, 9]).buffer, 1, 2), [3, 4]],
     ['custom Buffer', createCustomBuffer(4), [1, 2, 3, 4]],
   ])('normalizes a non-empty %s before rebooting', async (_kind, binary, expectedBytes) => {
-    let uploadedBytes: number[] = [];
-    mockUploadFirmwareFromSource.mockImplementation(
-      async (_updateType, _typedCall, _postMessage, _device, source) => {
-        uploadedBytes = Array.from(new Uint8Array(await source.readAt(0, source.size)));
-        return {
-          success: true,
-        } as Awaited<ReturnType<typeof uploadFirmwareFromSource>>;
-      }
-    );
+    mockUploadFirmware.mockResolvedValue({
+      success: true,
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
     const { method } = createMethod({ binary });
 
     await method.run();
 
     expect(mockGetBinary).not.toHaveBeenCalled();
-    expect(uploadedBytes).toEqual(expectedBytes);
+    const normalizedBinary = mockUploadFirmware.mock.calls[0][4].payload;
+    expect(normalizedBinary).toBeInstanceOf(ArrayBuffer);
+    expect(Array.from(new Uint8Array(normalizedBinary))).toEqual(expectedBytes);
   });
 
   it.each([
@@ -406,6 +397,6 @@ describe('FirmwareUpdateV2 download-before-reboot safety', () => {
     expect(mockGetBinary).not.toHaveBeenCalled();
     expectNoFirmwareMutationCalls(typedCall);
     expect(acquire).not.toHaveBeenCalled();
-    expect(mockUploadFirmwareFromSource).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
   });
 });

package/__tests__/logBlockEvent.test.ts

@@ -60,4 +60,21 @@ describe('getLogBlockLabel', () => {
       expect(getLogBlockLabel({ payload: { method, data: new Uint8Array(1024) } })).toBe(method);
     }
   );
+
+  it.each(['evmSignMessage', 'btcSignMessage', 'evmSignTransaction'])(
+    'blocks request and response payload logging for every API method including %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('does not classify events without an API method as method calls', () => {
+    expect(getLogBlockLabel({ event: 'DEVICE_EVENT', type: 'device-connect' })).toBeUndefined();
+  });
 });