@onekeyfe/hd-core 1.2.0-alpha.32 → 1.2.0-alpha.34

package/__tests__/check-all-firmware-release-protocol-v2.test.ts

@@ -160,6 +160,37 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
   });
 
+  test('keeps same-version hash-aware components unknown without metadata payloadHash', () => {
+    const packageSet: IFirmwareReleaseInfo = {
+      ...release,
+      required: false,
+      resourceBundles: undefined,
+      installOrder: ['applicationP1'],
+      components: {
+        applicationP1: {
+          target: 'APPLICATION_P1',
+          version: [1, 0, 0],
+          url: 'https://untrusted.example/application-p1.okpkg',
+          fingerprint: 'file-sha256-p1',
+        },
+      },
+    };
+
+    expect(
+      buildProtocolV2FirmwareRelease({
+        currentVersions: { ...currentVersions, applicationP1: '1.0.0' },
+        currentVerification: { applicationP1Hash: 'aa'.repeat(32) },
+        firmwareType: EFirmwareType.Universal,
+        release: packageSet,
+      })
+    ).toMatchObject({
+      status: 'unknown',
+      hasUpgrade: false,
+      targetsToUpdate: [],
+      components: [{ configKey: 'applicationP1', status: 'unknown' }],
+    });
+  });
+
   test('updates both application packages when normal mode only reports P1', () => {
     const packageSet: IFirmwareReleaseInfo = {
       ...release,

package/__tests__/core-dispose.test.ts

@@ -17,18 +17,18 @@ describe('Core.dispose', () => {
     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 disposeDevicePool = jest.spyOn(DevicePool, 'dispose');
     const core = new Core();
 
     const firstDispose = core.dispose();
     expect(connectorStop).toHaveBeenCalledTimes(1);
     expect(transportStop).toHaveBeenCalledTimes(1);
-    expect(resetDevicePool).toHaveBeenCalledTimes(1);
+    expect(disposeDevicePool).toHaveBeenCalledTimes(1);
 
     await firstDispose;
     await core.dispose();
     expect(connectorStop).toHaveBeenCalledTimes(1);
     expect(transportStop).toHaveBeenCalledTimes(1);
-    expect(resetDevicePool).toHaveBeenCalledTimes(1);
+    expect(disposeDevicePool).toHaveBeenCalledTimes(1);
   });
 });

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

@@ -79,6 +79,57 @@ describe('public device lifecycle events', () => {
     expect(DevicePool.emitter.listenerCount(DEVICE.DISCONNECT)).toBe(1);
   });
 
+  test('keeps shared device lifecycle listeners across a device cache reset', () => {
+    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.resetState();
+    DevicePool.emitter.emit(DEVICE.CONNECT, device);
+    DevicePool.emitter.emit(DEVICE.DISCONNECT, device);
+
+    expect(messages.filter(message => message.type === DEVICE.CONNECT)).toHaveLength(1);
+    expect(messages.filter(message => message.type === DEVICE.DISCONNECT)).toHaveLength(1);
+  });
+
+  test('uses a cached protocol as a fallback-capable acquire hint', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-id',
+      path: 'ble-id',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
+    device.deviceConnector = { acquire } as never;
+
+    await device.acquire();
+
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, 'V1');
+    expect(device.getProtocol()).toBe('V2');
+    expect(device.originalDescriptor.protocolType).toBe('V2');
+  });
+
+  test('keeps an explicit connectProtocol as a strict expected protocol', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-id',
+      path: 'ble-id',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
+    device.deviceConnector = { acquire } as never;
+
+    await device.acquire('V2');
+
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V2', undefined);
+    expect(device.getProtocol()).toBe('V2');
+  });
+
   test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -125,6 +176,7 @@ describe('public device lifecycle events', () => {
     const device = createInitializedDevice('V2');
 
     expect(device.toMessageObject()?.status).toBe('available');
+    expect(device.toMessageObject()?.connectProtocol).toBe('V2');
 
     (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
     expect(device.toMessageObject()?.status).toBe('used');

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

@@ -9,11 +9,11 @@ jest.mock('../src/data/config', () => ({
 
 describe('DevicePool state lifecycle', () => {
   beforeEach(() => {
-    DevicePool.resetState();
+    DevicePool.dispose();
   });
 
   afterEach(() => {
-    DevicePool.resetState();
+    DevicePool.dispose();
   });
 
   test('refreshes runtime state for a cached Protocol V2 discovery result', async () => {
@@ -74,6 +74,18 @@ describe('DevicePool state lifecycle', () => {
     expect(DevicePool.disconnectPool).toEqual([]);
   });
 
+  test('preserves shared listeners when resetting cached device state', () => {
+    const listener = jest.fn();
+    DevicePool.emitter.on(DEVICE.CONNECT, listener);
+    DevicePool.devicesCache = { stale: {} as Device };
+
+    DevicePool.resetState();
+    DevicePool.emitter.emit(DEVICE.CONNECT, { path: 'next-device' });
+
+    expect(DevicePool.devicesCache).toEqual({});
+    expect(listener).toHaveBeenCalledWith({ path: 'next-device' });
+  });
+
   test('releases a newly created device when initialization fails', async () => {
     const descriptor = { path: 'pro2-path', protocolType: 'V2' } as any;
     const release = jest.fn().mockResolvedValue(undefined);

package/__tests__/device-settings.test.ts

@@ -226,6 +226,28 @@ describe('DeviceSettings protocol routing', () => {
     });
   });
 
+  it('accepts a locked Pro2 as confirmation after disabling passphrase', async () => {
+    const { device, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState
+      .mockResolvedValueOnce({
+        status: { unlocked: true, passphraseProtection: true },
+      })
+      .mockResolvedValueOnce({
+        status: { unlocked: false, passphraseProtection: true },
+      });
+    const method = new DeviceSettings({
+      id: 6,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: false,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+  });
+
   it('keeps Protocol V1 passphrase settings on ApplySettings', async () => {
     const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V1' });
     const method = new DeviceSettings({

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

@@ -1,6 +1,6 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
-import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+import { DeviceType, Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
 import {
   mapApplySettingsToState,
   mapDeviceSettingsToState,
@@ -109,7 +109,7 @@ describe('DeviceStateMapper', () => {
     const patch = mapProtocolV2DeviceInfoToState(
       {
         protocol_version: 2,
-        hw: { serial_no: 'SERIAL-1' },
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
         fw: {
           application: { version: '5.0.0', build_id: 'p1-build', hash: [0x01, 0x02] },
           application_data: { version: '5.0.1', build_id: 'p2-build', hash: [0x03, 0x04] },
@@ -145,6 +145,17 @@ describe('DeviceStateMapper', () => {
     expect(patch.status?.unlocked).toBeUndefined();
   });
 
+  test('maps the hardware model independently from Protocol V2', () => {
+    const pro = mapProtocolV2DeviceInfoToState({
+      protocol_version: 2,
+      hw: { Device_type: 'PRO' as unknown as DeviceType, serial_no: 'SERIAL-PRO' },
+    });
+    const unknown = mapProtocolV2DeviceInfoToState({ protocol_version: 2, hw: {} });
+
+    expect(pro.identity).toMatchObject({ deviceType: EDeviceType.Pro, model: 'pro' });
+    expect(unknown.identity).toMatchObject({ deviceType: EDeviceType.Unknown, model: null });
+  });
+
   test('keeps normal mode when Protocol V2 application and SE versions are returned together', () => {
     const patch = mapProtocolV2DeviceInfoToState(
       {

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

@@ -73,7 +73,7 @@ describe('DeviceStateProjector', () => {
     });
   });
 
-  test('returns an isolated compatibility snapshot', () => {
+  test('returns an isolated compatibility snapshot without internal raw state', () => {
     const state = createEmptyDeviceState({ deviceType: EDeviceType.Pro });
     state.protocol = 'V1';
     state.capabilities = [1];
@@ -85,10 +85,10 @@ describe('DeviceStateProjector', () => {
     const features = projectFeatures(state);
     features.capabilities.push(2);
     if (features.verify) features.verify.firmwareBuildId = 'mutated';
-    if (features.raw?.protocolV1Features) features.raw.protocolV1Features.label = 'Mutated';
 
     expect(state.capabilities).toEqual([1]);
     expect(state.verification?.firmwareBuildId).toBe('build-1');
     expect(state.raw.protocolV1Features?.label).toBe('Original');
+    expect(features).not.toHaveProperty('raw');
   });
 });

package/__tests__/device-utils.test.ts

@@ -61,6 +61,7 @@ describe('device feature selectors', () => {
     } as PROTO.Features;
 
     expect(getDeviceType(features)).toBe(EDeviceType.Classic);
+    expect(getDeviceFirmwareVersion(features)).toEqual([0, 0, 0]);
     expect(getDeviceBootloaderVersion(features)).toEqual([1, 8, 3]);
   });
 

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

@@ -35,6 +35,35 @@ describe('DeviceWalletSessionStore', () => {
     expect(store.get('device-2', 'hidden-a')).toBe('session-c');
   });
 
+  test('evicts the oldest wallet session when a device exceeds the SE capacity of three', () => {
+    const store = new DeviceWalletSessionStore();
+    store.setStandard('device-1', 'wallet-a', 'session-a');
+    store.set('device-1', 'wallet-b', 'session-b');
+    store.set('device-1', 'wallet-c', 'session-c');
+    store.set('device-1', 'wallet-d', 'session-d');
+
+    expect(store.get('device-1', 'wallet-a')).toBeUndefined();
+    expect(store.getStandard('device-1')).toBeUndefined();
+    expect(store.get('device-1', 'wallet-b')).toBe('session-b');
+    expect(store.get('device-1', 'wallet-c')).toBe('session-c');
+    expect(store.get('device-1', 'wallet-d')).toBe('session-d');
+  });
+
+  test('indexes the standard wallet without replacing hidden-wallet sessions', () => {
+    const store = new DeviceWalletSessionStore();
+    store.set('device-1', 'hidden-a', 'hidden-session-a');
+
+    store.setStandard('device-1', 'standard-state', 'standard-session-1');
+    store.setStandard('device-1', 'standard-state', 'standard-session-2');
+
+    expect(store.getStandard('device-1')).toEqual({
+      passphraseState: 'standard-state',
+      sessionId: 'standard-session-2',
+    });
+    expect(store.get('device-1', 'standard-state')).toBe('standard-session-2');
+    expect(store.get('device-1', 'hidden-a')).toBe('hidden-session-a');
+  });
+
   test('keeps pending sessions unreadable until wallet binding', () => {
     const store = new DeviceWalletSessionStore();
     store.setPending('device-1', 'pending-session');
@@ -46,6 +75,7 @@ describe('DeviceWalletSessionStore', () => {
   test('migrates descriptor keys to stable device ids', () => {
     const store = new DeviceWalletSessionStore();
     store.set('ble-path', 'hidden-a', 'session-a');
+    store.setStandard('ble-path', 'standard-state', 'standard-session');
     store.setPending('ble-path', 'pending-session');
 
     store.reconcileDeviceIdentity({
@@ -55,10 +85,34 @@ describe('DeviceWalletSessionStore', () => {
 
     expect(store.get('ble-path', 'hidden-a')).toBeUndefined();
     expect(store.get('stable-device-id', 'hidden-a')).toBe('session-a');
+    expect(store.getStandard('ble-path')).toBeUndefined();
+    expect(store.getStandard('stable-device-id')).toEqual({
+      passphraseState: 'standard-state',
+      sessionId: 'standard-session',
+    });
     expect(store.getPending('ble-path')).toBeUndefined();
     expect(store.getPending('stable-device-id')).toBe('pending-session');
   });
 
+  test('keeps the three-session limit when descriptor sessions merge into a stable device id', () => {
+    const store = new DeviceWalletSessionStore();
+    store.setStandard('stable-device-id', 'wallet-a', 'session-a');
+    store.set('stable-device-id', 'wallet-b', 'session-b');
+    store.set('ble-path', 'wallet-c', 'session-c');
+    store.set('ble-path', 'wallet-d', 'session-d');
+
+    store.reconcileDeviceIdentity({
+      temporaryKey: 'ble-path',
+      nextDeviceId: 'stable-device-id',
+    });
+
+    expect(store.get('stable-device-id', 'wallet-a')).toBeUndefined();
+    expect(store.getStandard('stable-device-id')).toBeUndefined();
+    expect(store.get('stable-device-id', 'wallet-b')).toBe('session-b');
+    expect(store.get('stable-device-id', 'wallet-c')).toBe('session-c');
+    expect(store.get('stable-device-id', 'wallet-d')).toBe('session-d');
+  });
+
   test('drops sessions from an old stable identity without overwriting the new device', () => {
     const store = new DeviceWalletSessionStore();
     store.set('device-a', 'hidden-a', 'session-a');
@@ -82,11 +136,16 @@ describe('DeviceWalletSessionStore', () => {
     const store = new DeviceWalletSessionStore();
     store.set('device-1', 'hidden-a', 'session-a');
     store.set('device-1', 'hidden-b', 'session-b');
+    store.setStandard('device-1', 'standard-state', 'standard-session');
     store.set('device-2', 'hidden-a', 'session-c');
 
     store.delete('device-1', 'hidden-a');
     expect(store.get('device-1', 'hidden-a')).toBeUndefined();
     expect(store.get('device-1', 'hidden-b')).toBe('session-b');
+    expect(store.getStandard('device-1')?.sessionId).toBe('standard-session');
+
+    store.delete('device-1', 'standard-state');
+    expect(store.getStandard('device-1')).toBeUndefined();
 
     store.deleteDevice('device-1');
     expect(store.get('device-1', 'hidden-b')).toBeUndefined();
@@ -195,8 +254,7 @@ describe('ClearSessionCache', () => {
       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');
+    expect(device.features).not.toHaveProperty('raw');
 
     const method = new ClearSessionCache({
       payload: {
@@ -287,7 +345,7 @@ describe('Protocol V1 wallet identity initialization', () => {
     jest.restoreAllMocks();
   });
 
-  test('verifies the live device id before sending a cached wallet session', async () => {
+  test('verifies the live device id without resetting the cached wallet session', async () => {
     const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
     device.features = {
       protocol: 'V1',
@@ -307,15 +365,10 @@ describe('Protocol V1 wallet identity initialization', () => {
       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)
-    );
+    expect(typedCall).toHaveBeenCalledWith('GetFeatures', 'Features', {});
   });
 
-  test('resumes a cached V1 wallet only after the live device id matches', async () => {
+  test('resumes a cached V1 wallet after a non-destructive live identity read', async () => {
     const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
     device.features = {
       protocol: 'V1',
@@ -337,13 +390,7 @@ describe('Protocol V1 wallet identity initialization', () => {
     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(1, 'GetFeatures', 'Features', {});
     expect(typedCall).toHaveBeenNthCalledWith(
       2,
       'Initialize',

package/__tests__/kaspaSignTransaction.test.ts

@@ -135,6 +135,15 @@ describe('KaspaSignTransaction capability flags', () => {
       createMethod({ inputs: [buildInput()], outputs: [{ satoshis: 1 }] }).init()
     ).toThrow('outputs require either address/addressN');
   });
+
+  it('rejects outputs containing both address and addressN', () => {
+    expect(() =>
+      createMethod({
+        inputs: [buildInput()],
+        outputs: [{ satoshis: 1, address: ADDRESS, addressN: CHANGE_PATH }],
+      }).init()
+    ).toThrow('outputs must not contain both address and addressN');
+  });
 });
 
 describe('KaspaSignTransaction protocol negotiation', () => {

package/__tests__/known-device-public-types.type-test.ts

@@ -0,0 +1,3 @@
+import type { Features, KnownDevice } from '../src/types';
+
+export const requireKnownDeviceFeatures = ({ features }: KnownDevice): Features => features;

package/__tests__/logBlockEvent.test.ts

@@ -1,4 +1,10 @@
-import { UI_RESPONSE, getLogBlockLabel } from '../src/events';
+import {
+  UI_REQUEST,
+  UI_RESPONSE,
+  formatLogMethodLabel,
+  getLogBlockLabel,
+  getSafeLogPayload,
+} from '../src/events';
 
 describe('getLogBlockLabel', () => {
   it('blocks evmSignTypedData params before logging large typed data', () => {
@@ -35,6 +41,21 @@ describe('getLogBlockLabel', () => {
     expect(getLogBlockLabel({ type: UI_RESPONSE.RECEIVE_PIN })).toBe(UI_RESPONSE.RECEIVE_PIN);
   });
 
+  it.each([UI_REQUEST.REQUEST_PASSPHRASE, UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE])(
+    'blocks wallet identifiers in %s event logging',
+    type => {
+      expect(
+        getLogBlockLabel({
+          type,
+          payload: {
+            passphraseState: 'wallet-identifier',
+            expectedPassphraseState: 'expected-wallet-identifier',
+          },
+        })
+      ).toBe(type);
+    }
+  );
+
   it('blocks openWalletSession wallet identifiers in direct and iframe call logging', () => {
     const payload = {
       method: 'openWalletSession',
@@ -53,16 +74,51 @@ describe('getLogBlockLabel', () => {
     ).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(['deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
-    'blocks binary payload logging for %s',
+    'keeps metadata and replaces binary payloads with their size for %s',
     method => {
-      expect(getLogBlockLabel({ method, data: new Uint8Array(1024) })).toBe(method);
-      expect(getLogBlockLabel({ payload: { method, data: new Uint8Array(1024) } })).toBe(method);
+      const request = { method, path: 'resource.bin', data: new Uint8Array(1024) };
+      expect(getLogBlockLabel(request)).toBe(method);
+      expect(getSafeLogPayload(request, method)).toEqual({
+        method,
+        path: 'resource.bin',
+        data: '[BINARY:1024]',
+      });
     }
   );
 
   it.each(['evmSignMessage', 'btcSignMessage', 'evmSignTransaction'])(
-    'blocks request and response payload logging for every API method including %s',
+    'blocks request and response payload logging for signing method %s',
     method => {
       expect(getLogBlockLabel({ method, message: 'sensitive signing payload' })).toBe(method);
       expect(
@@ -74,6 +130,34 @@ describe('getLogBlockLabel', () => {
     }
   );
 
+  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]' } },
+    });
+  });
+
+  it('puts sensitive API method names in the log label', () => {
+    expect(formatLogMethodLabel('response:', 'openWalletSession')).toBe(
+      'response: [openWalletSession]'
+    );
+    expect(formatLogMethodLabel('response:')).toBe('response:');
+  });
+
   it('does not classify events without an API method as method calls', () => {
     expect(getLogBlockLabel({ event: 'DEVICE_EVENT', type: 'device-connect' })).toBeUndefined();
   });