@onekeyfe/hd-core 1.2.0-alpha.19 → 1.2.0-alpha.20

package/__tests__/deviceSettings.test.ts

@@ -4,23 +4,24 @@ import {
   getAutoLockOptions,
   getAutoShutDownOptions,
   getLanguageConfig,
+  mapLanguageToProtocolV2,
 } from '../src/utils/deviceSettings';
 
 describe('Pro 2 device settings options', () => {
-  test('returns the firmware-supported BCP-47 languages', () => {
+  test('returns stable SDK keys plus Pro2-only BCP-47 languages', () => {
     expect(getLanguageConfig(EDeviceType.Pro2)).toEqual([
-      { code: 'en-Latn-US', label: 'English' },
-      { code: 'zh-Hans-CN', label: '简体中文' },
-      { code: 'zh-Hant-HK', label: '繁體中文（香港）' },
+      { code: 'en', label: 'English' },
+      { code: 'zh_cn', label: '简体中文' },
+      { code: 'zh_hk', label: '繁體中文' },
+      { code: 'ja', label: '日本語' },
+      { code: 'ko', label: '한국어' },
+      { code: 'fr', label: 'Français' },
+      { code: 'de', label: 'Deutsch' },
+      { code: 'ru', label: 'Russian' },
+      { code: 'es', label: 'Spanish' },
+      { code: 'it', label: 'Italiano' },
+      { code: 'pt_br', label: 'Portuguese (Brazil)' },
       { code: 'zh-Hant-TW', label: '繁體中文（台灣）' },
-      { code: 'ja-Jpan-JP', label: '日本語' },
-      { code: 'ko-Kore-KR', label: '한국어' },
-      { code: 'fr-Latn-FR', label: 'Français' },
-      { code: 'de-Latn-DE', label: 'Deutsch' },
-      { code: 'ru-Cyrl-RU', label: 'Русский' },
-      { code: 'es-Latn-ES', label: 'Español' },
-      { code: 'it-Latn-IT', label: 'Italiano' },
-      { code: 'pt-Latn-BR', label: 'Portuguese (Brazil)' },
       { code: 'vi-Latn-VN', label: 'Tiếng Việt' },
       { code: 'tr-Latn-TR', label: 'Türkçe' },
       { code: 'id-Latn-ID', label: 'Bahasa Indonesia' },
@@ -29,6 +30,14 @@ describe('Pro 2 device settings options', () => {
     ]);
   });
 
+  test('maps shared language keys and preserves Pro2-only BCP-47 tags', () => {
+    expect(mapLanguageToProtocolV2('en')).toBe('en-Latn-US');
+    expect(mapLanguageToProtocolV2('zh_cn')).toBe('zh-Hans-CN');
+    expect(mapLanguageToProtocolV2('pt_br')).toBe('pt-Latn-BR');
+    expect(mapLanguageToProtocolV2('vi-Latn-VN')).toBe('vi-Latn-VN');
+    expect(mapLanguageToProtocolV2(undefined)).toBeUndefined();
+  });
+
   test('returns the firmware-supported auto-lock delays', () => {
     expect(getAutoLockOptions(EDeviceType.Pro2)).toEqual([
       { seconds: 30, minute: 0, hour: 0, day: 0 },

package/__tests__/evmLedgerLegacySafety.test.ts

@@ -5,7 +5,7 @@ import { findMethod } from '../src/api/utils';
 import { getDeviceType, getFirmwareType, getMethodVersionRange } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
 
-import { EDeviceType } from '@onekeyfe/hd-shared';
+import type { EDeviceType } from '@onekeyfe/hd-shared';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -30,7 +30,7 @@ const createDevice = (onekeyDeviceType: string) => {
       commands: {
         typedCall,
       },
-      // BaseMethod 通过 Device accessor 读取设备状态，stub 复用真实工具函数保持映射一致
+      // BaseMethod reads state through Device accessors; reuse production mappers in the stub.
       isProtocolV2: () => false,
       getCurrentDeviceType: () => getDeviceType(features as any),
       getCurrentSafetyChecks: () => features.safety_checks,

package/__tests__/evmSignTypedData.test.ts

@@ -497,3 +497,83 @@ describe('EVMSignTypedData — hasClassicFamilyTypedDataFormatViolations', () =>
     });
   });
 });
+
+describe('EVMSignTypedData — OneKey Pro Safe Protocol V1', () => {
+  it('收到 Pro 的 Safe 请求后按 EthereumGnosisSafeTxAck 字段回传', async () => {
+    const data = {
+      types: {
+        EIP712Domain: [
+          { name: 'chainId', type: 'uint256' },
+          { name: 'verifyingContract', type: 'address' },
+        ],
+        SafeTx: [
+          { name: 'to', type: 'address' },
+          { name: 'value', type: 'uint256' },
+          { name: 'data', type: 'bytes' },
+          { name: 'operation', type: 'uint8' },
+          { name: 'safeTxGas', type: 'uint256' },
+          { name: 'baseGas', type: 'uint256' },
+          { name: 'gasPrice', type: 'uint256' },
+          { name: 'gasToken', type: 'address' },
+          { name: 'refundReceiver', type: 'address' },
+          { name: 'nonce', type: 'uint256' },
+        ],
+      },
+      primaryType: 'SafeTx',
+      domain: {
+        chainId: '0x89',
+        verifyingContract: '0x673f21761c5400531a37554a602fe0407addd0dd',
+      },
+      message: {
+        to: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+        value: '1000',
+        data: '0x001234',
+        operation: '1',
+        safeTxGas: '256',
+        baseGas: '0',
+        gasPrice: '15',
+        gasToken: '0x0000000000000000000000000000000000000000',
+        refundReceiver: '0x0000000000000000000000000000000000000000',
+        nonce: '2',
+      },
+    } as EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>;
+    const method = createMethod(data);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'EthereumTypedDataSignatureOneKey',
+      message: {
+        address: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+        signature: 'abcd',
+      },
+    });
+
+    const result = await method.handleSignTypedData({
+      typedCall: typedCall as any,
+      signData: data,
+      response: { type: 'EthereumGnosisSafeTxRequest', message: {} } as any,
+      supportTrezor: false,
+    });
+
+    expect(typedCall).toHaveBeenCalledWith(
+      'EthereumGnosisSafeTxAck',
+      ['EthereumTypedDataSignature', 'EthereumTypedDataSignatureOneKey'],
+      {
+        to: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+        value: '03e8',
+        data: '1234',
+        operation: 1,
+        safeTxGas: '0100',
+        baseGas: '00',
+        gasPrice: '0f',
+        gasToken: '0x0000000000000000000000000000000000000000',
+        refundReceiver: '0x0000000000000000000000000000000000000000',
+        nonce: '02',
+        chain_id: 137,
+        verifyingContract: '0x673f21761c5400531a37554a602fe0407addd0dd',
+      }
+    );
+    expect(result).toEqual({
+      address: '0x5618207d27d78f09f61a5d92190d58c453feb4b7',
+      signature: 'abcd',
+    });
+  });
+});

package/__tests__/filesystemValidation.test.ts

@@ -0,0 +1,53 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { validateProtocolV2FilesystemPath } from '../src/api/helpers/filesystemValidation';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('validateProtocolV2FilesystemPath', () => {
+  test('兼容并保留设备现有的卷内相对路径格式', () => {
+    expect(validateProtocolV2FilesystemPath('vol1:test.bin', 'path')).toBe('vol1:test.bin');
+  });
+
+  test('目录查询可以使用卷根目录', () => {
+    expect(
+      validateProtocolV2FilesystemPath('VOL1:', 'path', {
+        allowVolumeRoot: true,
+      })
+    ).toBe('vol1:');
+  });
+
+  test.each([
+    'vol1:/../firmware.bin',
+    'vol1:/wallets/./test.bin',
+    'vol1:/wallets//test.bin',
+    'vol1:\\wallets\\test.bin',
+    'vol2:/test.bin',
+    '/test.bin',
+  ])('拒绝不安全或未知范围的路径：%s', path => {
+    expect(() => validateProtocolV2FilesystemPath(path, 'path')).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      })
+    );
+  });
+
+  test('文件操作不允许使用卷根目录', () => {
+    expect(() => validateProtocolV2FilesystemPath('vol1:', 'path')).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      })
+    );
+  });
+
+  test('按 UTF-8 字节数拒绝超出设备最小路径缓冲区的路径', () => {
+    expect(() => validateProtocolV2FilesystemPath(`vol1:/${'测'.repeat(41)}`, 'path')).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      })
+    );
+  });
+});

package/__tests__/firmware-update/firmware-update-v2-download-before-boot.test.ts

@@ -0,0 +1,402 @@
+import { EDeviceType, EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
+import { getBinary } from '../../src/api/firmware/getBinary';
+import { uploadFirmware } from '../../src/api/firmware/uploadFirmware';
+import * as utils from '../../src/utils';
+
+jest.mock('../../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+jest.mock('../../src/api/firmware/getBinary', () => ({
+  getBinary: jest.fn(),
+  getInfo: jest.fn(),
+  getSysResourceBinary: jest.fn(),
+}));
+
+jest.mock('../../src/api/firmware/uploadFirmware', () => ({
+  updateResources: jest.fn(),
+  uploadFirmware: jest.fn(),
+}));
+
+jest.mock('../../src/device/DevicePool', () => ({
+  DevicePool: {
+    clearDeviceCache: jest.fn(),
+    devicesCache: {},
+  },
+}));
+
+const mockGetBinary = getBinary as jest.MockedFunction<typeof getBinary>;
+const mockUploadFirmware = uploadFirmware as jest.MockedFunction<typeof uploadFirmware>;
+
+type DeviceType = 'CLASSIC1S' | 'PURE';
+
+const createCustomBuffer = (byteLength: number) => {
+  const customBuffer: {
+    [index: number]: number;
+    byteLength: number;
+    constructor: {
+      isBuffer: (value: unknown) => boolean;
+    };
+    length: number;
+  } = {
+    byteLength,
+    constructor: {
+      isBuffer: (value: unknown) => value === customBuffer,
+    },
+    length: byteLength,
+  };
+  for (let index = 0; index < byteLength; index += 1) {
+    customBuffer[index] = index + 1;
+  }
+  return customBuffer;
+};
+
+const countCommandCalls = (typedCall: jest.Mock, command: string) =>
+  typedCall.mock.calls.filter(([calledCommand]) => calledCommand === command).length;
+
+const expectNoFirmwareMutationCalls = (typedCall: jest.Mock) => {
+  expect(countCommandCalls(typedCall, 'DeviceBackToBoot')).toBe(0);
+  expect(countCommandCalls(typedCall, 'FirmwareErase')).toBe(0);
+  expect(countCommandCalls(typedCall, 'FirmwareErase_ex')).toBe(0);
+  expect(countCommandCalls(typedCall, 'FirmwareUpload')).toBe(0);
+  expect(countCommandCalls(typedCall, 'UpgradeFileHeader')).toBe(0);
+};
+
+const createMethod = ({
+  binary,
+  updateType = 'firmware',
+  isUpdateBootloader,
+  deviceType = 'CLASSIC1S',
+  bootloaderMode = false,
+}: {
+  binary?: unknown;
+  updateType?: 'firmware' | 'ble';
+  isUpdateBootloader?: boolean;
+  deviceType?: DeviceType;
+  bootloaderMode?: boolean;
+} = {}) => {
+  const method = new FirmwareUpdateV2({
+    id: 1,
+    payload: {
+      method: 'firmwareUpdateV2',
+      connectId: 'connect-id',
+      deviceId: 'device-id',
+      platform: 'desktop',
+      updateType,
+      isUpdateBootloader,
+      ...(binary !== undefined ? { binary } : { version: [3, 0, 0] }),
+    },
+  });
+  method.init();
+
+  const typedCall = jest.fn().mockResolvedValue({ type: 'Success' });
+  const checkDisposed = jest.fn();
+  const acquire = jest.fn().mockResolvedValue(undefined);
+  const commands = {
+    typedCall,
+    checkDisposed,
+    disposed: false,
+  };
+
+  method.device = {
+    features: {
+      onekey_device_type: deviceType,
+      onekey_serial_no: deviceType === 'PURE' ? 'CP123456' : 'CL123456',
+      bootloader_mode: bootloaderMode,
+      major_version: 3,
+      minor_version: 0,
+      patch_version: 0,
+      capabilities: [],
+    },
+    commands,
+    getCommands: () => commands,
+    getCurrentDeviceType: () =>
+      deviceType === 'PURE' ? EDeviceType.ClassicPure : EDeviceType.Classic1s,
+    getCurrentFirmwareType: () => EFirmwareType.Universal,
+    getCurrentFirmwareVersionString: () => '3.0.0',
+    getCurrentBootloaderVersionString: () => '0.0.0',
+    getCurrentSerialNo: () => (deviceType === 'PURE' ? 'CP123456' : 'CL123456'),
+    isBootloader: () => bootloaderMode,
+    isProtocolV2: () => false,
+    acquire,
+    toMessageObject: jest.fn(() => ({})),
+  } as any;
+  method.postMessage = jest.fn();
+  jest.spyOn(method, 'checkDeviceToBootloader').mockImplementation(() => {
+    method.checkPromise = {
+      promise: Promise.resolve(true),
+    } as any;
+  });
+
+  return {
+    method,
+    typedCall,
+    acquire,
+  };
+};
+
+describe('FirmwareUpdateV2 download-before-reboot safety', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(utils, 'wait').mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it.each([
+    {
+      context: 'Classic 1S normal mode',
+      deviceType: 'CLASSIC1S' as const,
+      bootloaderMode: false,
+    },
+    {
+      context: 'Classic Pure normal mode',
+      deviceType: 'PURE' as const,
+      bootloaderMode: false,
+    },
+    {
+      context: 'initial bootloader mode',
+      deviceType: 'CLASSIC1S' as const,
+      bootloaderMode: true,
+    },
+  ])('blocks all firmware mutation after final download failure in $context', async options => {
+    mockGetBinary.mockRejectedValue(new Error('request failed'));
+    const { method, typedCall, acquire } = createMethod(options);
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+    });
+
+    expect(mockGetBinary).toHaveBeenCalledTimes(1);
+    expectNoFirmwareMutationCalls(typedCall);
+    expect(acquire).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    {
+      mode: 'firmware release.url',
+      updateType: 'firmware' as const,
+      isUpdateBootloader: undefined,
+      deviceType: 'CLASSIC1S' as const,
+      firmwareBinary: new ArrayBuffer(4),
+    },
+    {
+      mode: 'BLE webUpdate',
+      updateType: 'ble' as const,
+      isUpdateBootloader: undefined,
+      deviceType: 'PURE' as const,
+      firmwareBinary: Buffer.from([1, 2, 3, 4]),
+    },
+    {
+      mode: 'bootloaderResource',
+      updateType: 'firmware' as const,
+      isUpdateBootloader: true,
+      deviceType: 'CLASSIC1S' as const,
+      firmwareBinary: new ArrayBuffer(8),
+    },
+  ])(
+    'acquires $mode before rebooting and preserves the response shape',
+    async ({ updateType, isUpdateBootloader, deviceType = 'CLASSIC1S', firmwareBinary }) => {
+      const callOrder: string[] = [];
+      const expectedResponse = {
+        success: true,
+        payload: {
+          firmwareVersion: '3.0.0',
+        },
+      };
+      mockGetBinary.mockImplementation(() => {
+        callOrder.push('download');
+        return Promise.resolve({
+          binary: firmwareBinary,
+        } as Awaited<ReturnType<typeof getBinary>>);
+      });
+      mockUploadFirmware.mockImplementation(() => {
+        callOrder.push('upload');
+        return Promise.resolve(expectedResponse as Awaited<ReturnType<typeof uploadFirmware>>);
+      });
+      const { method, typedCall } = createMethod({
+        updateType,
+        isUpdateBootloader,
+        deviceType,
+      });
+      typedCall.mockImplementation(type => {
+        if (type === 'DeviceBackToBoot') {
+          callOrder.push('reboot');
+        }
+        return Promise.resolve({ type: 'Success' });
+      });
+
+      await expect(method.run()).resolves.toBe(expectedResponse);
+
+      expect(callOrder).toEqual(['download', 'reboot', 'upload']);
+      expect(mockGetBinary).toHaveBeenCalledWith(
+        expect.objectContaining({
+          updateType,
+          isUpdateBootloader,
+          requestOptions: {
+            connectTimeoutMs: 60_000,
+            readTimeoutMs: 60_000,
+            overallTimeoutMs: 180_000,
+            maxRetries: 2,
+            retryDelayMs: 500,
+          },
+        })
+      );
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
+        updateType,
+        expect.any(Function),
+        expect.any(Function),
+        method.device,
+        {
+          payload: firmwareBinary,
+          rebootOnSuccess: true,
+        },
+        isUpdateBootloader
+      );
+    }
+  );
+
+  it('downloads before acquiring and uploading when the device starts in bootloader mode', async () => {
+    const callOrder: string[] = [];
+    const firmwareBinary = new ArrayBuffer(4);
+    mockGetBinary.mockImplementation(() => {
+      callOrder.push('download');
+      return Promise.resolve({
+        binary: firmwareBinary,
+      } as Awaited<ReturnType<typeof getBinary>>);
+    });
+    mockUploadFirmware.mockImplementation(() => {
+      callOrder.push('upload');
+      return Promise.resolve({
+        success: true,
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
+    });
+    const { method, typedCall, acquire } = createMethod({
+      bootloaderMode: true,
+    });
+    acquire.mockImplementation(() => {
+      callOrder.push('acquire');
+      return Promise.resolve();
+    });
+
+    await method.run();
+
+    expect(callOrder).toEqual(['download', 'acquire', 'upload']);
+    expect(countCommandCalls(typedCall, 'DeviceBackToBoot')).toBe(0);
+  });
+
+  it('does not reboot while the firmware download is pending', async () => {
+    let resolveDownload!: (result: Awaited<ReturnType<typeof getBinary>>) => void;
+    const firmwareBinary = new ArrayBuffer(4);
+    mockGetBinary.mockImplementation(
+      () =>
+        new Promise(resolve => {
+          resolveDownload = resolve;
+        })
+    );
+    mockUploadFirmware.mockResolvedValue({
+      success: true,
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
+    const { method, typedCall } = createMethod();
+
+    const runPromise = method.run();
+
+    expect(mockGetBinary).toHaveBeenCalledTimes(1);
+    expect(countCommandCalls(typedCall, 'DeviceBackToBoot')).toBe(0);
+
+    resolveDownload({
+      binary: firmwareBinary,
+    } as Awaited<ReturnType<typeof getBinary>>);
+    await runPromise;
+
+    expect(countCommandCalls(typedCall, 'DeviceBackToBoot')).toBe(1);
+  });
+
+  it.each([
+    ['ArrayBuffer', new ArrayBuffer(0)],
+    ['Buffer', Buffer.alloc(0)],
+  ])('does not reboot or upload an empty downloaded %s', async (_kind, firmwareBinary) => {
+    mockGetBinary.mockResolvedValue({
+      binary: firmwareBinary,
+    } as Awaited<ReturnType<typeof getBinary>>);
+    const { method, typedCall, acquire } = createMethod();
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+    });
+
+    expectNoFirmwareMutationCalls(typedCall);
+    expect(acquire).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ['ArrayBuffer', new ArrayBuffer(4)],
+    ['Buffer', Buffer.from([1, 2, 3, 4])],
+  ])(
+    'keeps the non-empty %s binary overload and never downloads it again',
+    async (_kind, binary) => {
+      mockUploadFirmware.mockResolvedValue({
+        success: true,
+      } as Awaited<ReturnType<typeof uploadFirmware>>);
+      const { method } = createMethod({ binary });
+
+      await method.run();
+
+      expect(mockGetBinary).not.toHaveBeenCalled();
+      expect(mockUploadFirmware).toHaveBeenCalledWith(
+        'firmware',
+        expect.any(Function),
+        expect.any(Function),
+        method.device,
+        {
+          payload: binary,
+          rebootOnSuccess: true,
+        },
+        undefined
+      );
+    }
+  );
+
+  it.each([
+    ['Uint8Array subview', new Uint8Array([9, 1, 2, 9]).subarray(1, 3), [1, 2]],
+    ['DataView', new DataView(new Uint8Array([9, 3, 4, 9]).buffer, 1, 2), [3, 4]],
+    ['custom Buffer', createCustomBuffer(4), [1, 2, 3, 4]],
+  ])('normalizes a non-empty %s before rebooting', async (_kind, binary, expectedBytes) => {
+    mockUploadFirmware.mockResolvedValue({
+      success: true,
+    } as Awaited<ReturnType<typeof uploadFirmware>>);
+    const { method } = createMethod({ binary });
+
+    await method.run();
+
+    expect(mockGetBinary).not.toHaveBeenCalled();
+    const normalizedBinary = mockUploadFirmware.mock.calls[0][4].payload;
+    expect(normalizedBinary).toBeInstanceOf(ArrayBuffer);
+    expect(Array.from(new Uint8Array(normalizedBinary))).toEqual(expectedBytes);
+  });
+
+  it.each([
+    ['ArrayBuffer', new ArrayBuffer(0)],
+    ['Buffer', Buffer.alloc(0)],
+    ['ArrayBufferView', new Uint8Array(0)],
+    ['custom Buffer', createCustomBuffer(0)],
+  ])('rejects an empty supplied %s before rebooting', async (_kind, binary) => {
+    const { method, typedCall, acquire } = createMethod({ binary });
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+    });
+
+    expect(mockGetBinary).not.toHaveBeenCalled();
+    expectNoFirmwareMutationCalls(typedCall);
+    expect(acquire).not.toHaveBeenCalled();
+    expect(mockUploadFirmware).not.toHaveBeenCalled();
+  });
+});