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

package/__tests__/DeviceCommands.test.ts

@@ -19,12 +19,12 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
-  it('logs passphrase call request and response without exposing the passphrase', async () => {
+  it('logs passphrase request and canonical response without exposing the passphrase', async () => {
     const commands = createCommands();
-    const requestLog = getLogger(LoggerNames.DeviceCommands);
-    const responseLog = getLogger(LoggerNames.Core);
-    requestLog.messages.length = 0;
-    responseLog.messages.length = 0;
+    const log = getLogger(LoggerNames.DeviceCommands);
+    const coreLog = getLogger(LoggerNames.Core);
+    log.messages.length = 0;
+    coreLog.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.call('DeviceSessionAskPassphrase', {
+      commands._commonCall('DeviceSessionAskPassphrase', {
         passphrase: 'hidden-wallet-secret',
         on_device: false,
       })
     ).resolves.toMatchObject({ type: 'Success' });
 
-    expect(requestLog.messages.at(-1)?.message).toEqual([
+    expect(log.messages.at(-2)?.message).toEqual([
       '[DeviceCommands] [call] Sending',
       'DeviceSessionAskPassphrase',
       {
@@ -50,21 +50,69 @@ describe('DeviceCommands failure mapping', () => {
         on_device: false,
       },
     ]);
-    expect(responseLog.messages.at(-1)?.message).toEqual([
-      '[DeviceCommands] [call] Received',
-      'Success',
+    expect(log.messages.at(-1)?.message).toEqual([
+      '_filterCommonTypes: ',
+      {
+        request: 'DeviceSessionAskPassphrase',
+        response: {
+          type: 'Success',
+          message: {
+            message: 'Passphrase accepted',
+          },
+        },
+      },
+    ]);
+    expect(
+      coreLog.messages.some(entry => entry.message[0] === '[DeviceCommands] [call] Received')
+    ).toBe(false);
+    expect(JSON.stringify([...log.messages, ...coreLog.messages])).not.toContain(
+      'hidden-wallet-secret'
+    );
+  });
+
+  it('redacts passphrases from transport errors logged through Core', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.DeviceCommands);
+    const coreLog = getLogger(LoggerNames.Core);
+    log.messages.length = 0;
+    coreLog.messages.length = 0;
+    const transportError = Object.assign(new Error('transport failed'), {
+      response: {
+        data: {
+          passphrase: 'hidden-wallet-secret',
+        },
+      },
+    });
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockRejectedValue(transportError),
+    } as any;
+
+    await expect(
+      commands._commonCall('DeviceSessionAskPassphrase', {
+        passphrase: 'hidden-wallet-secret',
+        on_device: false,
+      })
+    ).rejects.toBe(transportError);
+
+    expect(coreLog.messages.at(-1)?.message).toEqual([
+      '[DeviceCommands] [call] Received error',
       {
-        message: 'Passphrase accepted',
+        request: 'DeviceSessionAskPassphrase',
+        errorCode: undefined,
+        response: {
+          passphrase: '[REDACTED]',
+        },
       },
     ]);
-    expect(JSON.stringify([...requestLog.messages, ...responseLog.messages])).not.toContain(
+    expect(JSON.stringify([...log.messages, ...coreLog.messages])).not.toContain(
       'hidden-wallet-secret'
     );
   });
 
-  it('logs DeviceStatus response fields without exposing the device ID', async () => {
+  it('logs canonical DeviceStatus response fields without exposing the device ID', async () => {
     const commands = createCommands();
-    const log = getLogger(LoggerNames.Core);
+    const log = getLogger(LoggerNames.DeviceCommands);
     log.messages.length = 0;
     commands.mainId = 'main-id';
     commands.transport = {
@@ -82,22 +130,27 @@ describe('DeviceCommands failure mapping', () => {
       }),
     } as any;
 
-    await expect(commands.call('DeviceStatusGet', {})).resolves.toMatchObject({
+    await expect(commands._commonCall('DeviceStatusGet', {})).resolves.toMatchObject({
       type: 'DeviceStatus',
     });
 
     const receivedLog = log.messages.at(-1)?.message;
     expect(receivedLog).toEqual([
-      '[DeviceCommands] [call] Received',
-      'DeviceStatus',
+      '_filterCommonTypes: ',
       {
-        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,
+        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,
+          },
+        },
       },
     ]);
     expect(JSON.stringify(receivedLog)).not.toContain('sensitive-device-id');
@@ -125,6 +178,59 @@ 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);
@@ -561,17 +667,22 @@ describe('DeviceCommands failure mapping', () => {
 });
 
 describe('DeviceCommands Protocol V2 interactive response compatibility', () => {
-  it('still auto-acks ButtonRequest when no hardware UI listener is registered', async () => {
+  it('auto-acks Pro2 ButtonRequest and registers Cancel instead of Initialize', 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: jest.fn(),
+      setCancelableAction,
       emit,
       listenerCount: jest.fn(() => 0),
     } as any;
@@ -593,6 +704,9 @@ 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__/base64Data.test.ts

@@ -0,0 +1,70 @@
+import { Buffer } from 'buffer';
+
+import { encode as encodeJpeg } from 'jpeg-js';
+
+import { decodeCanonicalBase64, decodeJpegBase64ToRgba } from '../src/api/helpers/base64Data';
+
+const createJpegBase64 = (width: number, height: number) => {
+  const rgba = new Uint8Array(width * height * 4).fill(0xff);
+  return encodeJpeg({ width, height, data: rgba }, 80).data.toString('base64');
+};
+
+describe('Base64 resource data', () => {
+  test('decodes canonical Base64 to a detached Uint8Array', () => {
+    const decoded = decodeCanonicalBase64({
+      value: 'AQID',
+      parameterName: 'packageBase64',
+      maxBytes: 3,
+    });
+
+    expect(decoded).toBeInstanceOf(Uint8Array);
+    expect(Array.from(decoded)).toEqual([1, 2, 3]);
+  });
+
+  test.each(['', 'not-base64', 'AB==', 'data:image/jpeg;base64,AQID'])(
+    'rejects non-canonical Base64 input %p',
+    value => {
+      expect(() =>
+        decodeCanonicalBase64({ value, parameterName: 'data', maxBytes: 1024 })
+      ).toThrow();
+    }
+  );
+
+  test('rejects oversized Base64 before decoding', () => {
+    const value = Buffer.alloc(64 * 1024 + 17).toString('base64');
+    expect(() =>
+      decodeCanonicalBase64({ value, parameterName: 'data', maxBytes: 64 * 1024 })
+    ).toThrow('maximum supported size');
+  });
+
+  test('decodes and validates a JPEG with the expected dimensions', () => {
+    const decoded = decodeJpegBase64ToRgba({
+      jpegBase64: createJpegBase64(2, 1),
+      parameterName: 'jpegBase64',
+      expectedWidth: 2,
+      expectedHeight: 1,
+    });
+
+    expect(decoded).toMatchObject({ width: 2, height: 1 });
+    expect(decoded.data).toHaveLength(8);
+  });
+
+  test('rejects non-JPEG bytes and unexpected dimensions', () => {
+    expect(() =>
+      decodeJpegBase64ToRgba({
+        jpegBase64: 'AQID',
+        parameterName: 'jpegBase64',
+        expectedWidth: 2,
+        expectedHeight: 1,
+      })
+    ).toThrow('JPEG image');
+    expect(() =>
+      decodeJpegBase64ToRgba({
+        jpegBase64: createJpegBase64(2, 1),
+        parameterName: 'jpegBase64',
+        expectedWidth: 1,
+        expectedHeight: 1,
+      })
+    ).toThrow('1x1');
+  });
+});

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

@@ -1,12 +1,14 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceType, 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';
@@ -271,6 +273,115 @@ 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,6 +38,31 @@ 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,7 +67,6 @@ 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,4 +1,5 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { encode as encodeJpeg } from 'jpeg-js';
 
 import DeviceUploadNft from '../src/api/protocol-v2/DeviceUploadNft';
 
@@ -13,6 +14,19 @@ 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],
@@ -26,8 +40,8 @@ const createMethod = ({
     id: 1,
     payload: {
       method: 'deviceUploadNft',
-      image: { width: 540, height: 540, rgba: createRgba(540, 540) },
-      thumbnail: { width: 263, height: 263, rgba: createRgba(263, 263) },
+      imageJpegBase64: createJpegBase64(540, 540),
+      thumbnailJpegBase64: createJpegBase64(263, 263),
       title: 'CryptoPunk #3100',
       subtitle: 'CryptoPunks',
       timestampMs: 1_760_000_000_000,
@@ -86,8 +100,8 @@ describe('DeviceUploadNft', () => {
       id: 1,
       payload: {
         method: 'deviceUploadNft',
-        image: { width: 540, height: 540, rgba: createRgba(540, 540) },
-        thumbnail: { width: 263, height: 263, rgba: createRgba(263, 263) },
+        imageJpegBase64: createJpegBase64(540, 540),
+        thumbnailJpegBase64: createJpegBase64(263, 263),
         title: 'CryptoPunk #3100',
         subtitle: 'CryptoPunks',
         timestampMs: 1_760_000_000_000,
@@ -102,6 +116,21 @@ 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') {