@onekeyfe/hd-core 1.2.0-alpha.101 → 1.2.0-alpha.103

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__/check-all-firmware-release-protocol-v2.test.ts

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

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

@@ -38,6 +38,35 @@ 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,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') {

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

@@ -202,25 +202,111 @@ describe('getDeviceState', () => {
     expect(state.versions.se01).toBe('1.0.0');
   });
 
-  test.each(['bootloader', 'romloader'] as const)(
-    'uses ProtocolInfo to preserve %s mode without DeviceStatusGet',
-    async mode => {
+  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) => {
       const typedCall = jest.fn().mockImplementation((requestType: string) => {
-        if (requestType === 'DeviceInfoGet') {
+        if (requestType === 'ProtocolInfoRequest') {
+          return { message: protocolV2ApplicationInfo };
+        }
+        if (requestType === 'DeviceStatusGet') {
           return {
-            message: {
-              hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
+            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' },
               fw:
                 mode === 'romloader'
                   ? { romloader: { version: '1.0.0' } }
                   : { bootloader: { version: '1.0.0' } },
             },
-          };
-        }
-        if (requestType === 'ProtocolInfoRequest') {
-          return { message: getProtocolV2LoaderInfo(mode) };
-        }
-        throw new Error(`Unexpected request: ${requestType}`);
+            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([
+    [EDeviceType.Pro2, DeviceType.PRO2],
+    [EDeviceType.Neo, DeviceType.NEO],
+  ] as const)('invalidates cached loader state when %s is cancelled', async (deviceType, type) => {
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            protocol_version: 2,
+            hw: { Device_type: type, serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0' } },
+          },
+        };
+      }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
+      if (requestType === 'DeviceStatusGet') {
+        return {
+          message: { init_states: true, unlocked: true, device_id: 'wallet-1' },
+        };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const cancel = jest.fn().mockResolvedValue(undefined);
+    const device = createV2Device(typedCall);
+    (device as any).commands = { cancel, typedCall };
+    device.updateState(
+      {
+        protocol: 'V2',
+        identity: { deviceType },
+        status: { mode: 'bootloader' },
+        raw: { protocolV2ProtocolInfo: getProtocolV2LoaderInfo('bootloader') },
+      },
+      'initialize'
+    );
+
+    await device.interruptionFromUser();
+    await device.initialize();
+
+    expect(cancel).toHaveBeenCalledTimes(1);
+    expect(device.state?.status.mode).toBe('normal');
+    expect(device.state?.identity.deviceId).toBe('wallet-1');
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceInfoGet',
+      '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),
       });
       const device = createV2Device(typedCall);
       device.updateState(
@@ -236,7 +322,10 @@ describe('getDeviceState', () => {
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
       expect(state.status.mode).toBe(mode);
-      expect(typedCall).not.toHaveBeenCalled();
+      expect(typedCall).toHaveBeenCalledTimes(1);
+      expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+        eventless_wallet_session: true,
+      });
     }
   );
 

package/__tests__/protocol-v2-legacy-recovery.test.ts

@@ -0,0 +1,29 @@
+import { isLegacyProtocolV2FirmwareRecoveryMethod } from '../src/core/protocolV2LegacyRecovery';
+
+import type { BaseMethod } from '../src/api/BaseMethod';
+
+const createMethod = (
+  name: string,
+  payload: Record<string, unknown>
+): Pick<BaseMethod, 'name' | 'payload'> => ({
+  name,
+  payload: { method: name, ...payload },
+});
+
+describe('Protocol V2 legacy firmware recovery policy', () => {
+  test.each([
+    ['firmware state read', 'getDeviceState', { scope: 'firmware' }],
+    ['firmware release check', 'checkAllFirmwareRelease', {}],
+    ['firmware update', 'firmwareUpdateV4', {}],
+  ])('allows legacy ProtocolInfo for %s', (_label, name, payload) => {
+    expect(isLegacyProtocolV2FirmwareRecoveryMethod(createMethod(name, payload))).toBe(true);
+  });
+
+  test.each([
+    ['runtime state read', 'getDeviceState', { scope: 'runtime' }],
+    ['settings state read', 'getDeviceState', { scope: 'settings' }],
+    ['ordinary API', 'getFeatures', {}],
+  ])('rejects legacy ProtocolInfo for %s', (_label, name, payload) => {
+    expect(isLegacyProtocolV2FirmwareRecoveryMethod(createMethod(name, payload))).toBe(false);
+  });
+});