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

package/__tests__/DeviceCommands.test.ts

@@ -19,12 +19,12 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
-  it('logs passphrase request and canonical response without exposing the passphrase', async () => {
+  it('logs passphrase call request and response without exposing the passphrase', async () => {
     const commands = createCommands();
-    const log = getLogger(LoggerNames.DeviceCommands);
-    const coreLog = getLogger(LoggerNames.Core);
-    log.messages.length = 0;
-    coreLog.messages.length = 0;
+    const requestLog = getLogger(LoggerNames.DeviceCommands);
+    const responseLog = getLogger(LoggerNames.Core);
+    requestLog.messages.length = 0;
+    responseLog.messages.length = 0;
     commands.mainId = 'main-id';
     commands.transport = {
       call: jest.fn().mockResolvedValue({
@@ -36,13 +36,13 @@ describe('DeviceCommands failure mapping', () => {
     } as any;
 
     await expect(
-      commands._commonCall('DeviceSessionAskPassphrase', {
+      commands.call('DeviceSessionAskPassphrase', {
         passphrase: 'hidden-wallet-secret',
         on_device: false,
       })
     ).resolves.toMatchObject({ type: 'Success' });
 
-    expect(log.messages.at(-2)?.message).toEqual([
+    expect(requestLog.messages.at(-1)?.message).toEqual([
       '[DeviceCommands] [call] Sending',
       'DeviceSessionAskPassphrase',
       {
@@ -50,27 +50,21 @@ describe('DeviceCommands failure mapping', () => {
         on_device: false,
       },
     ]);
-    expect(log.messages.at(-1)?.message).toEqual([
-      '_filterCommonTypes: ',
+    expect(responseLog.messages.at(-1)?.message).toEqual([
+      '[DeviceCommands] [call] Received',
+      'Success',
       {
-        request: 'DeviceSessionAskPassphrase',
-        response: {
-          type: 'Success',
-          message: {
-            message: 'Passphrase accepted',
-          },
-        },
+        message: 'Passphrase accepted',
       },
     ]);
-    expect(
-      coreLog.messages.some(entry => entry.message[0] === '[DeviceCommands] [call] Received')
-    ).toBe(false);
-    expect(JSON.stringify(log.messages)).not.toContain('hidden-wallet-secret');
+    expect(JSON.stringify([...requestLog.messages, ...responseLog.messages])).not.toContain(
+      'hidden-wallet-secret'
+    );
   });
 
-  it('logs canonical DeviceStatus response fields without exposing the device ID', async () => {
+  it('logs DeviceStatus response fields without exposing the device ID', async () => {
     const commands = createCommands();
-    const log = getLogger(LoggerNames.DeviceCommands);
+    const log = getLogger(LoggerNames.Core);
     log.messages.length = 0;
     commands.mainId = 'main-id';
     commands.transport = {
@@ -88,27 +82,22 @@ describe('DeviceCommands failure mapping', () => {
       }),
     } as any;
 
-    await expect(commands._commonCall('DeviceStatusGet', {})).resolves.toMatchObject({
+    await expect(commands.call('DeviceStatusGet', {})).resolves.toMatchObject({
       type: 'DeviceStatus',
     });
 
     const receivedLog = log.messages.at(-1)?.message;
     expect(receivedLog).toEqual([
-      '_filterCommonTypes: ',
+      '[DeviceCommands] [call] Received',
+      'DeviceStatus',
       {
-        request: 'DeviceStatusGet',
-        response: {
-          type: 'DeviceStatus',
-          message: {
-            device_id: '[REDACTED]',
-            unlocked: true,
-            init_states: true,
-            backup_required: false,
-            passphrase_enabled: true,
-            attach_to_pin_enabled: false,
-            unlocked_by_attach_to_pin: false,
-          },
-        },
+        device_id: '[REDACTED]',
+        unlocked: true,
+        init_states: true,
+        backup_required: false,
+        passphrase_enabled: true,
+        attach_to_pin_enabled: false,
+        unlocked_by_attach_to_pin: false,
       },
     ]);
     expect(JSON.stringify(receivedLog)).not.toContain('sensitive-device-id');
@@ -136,59 +125,6 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
-  it('logs the sanitized DeviceInfo response payload', async () => {
-    const commands = createCommands();
-    const log = getLogger(LoggerNames.DeviceCommands);
-    log.messages.length = 0;
-
-    await expect(
-      commands._filterCommonTypes(
-        {
-          type: 'DeviceInfo',
-          message: {
-            protocol_version: 2,
-            hw: {
-              Device_type: 7,
-              hardware_version: '1.0.0',
-            },
-            fw: {
-              application: {
-                version: '5.0.0',
-                build_id: '20260811',
-                hash: 'firmware-hash',
-              },
-            },
-          },
-        } as any,
-        'DeviceInfoGet'
-      )
-    ).resolves.toMatchObject({ type: 'DeviceInfo' });
-
-    expect(log.messages.at(-1)?.message).toEqual([
-      '_filterCommonTypes: ',
-      {
-        request: 'DeviceInfoGet',
-        response: {
-          type: 'DeviceInfo',
-          message: {
-            protocol_version: 2,
-            hw: {
-              Device_type: 7,
-              hardware_version: '1.0.0',
-            },
-            fw: {
-              application: {
-                version: '5.0.0',
-                build_id: '20260811',
-                hash: 'firmware-hash',
-              },
-            },
-          },
-        },
-      },
-    ]);
-  });
-
   it('logs the sanitized DeviceFirmwareUpdateStatus response payload', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);
@@ -625,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;
@@ -662,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__/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,31 +38,6 @@ describe('DevicePool state lifecycle', () => {
     expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['settings'] });
   });
 
-  test('refreshes Protocol V2 discovery state without legacy-specific options', 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,
-    });
-
-    expect(run).toHaveBeenCalledWith(expect.any(Function), {
-      connectProtocol: undefined,
-      forceProtocolDetection: undefined,
-    });
-    expect(getDeviceState).toHaveBeenNthCalledWith(1, {
-      refreshSections: ['status'],
-    });
-    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
-      refreshSections: ['settings'],
-    });
-  });
-
   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__/deviceSettings.test.ts

@@ -67,6 +67,7 @@ describe('Pro 2 device settings options', () => {
       { label: '2 minutes', valueMs: 120_000 },
       { label: '5 minutes', valueMs: 300_000 },
       { label: '10 minutes', valueMs: 600_000 },
+      { label: '30 minutes', valueMs: 1_800_000 },
       { label: 'Never', valueMs: PROTOCOL_V2_NEVER_TIMEOUT_MS },
     ]);
   });

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();
     }
   );
 

package/__tests__/logBlockEvent.test.ts

@@ -104,19 +104,7 @@ describe('getLogBlockLabel', () => {
     });
   });
 
-  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio'])(
-    'skips large Base64 resource payload logging for %s',
-    method => {
-      const request = { method, path: 'resource.bin', data: 'A'.repeat(1024 * 1024) };
-      expect(getLogBlockLabel(request)).toBe(method);
-      expect(getSafeLogPayload(request, method)).toEqual({
-        method,
-        payload: '[REDACTED]',
-      });
-    }
-  );
-
-  it.each(['fileWrite', 'fileRead'])(
+  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
     'keeps metadata and replaces binary payloads with their size for %s',
     method => {
       const request = { method, path: 'resource.bin', data: new Uint8Array(1024) };