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

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

@@ -1,7 +1,9 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceType } from '@onekeyfe/hd-transport';
 
 import { Device } from '../src/device/Device';
 import { DEVICE } from '../src/events';
+import { PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE } from '../src/protocols/protocol-v2';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -28,7 +30,83 @@ const createV1Device = (typedCall: jest.Mock) => {
   return device;
 };
 
+const protocolV2ApplicationInfo = {
+  version: 1,
+  build_fingerprint: 'application__5.0.0__abcdef0__PROD__RELEASE',
+  supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
+};
+
+const getProtocolV2LoaderInfo = (mode: 'bootloader' | 'romloader') => ({
+  version: 1,
+  build_fingerprint: `${mode}__1.0.0__abcdef0__PROD__RELEASE`,
+  supported_messages: [],
+});
+
 describe('getDeviceState', () => {
+  test('coalesces concurrent Protocol V2 runtime-context negotiation', async () => {
+    let resolveProtocolInfo:
+      | ((value: { message: typeof protocolV2ApplicationInfo }) => void)
+      | undefined;
+    const typedCall = jest.fn(
+      () =>
+        new Promise<{ message: typeof protocolV2ApplicationInfo }>(resolve => {
+          resolveProtocolInfo = resolve;
+        })
+    );
+    const device = createV2Device(typedCall);
+
+    const first = device.ensureProtocolV2RuntimeContext();
+    const second = device.ensureProtocolV2RuntimeContext();
+    resolveProtocolInfo?.({ message: protocolV2ApplicationInfo });
+
+    await expect(Promise.all([first, second])).resolves.toEqual([
+      protocolV2ApplicationInfo,
+      protocolV2ApplicationInfo,
+    ]);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
+  });
+
+  test('renegotiates Protocol V2 runtime context after transport disconnect', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: protocolV2ApplicationInfo });
+    const device = createV2Device(typedCall);
+
+    await device.ensureProtocolV2RuntimeContext();
+    await device.ensureProtocolV2RuntimeContext();
+    device.markTransportDisconnected();
+    await device.ensureProtocolV2RuntimeContext();
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+  });
+
+  test('rejects every waiter when runtime-context negotiation is invalidated', async () => {
+    let resolveProtocolInfo:
+      | ((value: { message: typeof protocolV2ApplicationInfo }) => void)
+      | undefined;
+    const typedCall = jest.fn(
+      () =>
+        new Promise<{ message: typeof protocolV2ApplicationInfo }>(resolve => {
+          resolveProtocolInfo = resolve;
+        })
+    );
+    const device = createV2Device(typedCall);
+
+    const first = device.ensureProtocolV2RuntimeContext();
+    const second = device.ensureProtocolV2RuntimeContext();
+    const firstExpectation = expect(first).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInitializeFailed,
+    });
+    const secondExpectation = expect(second).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInitializeFailed,
+    });
+    device.markTransportDisconnected();
+    resolveProtocolInfo?.({ message: protocolV2ApplicationInfo });
+
+    await Promise.all([firstExpectation, secondExpectation]);
+  });
+
   test('does not expose the internal wallet session', async () => {
     const device = createV2Device(jest.fn());
     device.updateState({ protocol: 'V2' }, 'initialize');
@@ -39,45 +117,55 @@ describe('getDeviceState', () => {
   });
 
   test('hydrates Protocol V2 with separate DeviceInfoGet and DeviceStatusGet', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => ({
-      message:
-        requestType === 'DeviceInfoGet'
-          ? {
-              protocol_version: 2,
-              hw: { serial_no: 'SERIAL-1' },
-              fw: { application: { version: '5.0.0' } },
-            }
-          : { init_states: true, unlocked: true },
-    }));
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            protocol_version: 2,
+            hw: { serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0' } },
+          },
+        };
+      }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
+      return { message: { init_states: true, unlocked: true } };
+    });
     const device = createV2Device(typedCall);
 
     const state = await device.getDeviceState();
 
     expect(state.identity.serialNo).toBe('SERIAL-1');
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(3);
     expect(typedCall.mock.calls[0][0]).toBe('DeviceInfoGet');
     expect(typedCall.mock.calls[0][2]?.targets?.status).not.toBe(true);
     expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
   });
 
   test('uses one full DeviceInfoGet plus DeviceStatusGet when firmware refresh initializes state', async () => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => ({
-      message:
-        requestType === 'DeviceInfoGet'
-          ? {
-              protocol_version: 2,
-              hw: { serial_no: 'SERIAL-1' },
-              fw: { application: { version: '5.0.0', hash: 'HASH-1' } },
-            }
-          : { init_states: true, unlocked: true },
-    }));
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            protocol_version: 2,
+            hw: { serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0', hash: 'HASH-1' } },
+          },
+        };
+      }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
+      return { message: { init_states: true, unlocked: true } };
+    });
     const device = createV2Device(typedCall);
 
     await device.getDeviceState({
       refreshSections: ['identity', 'versions', 'verification'],
     });
 
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(3);
     expect(typedCall).toHaveBeenNthCalledWith(
       1,
       'DeviceInfoGet',
@@ -115,13 +203,13 @@ describe('getDeviceState', () => {
   });
 
   test.each(['bootloader', 'romloader'] as const)(
-    'temporarily treats failed DeviceStatusGet with %s metadata as bootloader',
+    'uses ProtocolInfo to preserve %s mode without DeviceStatusGet',
     async mode => {
       const typedCall = jest.fn().mockImplementation((requestType: string) => {
         if (requestType === 'DeviceInfoGet') {
           return {
             message: {
-              hw: { serial_no: 'SERIAL-1' },
+              hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
               fw:
                 mode === 'romloader'
                   ? { romloader: { version: '1.0.0' } }
@@ -129,27 +217,53 @@ describe('getDeviceState', () => {
             },
           };
         }
-        throw new Error('DeviceStatusGet unavailable');
+        if (requestType === 'ProtocolInfoRequest') {
+          return { message: getProtocolV2LoaderInfo(mode) };
+        }
+        throw new Error(`Unexpected request: ${requestType}`);
       });
       const device = createV2Device(typedCall);
-      device.updateState({ protocol: 'V2', status: { mode } }, 'initialize');
+      device.updateState(
+        {
+          protocol: 'V2',
+          identity: { deviceType: EDeviceType.Pro2 },
+          status: { mode },
+          raw: { protocolV2ProtocolInfo: getProtocolV2LoaderInfo(mode) },
+        },
+        'initialize'
+      );
 
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
-      expect(state.status.mode).toBe('bootloader');
-      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-        'DeviceInfoGet',
-        'DeviceStatusGet',
-      ]);
+      expect(state.status.mode).toBe(mode);
+      expect(typedCall).not.toHaveBeenCalled();
     }
   );
 
   test('refreshes Protocol V2 status only when explicitly requested in normal mode', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: { init_states: true, unlocked: true, device_id: 'device-1' },
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            hw: { serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0' } },
+          },
+        };
+      }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
+      return { message: { init_states: true, unlocked: true, device_id: 'device-1' } };
     });
     const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
+    device.updateState(
+      {
+        protocol: 'V2',
+        status: { mode: 'normal' },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
+      'initialize'
+    );
 
     const state = await device.getDeviceState({ refreshSections: ['status'] });
 
@@ -167,7 +281,14 @@ describe('getDeviceState', () => {
       },
     });
     const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
+    device.updateState(
+      {
+        protocol: 'V2',
+        status: { mode: 'normal' },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
+      'initialize'
+    );
     const onState = jest.fn();
     device.on(DEVICE.STATE, onState);
 
@@ -203,18 +324,27 @@ describe('getDeviceState', () => {
           message: { init_states: true, unlocked: false, device_id: 'device-1' },
         };
       }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
       if (requestType === 'DeviceSettingsGet') {
         return { message: { label: 'Renamed Pro 2' } };
       }
       throw new Error(`Unexpected request: ${requestType}`);
     });
     const device = createV2Device(typedCall);
-    device.updateState({ protocol: 'V2', status: { mode: 'normal' } }, 'initialize');
+    device.updateState(
+      {
+        protocol: 'V2',
+        status: { mode: 'normal' },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
+      'initialize'
+    );
 
     const state = await device.getDeviceState({ refreshSections: ['status', 'settings'] });
 
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceInfoGet',
       'DeviceStatusGet',
       'DeviceSettingsGet',
     ]);
@@ -237,13 +367,20 @@ describe('getDeviceState', () => {
           message: { init_states: true, unlocked: false, device_id: 'device-1' },
         };
       }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
       throw Object.assign(new Error('Device locked'), {
         errorCode: HardwareErrorCode.DeviceLocked,
       });
     });
     const device = createV2Device(typedCall);
     device.updateState(
-      { protocol: 'V2', status: { mode: 'normal', unlocked: true } },
+      {
+        protocol: 'V2',
+        status: { mode: 'normal', unlocked: true },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
       'initialize'
     );
 
@@ -383,7 +520,10 @@ describe('getDeviceState', () => {
           },
         };
       }
-      throw new Error('DeviceStatusGet unavailable in bootloader');
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: getProtocolV2LoaderInfo('bootloader') };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
     });
     const device = createV2Device(typedCall);
     device.updateState(