@onekeyfe/hd-core 1.2.0-alpha.105 → 1.2.0-alpha.107

package/__tests__/DeviceCommands.test.ts

@@ -561,22 +561,17 @@ describe('DeviceCommands failure mapping', () => {
 });
 
 describe('DeviceCommands Protocol V2 interactive response compatibility', () => {
-  it('auto-acks Pro2 ButtonRequest and registers Cancel instead of Initialize', async () => {
+  it('still auto-acks ButtonRequest when no hardware UI listener is registered', async () => {
     const commands = createCommands();
     const emit = jest.fn();
-    const cancelDevice = jest.spyOn(commands, 'cancelDevice').mockResolvedValue(undefined);
-    const cancelDeviceOnOneKeyDevice = jest
-      .spyOn(commands, 'cancelDeviceOnOneKeyDevice')
-      .mockResolvedValue(undefined);
     const commonCall = jest.fn().mockResolvedValue({
       type: 'Success',
       message: {},
     });
-    const setCancelableAction = jest.fn();
     commands.device = {
       ...commands.device,
       getCurrentDeviceType: jest.fn(() => 'pro2'),
-      setCancelableAction,
+      setCancelableAction: jest.fn(),
       emit,
       listenerCount: jest.fn(() => 0),
     } as any;
@@ -598,9 +593,6 @@ describe('DeviceCommands Protocol V2 interactive response compatibility', () =>
       expect.objectContaining({ code: 'ButtonRequest_PinEntry' })
     );
     expect(commonCall).toHaveBeenCalledWith('ButtonAck', {}, undefined);
-    await setCancelableAction.mock.calls[0][0]();
-    expect(cancelDevice).toHaveBeenCalledTimes(1);
-    expect(cancelDeviceOnOneKeyDevice).not.toHaveBeenCalled();
   });
 
   it('rejects PassphraseRequest when the Pro2 UI listener is not registered', async () => {

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

@@ -346,7 +346,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     expect(typedCall).not.toHaveBeenCalled();
     expect(getDeviceState).toHaveBeenCalledWith({
       refreshSections: ['identity', 'versions'],
-      allowLegacyProtocolV2ProtocolInfo: true,
     });
     expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
   });
@@ -726,7 +725,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
     expect(getDeviceState).toHaveBeenCalledWith({
       refreshSections: ['identity', 'versions', 'verification'],
-      allowLegacyProtocolV2ProtocolInfo: true,
     });
   });
 

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

@@ -1,14 +1,12 @@
-import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+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';
 import { Device } from '../src/device/Device';
-import { cancelDeviceInPrompt, cancelDeviceWithInitialize } from '../src/device/DeviceCommands';
 import { DevicePool } from '../src/device/DevicePool';
 import { CORE_EVENT, DEVICE, IFRAME } from '../src/events';
-import { PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE } from '../src/protocols/protocol-v2';
 
 import type Core from '../src/core';
 import type { CoreMessage } from '../src/events';
@@ -273,115 +271,6 @@ describe('public device lifecycle events', () => {
     expect(device.isUsedHere()).toBe(false);
   });
 
-  test.each([
-    ['V2', 'Cancel', 'webusb'],
-    ['V2', 'Cancel', 'desktop-web-ble'],
-    ['V2', 'Cancel', 'react-native'],
-    ['V1', 'Initialize', 'webusb'],
-    ['V1', 'Cancel', 'desktop-web-ble'],
-  ] as const)(
-    'sends Protocol %s %s without treating the acquired %s session as disconnected',
-    async (protocol, messageType, env) => {
-      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
-      const device = createInitializedDevice(protocol);
-      const post = jest.fn().mockResolvedValue(undefined);
-      const call = jest.fn().mockResolvedValue(undefined);
-      const cancel = jest.fn().mockResolvedValue(undefined);
-      device.originalDescriptor.session = device.mainId;
-      (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
-      (device as any).commands = { transport: { post, call }, cancel };
-      device.setCancelableAction(() =>
-        messageType === 'Cancel'
-          ? cancelDeviceInPrompt(device, false)
-          : cancelDeviceWithInitialize(device)
-      );
-
-      await device.interruptionFromUser();
-
-      if (messageType === 'Cancel') {
-        expect(post).toHaveBeenCalledWith(device.mainId, 'Cancel', {});
-        expect(call).not.toHaveBeenCalled();
-      } else {
-        expect(call).toHaveBeenCalledWith(device.mainId, 'Initialize', {});
-        expect(post).not.toHaveBeenCalled();
-      }
-      expect(cancel).toHaveBeenCalledTimes(1);
-      expect(device.hasDeviceAcquire()).toBe(true);
-    }
-  );
-
-  test.each([
-    [EDeviceType.Pro2, 'webusb', false, DeviceType.PRO2],
-    [EDeviceType.Neo, 'webusb', false, DeviceType.NEO],
-    [EDeviceType.Pro2, 'desktop-web-ble', true, DeviceType.PRO2],
-    [EDeviceType.Neo, 'desktop-web-ble', true, DeviceType.NEO],
-    [EDeviceType.Pro2, 'react-native', true, DeviceType.PRO2],
-    [EDeviceType.Neo, 'react-native', true, DeviceType.NEO],
-    [EDeviceType.Pro2, 'lowlevel', false, DeviceType.PRO2],
-  ] as const)(
-    'refreshes %s runtime state after acquiring a fresh %s session',
-    async (deviceType, env, isBle, protocolV2DeviceType) => {
-      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
-      const device = createInitializedDevice('V2');
-      const staleProtocolInfo = {
-        version: 1,
-        build_fingerprint: 'bootloader__1.0.0__abcdef0__PROD__RELEASE',
-        supported_messages: [],
-      };
-      const freshProtocolInfo = {
-        version: 1,
-        build_fingerprint: 'application__5.0.0__abcdef0__PROD__RELEASE',
-        supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
-      };
-      device.updateState(
-        {
-          identity: { deviceType },
-          status: { mode: 'bootloader' },
-          raw: { protocolV2ProtocolInfo: staleProtocolInfo },
-        },
-        'initialize'
-      );
-      const acquire = jest
-        .fn()
-        .mockResolvedValue(isBle ? { uuid: 'fresh-session', protocolType: 'V2' } : 'fresh-session');
-      device.deviceConnector = { acquire } as never;
-
-      await device.acquire('V2', { throwOnRunPromiseError: true });
-      const typedCall = jest.fn().mockImplementation((requestType: string) => {
-        if (requestType === 'DeviceInfoGet') {
-          return {
-            message: {
-              protocol_version: 2,
-              hw: { Device_type: protocolV2DeviceType, serial_no: 'SERIAL-001' },
-              fw: { application: { version: '5.0.0' } },
-            },
-          };
-        }
-        if (requestType === 'ProtocolInfoRequest') {
-          return { message: freshProtocolInfo };
-        }
-        if (requestType === 'DeviceStatusGet') {
-          return {
-            message: { init_states: true, unlocked: true, device_id: 'wallet-device-id' },
-          };
-        }
-        throw new Error(`Unexpected request: ${requestType}`);
-      });
-      device.commands.typedCall = typedCall as never;
-
-      await device.initialize();
-
-      expect(typedCall.mock.calls.map(callArgs => callArgs[0])).toEqual([
-        'DeviceInfoGet',
-        'ProtocolInfoRequest',
-        'DeviceStatusGet',
-      ]);
-      expect(device.state?.status.mode).toBe('normal');
-      expect(device.state?.identity.deviceType).toBe(deviceType);
-      expect(device.hasDeviceAcquire()).toBe(true);
-    }
-  );
-
   test('exposes the current transport usage state in public device snapshots', () => {
     const getSettings = jest
       .spyOn(DataManager, 'getSettings')

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

@@ -38,35 +38,6 @@ describe('DevicePool state lifecycle', () => {
     expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['settings'] });
   });
 
-  test('keeps legacy ProtocolInfo compatibility scoped to a discovery refresh', async () => {
-    const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'bootloader' } });
-    const run = jest.fn(async (callback: () => Promise<void>) => callback());
-    const device = {
-      isProtocolV2: () => true,
-      getDeviceState,
-      run,
-    } as any;
-
-    await (DevicePool as any)._refreshRuntimeState(device, {
-      refreshRuntimeState: true,
-      allowLegacyProtocolV2ProtocolInfo: true,
-    });
-
-    expect(run).toHaveBeenCalledWith(expect.any(Function), {
-      connectProtocol: undefined,
-      forceProtocolDetection: undefined,
-      allowLegacyProtocolV2ProtocolInfo: true,
-    });
-    expect(getDeviceState).toHaveBeenNthCalledWith(1, {
-      refreshSections: ['status'],
-      allowLegacyProtocolV2ProtocolInfo: true,
-    });
-    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
-      refreshSections: ['settings'],
-      allowLegacyProtocolV2ProtocolInfo: true,
-    });
-  });
-
   test('actively re-detects a cached device when protocol detection is forced', async () => {
     const descriptor = { path: 'cached-path', protocolType: 'V1' } as any;
     const device = Device.fromDescriptor(descriptor);

package/__tests__/deviceUploadNft.test.ts

@@ -1,5 +1,4 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { encode as encodeJpeg } from 'jpeg-js';
 
 import DeviceUploadNft from '../src/api/protocol-v2/DeviceUploadNft';
 
@@ -14,19 +13,6 @@ const createRgba = (width: number, height: number) => {
   return data;
 };
 
-const jpegBase64Cache = new Map<string, string>();
-
-const createJpegBase64 = (width: number, height: number) => {
-  const key = `${width}x${height}`;
-  const cached = jpegBase64Cache.get(key);
-  if (cached) return cached;
-  const value = encodeJpeg({ width, height, data: createRgba(width, height) }, 80).data.toString(
-    'base64'
-  );
-  jpegBase64Cache.set(key, value);
-  return value;
-};
-
 const createMethod = ({
   typedCall,
   supportedMessages = [60802, 60805, 60808, 61500],
@@ -40,8 +26,8 @@ const createMethod = ({
     id: 1,
     payload: {
       method: 'deviceUploadNft',
-      imageJpegBase64: createJpegBase64(540, 540),
-      thumbnailJpegBase64: createJpegBase64(263, 263),
+      image: { width: 540, height: 540, rgba: createRgba(540, 540) },
+      thumbnail: { width: 263, height: 263, rgba: createRgba(263, 263) },
       title: 'CryptoPunk #3100',
       subtitle: 'CryptoPunks',
       timestampMs: 1_760_000_000_000,
@@ -100,8 +86,8 @@ describe('DeviceUploadNft', () => {
       id: 1,
       payload: {
         method: 'deviceUploadNft',
-        imageJpegBase64: createJpegBase64(540, 540),
-        thumbnailJpegBase64: createJpegBase64(263, 263),
+        image: { width: 540, height: 540, rgba: createRgba(540, 540) },
+        thumbnail: { width: 263, height: 263, rgba: createRgba(263, 263) },
         title: 'CryptoPunk #3100',
         subtitle: 'CryptoPunks',
         timestampMs: 1_760_000_000_000,
@@ -116,21 +102,6 @@ describe('DeviceUploadNft', () => {
     });
   });
 
-  test('rejects invalid image Base64 before device communication', () => {
-    const method = new DeviceUploadNft({
-      id: 1,
-      payload: {
-        method: 'deviceUploadNft',
-        imageJpegBase64: 'not-base64',
-        thumbnailJpegBase64: createJpegBase64(263, 263),
-        title: 'NFT',
-        subtitle: '',
-      },
-    });
-
-    expect(() => method.init()).toThrow('canonical Base64');
-  });
-
   test('uploads the triplet in order without creating the firmware-owned directory', async () => {
     const typedCall = jest.fn((request: string, _response: string, params: any) => {
       if (request === 'FilesystemPathInfoQuery') {

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

@@ -202,61 +202,25 @@ describe('getDeviceState', () => {
     expect(state.versions.se01).toBe('1.0.0');
   });
 
-  test.each([
-    ['bootloader', EDeviceType.Pro2, DeviceType.PRO2],
-    ['romloader', EDeviceType.Pro2, DeviceType.PRO2],
-    ['bootloader', EDeviceType.Neo, DeviceType.NEO],
-    ['romloader', EDeviceType.Neo, DeviceType.NEO],
-  ] as const)(
-    'refreshes cached %s state after %s reboots into the application',
-    async (mode, deviceType, protocolV2DeviceType) => {
+  test.each(['bootloader', 'romloader'] as const)(
+    'uses ProtocolInfo to preserve %s mode without DeviceStatusGet',
+    async mode => {
       const typedCall = jest.fn().mockImplementation((requestType: string) => {
-        if (requestType === 'ProtocolInfoRequest') {
-          return { message: protocolV2ApplicationInfo };
-        }
-        if (requestType === 'DeviceStatusGet') {
+        if (requestType === 'DeviceInfoGet') {
           return {
-            message: { init_states: true, unlocked: true, device_id: 'wallet-1' },
-          };
-        }
-        throw new Error(`Unexpected request: ${requestType}`);
-      });
-      const device = createV2Device(typedCall);
-      device.updateState(
-        {
-          protocol: 'V2',
-          identity: { deviceType },
-          status: { mode },
-          raw: {
-            protocolV2DeviceInfo: {
-              hw: { Device_type: protocolV2DeviceType, serial_no: 'SERIAL-1' },
+            message: {
+              hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
               fw:
                 mode === 'romloader'
                   ? { romloader: { version: '1.0.0' } }
                   : { bootloader: { version: '1.0.0' } },
             },
-            protocolV2ProtocolInfo: getProtocolV2LoaderInfo(mode),
-          },
-        },
-        'initialize'
-      );
-
-      const state = await device.getDeviceState({ refreshSections: ['status'] });
-
-      expect(state.status.mode).toBe('normal');
-      expect(state.identity.deviceId).toBe('wallet-1');
-      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-        'ProtocolInfoRequest',
-        'DeviceStatusGet',
-      ]);
-    }
-  );
-
-  test.each(['bootloader', 'romloader'] as const)(
-    'keeps live %s mode after refreshing cached loader state',
-    async mode => {
-      const typedCall = jest.fn().mockResolvedValue({
-        message: getProtocolV2LoaderInfo(mode),
+          };
+        }
+        if (requestType === 'ProtocolInfoRequest') {
+          return { message: getProtocolV2LoaderInfo(mode) };
+        }
+        throw new Error(`Unexpected request: ${requestType}`);
       });
       const device = createV2Device(typedCall);
       device.updateState(
@@ -272,10 +236,7 @@ describe('getDeviceState', () => {
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
       expect(state.status.mode).toBe(mode);
-      expect(typedCall).toHaveBeenCalledTimes(1);
-      expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
-        eventless_wallet_session: true,
-      });
+      expect(typedCall).not.toHaveBeenCalled();
     }
   );