@onekeyfe/hd-core 1.2.0-alpha.64 → 1.2.0-alpha.66

package/__tests__/device-settings.test.ts

@@ -115,8 +115,8 @@ describe('DeviceSettings protocol routing', () => {
     );
   });
 
-  it('uses DeviceSettingsSet and commits the confirmed patch for Protocol V2', async () => {
-    const { device, typedCall, updateState } = createDevice({ protocol: 'V2' });
+  it('uses DeviceSettingsSet and reloads Protocol V2 status and settings from the device', async () => {
+    const { device, typedCall, updateState, getDeviceState } = createDevice({ protocol: 'V2' });
     const method = new DeviceSettings({
       id: 2,
       payload: {
@@ -141,21 +141,10 @@ describe('DeviceSettings protocol routing', () => {
         haptic_feedback: true,
       },
     });
-    expect(updateState).toHaveBeenCalledWith(
-      {
-        identity: { label: 'Shared Label' },
-        settings: {
-          language: 'ja',
-          bleEnabled: true,
-          autoLockDelayMs: 60_000,
-          hapticFeedback: true,
-        },
-      },
-      'settings-write'
-    );
-    expect(typedCall.mock.calls.map(call => call[0])).not.toEqual(
-      expect.arrayContaining(['DeviceInfoGet', 'DeviceStatusGet', 'DeviceSettingsGet'])
-    );
+    expect(getDeviceState).toHaveBeenCalledWith({
+      refreshSections: ['status', 'settings'],
+    });
+    expect(updateState).not.toHaveBeenCalled();
   });
 
   it('uses the Pro2 passphrase page as a device-side toggle and verifies the target state', async () => {
@@ -183,7 +172,39 @@ describe('DeviceSettings protocol routing', () => {
     });
     expect(typedCall).not.toHaveBeenCalledWith('DeviceSettingsSet', 'Success', expect.anything());
     expect(getDeviceState).toHaveBeenNthCalledWith(1, { refreshSections: ['status'] });
-    expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['status'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['status', 'settings'],
+    });
+  });
+
+  it('reloads Protocol V2 status and settings after changing air-gap mode', async () => {
+    const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState
+      .mockResolvedValueOnce({
+        settings: { airgapMode: false },
+      })
+      .mockResolvedValueOnce({
+        status: { unlocked: true },
+        settings: { airgapMode: true },
+      });
+    const method = new DeviceSettings({
+      id: 4,
+      payload: {
+        method: 'deviceSettings',
+        airgapMode: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
+      page: DeviceSettingsPage.DeviceAirgap,
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, { refreshSections: ['settings'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['status', 'settings'],
+    });
   });
 
   it('does not open a Pro2 settings page when the hardware already matches the target', async () => {

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

@@ -1,4 +1,5 @@
 import { DEVICE } from '../src/events';
+
 import type { DeviceState, DeviceStateEvent } from '../src/types';
 
 describe('DeviceState contract', () => {

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

@@ -1,6 +1,6 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
-
 import { DeviceType, Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+
 import {
   mapApplySettingsToState,
   mapDeviceSettingsToState,
@@ -145,6 +145,18 @@ describe('DeviceStateMapper', () => {
     expect(patch.status?.unlocked).toBeUndefined();
   });
 
+  test('maps the Protocol V2 Neo device type without treating it as Pro2', () => {
+    const patch = mapProtocolV2DeviceInfoToState({
+      hw: { Device_type: DeviceType.NEO, serial_no: 'NEO-SERIAL-1' },
+    });
+
+    expect(patch.identity).toMatchObject({
+      deviceType: EDeviceType.Neo,
+      model: 'neo',
+      serialNo: 'NEO-SERIAL-1',
+    });
+  });
+
   test('maps the hardware model independently from Protocol V2', () => {
     const pro = mapProtocolV2DeviceInfoToState({
       protocol_version: 2,

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