@onekeyfe/hd-core 1.2.0-alpha.67 → 1.2.0-alpha.68

package/__tests__/device-utils.test.ts

@@ -1,10 +1,13 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { DeviceType } from '@onekeyfe/hd-transport';
 
 import {
   getDeviceSerialNo,
   getDeviceType,
+  getDeviceTypeByBleName,
   getDeviceUUID,
   getFirmwareType,
+  getMethodVersionRange,
 } from '../src/utils/deviceInfoUtils';
 import {
   getDeviceBLEFirmwareVersion,
@@ -85,7 +88,7 @@ describe('device feature selectors', () => {
   test('reads normalized Protocol V2 features through the same public selectors', () => {
     const features = buildProtocolV2FeaturesPayload({
       deviceInfo: {
-        hw: { serial_no: 'P2-001' },
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'P2-001' },
         fw: {
           application: { version: '5.0.0' },
           bootloader: { version: '2.0.0' },
@@ -104,4 +107,48 @@ describe('device feature selectors', () => {
     expect(getDeviceBoardloaderVersion(features)).toEqual([1, 0, 0]);
     expect(getDeviceBLEFirmwareVersion(features)).toEqual([3, 0, 0]);
   });
+
+  test('preserves the real Neo type in Protocol V2 compatibility features', () => {
+    const features = buildProtocolV2FeaturesPayload({
+      deviceInfo: {
+        hw: { Device_type: DeviceType.NEO, serial_no: 'NEO-001' },
+      },
+    });
+
+    expect(features.deviceType).toBe(EDeviceType.Neo);
+    expect(features.onekey_device_type).toBe('NEO');
+    expect(getDeviceType(features)).toBe(EDeviceType.Neo);
+  });
+
+  test('recognizes Neo discovery names before initialization', () => {
+    expect(getDeviceTypeByBleName('OneKey Neo 1234')).toBe(EDeviceType.Neo);
+    expect(getDeviceTypeByBleName('Neo 1234')).toBe(EDeviceType.Neo);
+  });
+
+  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
+    'uses the Pro2 product model as the chain capability fallback for %s',
+    deviceType => {
+      const checkedTypes: string[] = [];
+      const versionRange = getMethodVersionRange({ deviceType } as PROTO.Features, type => {
+        checkedTypes.push(type);
+        return type === 'model_pro2' ? { min: '1.0.0' } : undefined;
+      });
+
+      expect(versionRange).toEqual({ min: '1.0.0' });
+      expect(checkedTypes).toEqual([deviceType, 'model_pro2']);
+    }
+  );
+
+  test('prefers a Neo-specific chain range over the shared Pro2 product model', () => {
+    const versionRange = getMethodVersionRange(
+      { deviceType: EDeviceType.Neo } as PROTO.Features,
+      type => {
+        if (type === EDeviceType.Neo) return { min: '2.0.0' };
+        if (type === 'model_pro2') return { min: '1.0.0' };
+        return undefined;
+      }
+    );
+
+    expect(versionRange).toEqual({ min: '2.0.0' });
+  });
 });

package/__tests__/deviceSettings.test.ts

@@ -1,13 +1,13 @@
 import { EDeviceType } from '@onekeyfe/hd-shared';
 
 import {
+  PROTOCOL_V2_NEVER_TIMEOUT_MS,
   getAutoLockOptions,
   getAutoShutDownOptions,
   getDeviceSettingsCapabilities,
   getLanguageConfig,
   mapLanguageFromProtocolV2,
   mapLanguageToProtocolV2,
-  PROTOCOL_V2_NEVER_TIMEOUT_MS,
 } from '../src/utils/deviceSettings';
 
 describe('Pro 2 device settings options', () => {
@@ -72,6 +72,16 @@ describe('Pro 2 device settings options', () => {
     ]);
   });
 
+  test('uses the shared Protocol V2 settings model for Neo', () => {
+    expect(getLanguageConfig(EDeviceType.Neo)).toEqual(getLanguageConfig(EDeviceType.Pro2));
+    expect(getAutoLockOptions(EDeviceType.Neo, 'V2')).toEqual(
+      getAutoLockOptions(EDeviceType.Pro2, 'V2')
+    );
+    expect(getAutoShutDownOptions(EDeviceType.Neo, 'V2')).toEqual(
+      getAutoShutDownOptions(EDeviceType.Pro2, 'V2')
+    );
+  });
+
   test('keeps the legacy and Protocol V2 never values protocol-specific', () => {
     expect(getAutoLockOptions(EDeviceType.Pro, 'V1').slice(-1)[0]).toEqual({
       label: 'Never',

package/__tests__/deviceUploadNft.test.ts

@@ -0,0 +1,316 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import DeviceUploadNft from '../src/api/protocol-v2/DeviceUploadNft';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+const createRgba = (width: number, height: number) => {
+  const data = new Uint8Array(width * height * 4);
+  for (let index = 3; index < data.length; index += 4) data[index] = 0xff;
+  return data;
+};
+
+const createMethod = ({
+  typedCall,
+  supportedMessages = [60802, 60805, 60808, 61500],
+  useFullBundle = false,
+}: {
+  typedCall: jest.Mock;
+  supportedMessages?: number[];
+  useFullBundle?: boolean;
+}) => {
+  const method = new DeviceUploadNft({
+    id: 1,
+    payload: {
+      method: 'deviceUploadNft',
+      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,
+      chunkSize: 2048,
+      paceMs: 0,
+    },
+  });
+  (method as any).device = {
+    commands: { typedCall },
+    ensureProtocolV2RuntimeContext: jest.fn(() =>
+      Promise.resolve({
+        version: 2,
+        build_fingerprint: 'application__1.0.0__test__DEV__DEBUG',
+        supported_messages: supportedMessages,
+      })
+    ),
+    getCurrentFirmwareType: jest.fn(),
+  };
+  method.postMessage = jest.fn();
+
+  if (useFullBundle) {
+    method.init();
+  } else {
+    (method as any).params = { chunkSize: 2048, paceMs: 0, timeoutMs: 15_000 };
+    (method as any).bundle = {
+      basename: 'nft-deadbeef-1760000000000',
+      image: new Uint8Array([1]),
+      thumbnail: new Uint8Array([2]),
+      metadata: new TextEncoder().encode('{"title":"NFT","subtitle":""}'),
+    };
+  }
+
+  return method;
+};
+
+const fileWriteSuccess = (params: { file: { offset: number; data: Uint8Array } }) => ({
+  message: {
+    processed_byte: params.file.offset + params.file.data.byteLength,
+  },
+});
+
+const nftFileList = (count: number, basenameAt?: number) =>
+  Array.from({ length: count }, (_, index) => {
+    const basename =
+      index === basenameAt
+        ? 'nft-deadbeef-1760000000000'
+        : `nft-${index.toString(16).padStart(8, '0')}-${1760000000001 + index}`;
+    return [`${basename}.bin`, `${basename}_m.bin`, `${basename}.json`];
+  })
+    .flat()
+    .join('\n');
+
+describe('DeviceUploadNft', () => {
+  test('defaults to maximum-size chunks without artificial pacing', () => {
+    const method = new DeviceUploadNft({
+      id: 1,
+      payload: {
+        method: 'deviceUploadNft',
+        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,
+      },
+    });
+
+    method.init();
+
+    expect((method as any).params).toMatchObject({
+      chunkSize: 2048,
+      paceMs: 0,
+    });
+  });
+
+  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') {
+        return { message: { exist: true, directory: true } };
+      }
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: { message: 'NFT updated' } };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall, useFullBundle: true });
+
+    const result = await method.run();
+
+    const requests = typedCall.mock.calls.map(call => call[0]);
+    expect(requests[0]).toBe('FilesystemPathInfoQuery');
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'FilesystemPathInfoQuery',
+      'FilesystemPathInfo',
+      { path: 'vol1:/nft' },
+      { timeoutMs: 15_000 }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'FilesystemDirList',
+      'FilesystemDir',
+      { path: 'vol1:/nft', depth: 1 },
+      { timeoutMs: 15_000 }
+    );
+    expect(requests).not.toContain('FilesystemDirMake');
+    expect(requests.at(-1)).toBe('NftUpdate');
+    const fileWrites = typedCall.mock.calls.filter(call => call[0] === 'FilesystemFileWrite');
+    const paths = fileWrites.map(call => call[2].file.path as string);
+    const imagePath = paths[0];
+    const thumbnailStart = paths.findIndex(path => path.endsWith('_m.bin'));
+    const metadataStart = paths.findIndex(path => path.endsWith('.json'));
+    expect(imagePath).toMatch(/^vol1:\/nft\/nft-[a-f0-9]{8}-1760000000000\.bin$/);
+    expect(thumbnailStart).toBeGreaterThan(0);
+    expect(metadataStart).toBeGreaterThan(thumbnailStart);
+    expect(new Set(paths.slice(0, thumbnailStart))).toEqual(new Set([imagePath]));
+    expect(new Set(paths.slice(thumbnailStart, metadataStart))).toEqual(
+      new Set([result.thumbnailPath])
+    );
+    expect(typedCall).toHaveBeenLastCalledWith(
+      'NftUpdate',
+      'Success',
+      { file_name_no_ext: result.basename },
+      { timeoutMs: 15_000 }
+    );
+    expect(result).toMatchObject({
+      nftUpdated: true,
+      message: 'NFT updated',
+      totalSize: 583_212 + 138_876 + 53,
+    });
+    expect(method.postMessage).toHaveBeenLastCalledWith({
+      event: 'UI_EVENT',
+      type: 'ui-device_progress',
+      payload: expect.objectContaining({
+        progress: 100,
+        transferredBytes: result.totalSize,
+        totalBytes: result.totalSize,
+      }),
+    });
+  });
+
+  test('treats a missing NFT directory as empty before the first upload', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemPathInfoQuery') {
+        return { message: { exist: false, directory: false } };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: { message: 'NFT updated' } };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
+    expect(typedCall.mock.calls.map(call => call[0])).not.toContain('FilesystemDirList');
+    expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileWrite')).toBe(true);
+  });
+
+  test('does not retry a timed-out NftUpdate', async () => {
+    const timeout = Object.assign(new Error('Protocol V2 response timeout'), {
+      code: 'response-timeout',
+    });
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemPathInfoQuery') {
+        return { message: { exist: true, directory: true } };
+      }
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') throw timeout;
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).rejects.toBe(timeout);
+
+    const updateRequests = typedCall.mock.calls.filter(call => call[0] === 'NftUpdate');
+    expect(updateRequests).toHaveLength(1);
+  });
+
+  test('does not retry a non-timeout NftUpdate failure', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemPathInfoQuery') {
+        return { message: { exist: true, directory: true } };
+      }
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') throw new Error('Invalid NFT metadata');
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).rejects.toThrow('Invalid NFT metadata');
+    expect(typedCall.mock.calls.filter(call => call[0] === 'NftUpdate')).toHaveLength(1);
+  });
+
+  test('does not publish when a file write fails', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'FilesystemPathInfoQuery') {
+        return { message: { exist: true, directory: true } };
+      }
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
+      if (request === 'FilesystemFileWrite') throw new Error('Filesystem full');
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).rejects.toThrow('Filesystem full');
+    expect(typedCall.mock.calls.some(call => call[0] === 'NftUpdate')).toBe(false);
+  });
+
+  test('rejects unsupported firmware before writing files', async () => {
+    const typedCall = jest.fn();
+    const method = createMethod({ typedCall, supportedMessages: [60805] });
+
+    await expect(method.run()).rejects.toBeDefined();
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  test('rejects a new NFT before writing when ten complete NFT bundles exist', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'FilesystemPathInfoQuery') {
+        return { message: { exist: true, directory: true } };
+      }
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: nftFileList(10) } };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.NftStorageLimitReached,
+      params: { count: 10, limit: 10 },
+    });
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'FilesystemPathInfoQuery',
+      'FilesystemDirList',
+    ]);
+  });
+
+  test('allows an idempotent retry for a basename already counted at the limit', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemPathInfoQuery') {
+        return { message: { exist: true, directory: true } };
+      }
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: nftFileList(10, 0) } };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: {} };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
+    expect(typedCall.mock.calls.some(call => call[0] === 'FilesystemFileWrite')).toBe(true);
+  });
+
+  test('does not count unrelated or incomplete files as stored NFTs', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemPathInfoQuery') {
+        return { message: { exist: true, directory: true } };
+      }
+      if (request === 'FilesystemDirList') {
+        return {
+          message: {
+            path: 'vol1:/nft',
+            child_files: `${nftFileList(9)}\nnft-ffffffff-1760000009999.json\nnotes.txt`,
+          },
+        };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: {} };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
+  });
+});

package/__tests__/firmware-update/firmware-update-v3-reconnect.test.ts

@@ -34,6 +34,11 @@ describe('FirmwareUpdateV3 reconnect', () => {
     });
     method.isBleReconnect = jest.fn(() => false);
     method.device = {
+      originalDescriptor: {
+        id: 'usb-path',
+        path: 'usb-path',
+        protocolType: 'V1',
+      },
       deviceConnector: {
         enumerate: jest.fn().mockResolvedValue({
           descriptors: [{ path: 'usb-path' }],

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

@@ -1,4 +1,4 @@
-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';
@@ -43,6 +43,70 @@ const getProtocolV2LoaderInfo = (mode: 'bootloader' | 'romloader') => ({
 });
 
 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');
@@ -159,15 +223,20 @@ describe('getDeviceState', () => {
         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(mode);
-      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-        'DeviceInfoGet',
-        'ProtocolInfoRequest',
-      ]);
+      expect(typedCall).not.toHaveBeenCalled();
     }
   );
 
@@ -187,7 +256,14 @@ describe('getDeviceState', () => {
       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'] });
 
@@ -205,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);
 
@@ -250,13 +333,18 @@ describe('getDeviceState', () => {
       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',
-      'ProtocolInfoRequest',
       'DeviceStatusGet',
       'DeviceSettingsGet',
     ]);
@@ -288,7 +376,11 @@ describe('getDeviceState', () => {
     });
     const device = createV2Device(typedCall);
     device.updateState(
-      { protocol: 'V2', status: { mode: 'normal', unlocked: true } },
+      {
+        protocol: 'V2',
+        status: { mode: 'normal', unlocked: true },
+        raw: { protocolV2ProtocolInfo: protocolV2ApplicationInfo },
+      },
       'initialize'
     );
 
@@ -374,6 +466,34 @@ describe('getDeviceState', () => {
     });
   });
 
+  test.each([
+    EDeviceType.Classic,
+    EDeviceType.Classic1s,
+    EDeviceType.ClassicPure,
+    EDeviceType.Mini,
+  ])('keeps the GetFeatures-only firmware path for %s', async deviceType => {
+    const typedCall = jest.fn().mockResolvedValue({
+      message: {
+        onekey_device_type: deviceType.toUpperCase(),
+        initialized: true,
+        onekey_firmware_version: '3.5.0',
+        se_ver: '1.1.0.2',
+      },
+    });
+    const device = createV1Device(typedCall);
+
+    const state = await device.getDeviceState({
+      refreshSections: ['identity', 'versions', 'verification'],
+    });
+
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['GetFeatures']);
+    expect(state.versions).toMatchObject({
+      firmware: '3.5.0',
+      se: '1.1.0.2',
+      se01: '1.1.0.2',
+    });
+  });
+
   test('does not clear Protocol V1 firmware details during a later runtime refresh', async () => {
     let getFeaturesCount = 0;
     const typedCall = jest.fn().mockImplementation((requestType: string) => {

package/__tests__/homescreen.test.ts

@@ -1,6 +1,6 @@
 import { EDeviceType } from '@onekeyfe/hd-shared';
 
-import { getHomeScreenSize } from '../src/utils/homescreen';
+import { getHomeScreenSize, getNftSize } from '../src/utils/homescreen';
 
 describe('getHomeScreenSize', () => {
   it('returns the Pro 2 wallpaper dimensions', () => {
@@ -21,4 +21,44 @@ describe('getHomeScreenSize', () => {
       })
     ).toBeUndefined();
   });
+
+  it('does not reuse the wallpaper homeScreenType for Pro 2 NFT dimensions', () => {
+    expect(
+      getHomeScreenSize({
+        deviceType: EDeviceType.Pro2,
+        homeScreenType: 'Nft',
+        thumbnail: false,
+      })
+    ).toEqual({ width: 604, height: 1024 });
+    expect(
+      getHomeScreenSize({
+        deviceType: EDeviceType.Pro2,
+        homeScreenType: 'Nft',
+        thumbnail: true,
+      })
+    ).toBeUndefined();
+  });
+});
+
+describe('getNftSize', () => {
+  it('returns the Pro 2 NFT image and thumbnail dimensions independently', () => {
+    expect(getNftSize({ deviceType: EDeviceType.Pro2 })).toEqual({ width: 540, height: 540 });
+    expect(getNftSize({ deviceType: EDeviceType.Pro2, thumbnail: true })).toEqual({
+      width: 263,
+      height: 263,
+    });
+  });
+
+  it('preserves the legacy NFT dimensions', () => {
+    expect(getNftSize({ deviceType: EDeviceType.Touch })).toEqual({ width: 480, height: 800 });
+    expect(getNftSize({ deviceType: EDeviceType.Touch, thumbnail: true })).toEqual({
+      width: 238,
+      height: 238,
+    });
+    expect(getNftSize({ deviceType: EDeviceType.Pro, thumbnail: true })).toEqual({
+      width: 226,
+      height: 226,
+      radius: 40,
+    });
+  });
 });