@onekeyfe/hd-core 1.2.0-alpha.5 → 1.2.0-alpha.50

package/__tests__/deviceFeaturesUtils.test.ts

@@ -0,0 +1,39 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import DataManager from '../src/data-manager/DataManager';
+import {
+  getSupportProtocolV1MessageSchema,
+  supportInputPinOnSoftware,
+} from '../src/utils/deviceFeaturesUtils';
+
+import type { Features } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: () => '1.0.0',
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('getSupportProtocolV1MessageSchema', () => {
+  test('Classic Pure 在无主固件的 Bootloader 模式下使用当前协议结构', () => {
+    const features = {
+      deviceType: EDeviceType.ClassicPure,
+      bootloaderMode: true,
+      firmwarePresent: false,
+      firmwareVersion: '2.0.8',
+    } as Features;
+
+    const result = getSupportProtocolV1MessageSchema(features);
+
+    expect(result.protocolV1MessageSchema).toBe('v1CurrentSchema');
+    expect(result.messages).toBe(DataManager.messages.v1CurrentSchema);
+  });
+
+  test('Pro2 never supports entering PIN in software', () => {
+    const features = {
+      deviceType: EDeviceType.Pro2,
+      firmwareVersion: '9.9.9',
+    } as Features;
+
+    expect(supportInputPinOnSoftware(features)).toEqual({ support: false });
+  });
+});

package/__tests__/deviceSettings.test.ts

@@ -0,0 +1,103 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import {
+  getAutoLockOptions,
+  getAutoShutDownOptions,
+  getDeviceSettingsCapabilities,
+  getLanguageConfig,
+  mapLanguageFromProtocolV2,
+  mapLanguageToProtocolV2,
+  PROTOCOL_V2_NEVER_TIMEOUT_MS,
+} from '../src/utils/deviceSettings';
+
+describe('Pro 2 device settings options', () => {
+  test('returns stable SDK keys plus Pro2-only BCP-47 languages', () => {
+    expect(getLanguageConfig(EDeviceType.Pro2)).toEqual([
+      { code: 'en', label: 'English' },
+      { code: 'zh_cn', label: '简体中文' },
+      { code: 'zh_hk', label: '繁體中文（香港）' },
+      { code: 'zh-Hant-TW', label: '繁體中文（台灣）' },
+      { code: 'ja', label: '日本語' },
+      { code: 'ko', label: '한국어' },
+      { code: 'fr', label: 'Français' },
+      { code: 'de', label: 'Deutsch' },
+      { code: 'ru', label: 'Русский' },
+      { code: 'es', label: 'Español' },
+      { code: 'it', label: 'Italiano' },
+      { code: 'pt_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' },
+      { code: 'fil-Latn-PH', label: 'Filipino' },
+      { code: 'uk-Cyrl-UA', label: 'Українська' },
+    ]);
+  });
+
+  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('maps Protocol V2 tags back to the shared SDK language keys', () => {
+    expect(mapLanguageFromProtocolV2('en-Latn-US')).toBe('en');
+    expect(mapLanguageFromProtocolV2('zh-Hans-CN')).toBe('zh_cn');
+    expect(mapLanguageFromProtocolV2('pt-Latn-BR')).toBe('pt_br');
+    expect(mapLanguageFromProtocolV2('vi-Latn-VN')).toBe('vi-Latn-VN');
+    expect(mapLanguageFromProtocolV2(undefined)).toBeUndefined();
+  });
+
+  test('returns the firmware-supported auto-lock delays', () => {
+    expect(getAutoLockOptions(EDeviceType.Pro2, 'V2')).toEqual([
+      { label: '30 seconds', valueMs: 30_000 },
+      { label: '1 minute', valueMs: 60_000 },
+      { 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 },
+    ]);
+  });
+
+  test('returns the firmware-supported auto-shutdown delays', () => {
+    expect(getAutoShutDownOptions(EDeviceType.Pro2, 'V2')).toEqual([
+      { label: '1 minute', valueMs: 60_000 },
+      { 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 },
+    ]);
+  });
+
+  test('keeps the legacy and Protocol V2 never values protocol-specific', () => {
+    expect(getAutoLockOptions(EDeviceType.Pro, 'V1').slice(-1)[0]).toEqual({
+      label: 'Never',
+      valueMs: 0,
+    });
+    expect(getAutoLockOptions(EDeviceType.Pro2, 'V2').slice(-1)[0]).toEqual({
+      label: 'Never',
+      valueMs: PROTOCOL_V2_NEVER_TIMEOUT_MS,
+    });
+  });
+
+  test('returns one capability model for Protocol V1 and V2 consumers', () => {
+    const v1 = getDeviceSettingsCapabilities(EDeviceType.Pro, 'V1');
+    const v2 = getDeviceSettingsCapabilities(EDeviceType.Pro2, 'V2');
+
+    expect(v1.supportedFields).toEqual(
+      expect.arrayContaining(['label', 'safetyChecks', 'experimentalFeatures'])
+    );
+    expect(v1.supportedFields).not.toContain('brightness');
+    expect(v2.supportedFields).toEqual(
+      expect.arrayContaining(['label', 'brightness', 'airgapMode'])
+    );
+    expect(v2.supportedFields).not.toContain('safetyChecks');
+    expect(v2.ranges.brightness).toEqual({ min: 10, max: 100 });
+    expect(v1.safetyCheckOptions.map(option => option.value)).toEqual([0, 1, 2]);
+    expect(v2.safetyCheckOptions).toEqual([]);
+    expect(v2.onDeviceConfirmationFields).toEqual(['usePassphrase', 'airgapMode']);
+  });
+});

package/__tests__/deviceUploadNft.test.ts

@@ -0,0 +1,293 @@
+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 = [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 === '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('FilesystemDirList');
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      '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('retries one timed-out NftUpdate with the same basename', async () => {
+    const timeout = Object.assign(new Error('Protocol V2 response timeout'), {
+      code: 'response-timeout',
+    });
+    let updateCalls = 0;
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') {
+        updateCalls += 1;
+        if (updateCalls === 1) throw timeout;
+        return { message: { message: 'NFT updated' } };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall });
+
+    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
+
+    const updateRequests = typedCall.mock.calls.filter(call => call[0] === 'NftUpdate');
+    expect(updateRequests).toHaveLength(2);
+    expect(updateRequests[1]).toEqual(updateRequests[0]);
+  });
+
+  test('does not retry a non-timeout NftUpdate failure', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      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('propagates a second NftUpdate timeout after one retry', 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 === '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);
+    expect(typedCall.mock.calls.filter(call => call[0] === 'NftUpdate')).toHaveLength(2);
+  });
+
+  test('does not publish when a file write fails', async () => {
+    const typedCall = jest.fn((request: string) => {
+      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 === '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(['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 === '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 === '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__/evmLedgerLegacySafety.test.ts

@@ -1,3 +1,5 @@
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+
 import AllNetworkGetAddressBase from '../src/api/allnetwork/AllNetworkGetAddressBase';
 import EvmGetAddress from '../src/api/evm/EVMGetAddress';
 import EVMGetPublicKey from '../src/api/evm/EVMGetPublicKey';
@@ -5,6 +7,8 @@ import { findMethod } from '../src/api/utils';
 import { getDeviceType, getFirmwareType, getMethodVersionRange } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
 
+import type { EDeviceType } from '@onekeyfe/hd-shared';
+
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
@@ -18,7 +22,8 @@ const createDevice = (onekeyDeviceType: string) => {
   const typedCall = jest.fn();
   const features = {
     onekey_device_type: onekeyDeviceType,
-    safety_checks: 'Strict',
+    deviceType: onekeyDeviceType.toLowerCase() as EDeviceType,
+    safety_checks: Enum_SafetyCheckLevel.Strict,
   };
   return {
     typedCall,
@@ -27,8 +32,9 @@ const createDevice = (onekeyDeviceType: string) => {
       commands: {
         typedCall,
       },
-      // BaseMethod 通过 Device accessor 读取设备状态，stub 复用真实工具函数保持映射一致
+      // BaseMethod reads state through Device accessors; reuse production mappers in the stub.
       isProtocolV2: () => false,
+      getProtocol: () => 'V1' as const,
       getCurrentDeviceType: () => getDeviceType(features as any),
       getCurrentSafetyChecks: () => features.safety_checks,
       getCurrentFirmwareType: () => getFirmwareType(features as any),
@@ -65,7 +71,7 @@ describe('EVM Ledger legacy path safety checks', () => {
       await method.checkSafetyLevelOnTestNet();
 
       expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-        safety_checks: 'PromptTemporarily',
+        safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
       });
     }
   );
@@ -84,7 +90,7 @@ describe('EVM Ledger legacy path safety checks', () => {
     await method.checkSafetyLevelOnTestNet();
 
     expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
+      safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
     });
   });
 
@@ -133,7 +139,7 @@ describe('EVM Ledger legacy path safety checks', () => {
     );
 
     expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
+      safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
     });
 
     runSpy.mockRestore();
@@ -213,7 +219,7 @@ describe('EVM Ledger legacy path safety checks', () => {
 
     expect(typedCall).toHaveBeenCalledTimes(1);
     expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
-      safety_checks: 'PromptTemporarily',
+      safety_checks: Enum_SafetyCheckLevel.PromptTemporarily,
     });
 
     runSpy.mockRestore();

package/__tests__/evmSignTransaction.test.ts

@@ -1,4 +1,5 @@
 import EVMSignTransaction from '../src/api/evm/EVMSignTransaction';
+import TransportManager from '../src/data-manager/TransportManager';
 
 import type { EVMTransactionEIP7702 } from '../src/types';
 
@@ -17,13 +18,17 @@ jest.mock('../src/device/Device', () => ({
   Device: jest.fn(),
 }));
 
+const mockTransportManager = jest.mocked(TransportManager);
+
 describe('EVMSignTransaction EIP-7702', () => {
   let mockDevice: any;
   let mockTypedCall: jest.Mock;
 
   beforeEach(() => {
+    mockTransportManager.getProtocolV1MessageSchema.mockReturnValue('v1CurrentSchema');
     mockTypedCall = jest.fn();
     mockDevice = {
+      isProtocolV2: jest.fn(() => false),
       commands: {
         typedCall: {
           bind: jest.fn(() => mockTypedCall),
@@ -32,6 +37,70 @@ describe('EVMSignTransaction EIP-7702', () => {
     };
   });
 
+  describe('Protocol-specific schema routing', () => {
+    const transaction: EVMTransactionEIP7702 = {
+      to: '0x4Cd241E8d1510e30b2076397afc7508Ae59C66c9',
+      value: '0x0',
+      gasLimit: '0x5208',
+      nonce: '0x0',
+      chainId: 1,
+      maxFeePerGas: '0xbebc200',
+      maxPriorityFeePerGas: '0x9502f900',
+      authorizationList: [
+        {
+          chainId: 1,
+          address: '0x4Cd241E8d1510e30b2076397afc7508Ae59C66c9',
+          nonce: '0x1',
+        },
+      ],
+    };
+
+    const createTransactionMethod = () => {
+      const method = new EVMSignTransaction({
+        id: 1,
+        payload: {
+          method: 'evmSignTransaction',
+          path: "m/44'/60'/0'/0/0",
+          transaction,
+        },
+      });
+      method.device = mockDevice;
+      method.init();
+      return method;
+    };
+
+    it('keeps Protocol V2 on current OneKey messages after a legacy V1 device', async () => {
+      mockTransportManager.getProtocolV1MessageSchema.mockReturnValue('v1LegacySchema');
+      mockDevice.isProtocolV2.mockReturnValue(true);
+      mockTypedCall.mockResolvedValue({
+        message: {
+          signature_v: 27,
+          signature_r: '01',
+          signature_s: '02',
+          authorization_signatures: [],
+        },
+      });
+
+      await expect(createTransactionMethod().run()).resolves.toMatchObject({
+        v: '0x1b',
+      });
+      expect(mockTypedCall).toHaveBeenCalledWith(
+        'EthereumSignTxEIP7702OneKey',
+        'EthereumTxRequestOneKey',
+        expect.any(Object)
+      );
+    });
+
+    it('continues to use legacy messages for a Protocol V1 legacy device', async () => {
+      mockTransportManager.getProtocolV1MessageSchema.mockReturnValue('v1LegacySchema');
+
+      await expect(createTransactionMethod().run()).rejects.toThrow(
+        'EIP7702 not supported by Trezor'
+      );
+      expect(mockTypedCall).not.toHaveBeenCalled();
+    });
+  });
+
   describe('EIP-7702 Transaction Detection', () => {
     it('should detect EIP-7702 transaction with authorization list', () => {
       const transaction: EVMTransactionEIP7702 = {

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