@onekeyfe/hd-core 1.2.0-alpha.2 → 1.2.0-alpha.4

package/__tests__/protocol-v2.test.ts

@@ -1,17 +1,19 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DevRebootType } from '@onekeyfe/hd-transport';
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
 
-import ConfluxSignTransaction from '../src/api/conflux/ConfluxSignTransaction';
+import * as firmwareBinaryApi from '../src/api/firmware/getBinary';
 import DnxGetAddress from '../src/api/dynex/DnxGetAddress';
 import DnxSignTransaction from '../src/api/dynex/DnxSignTransaction';
 import DirList from '../src/api/DirList';
 import FileRead from '../src/api/FileRead';
 import FileWrite from '../src/api/FileWrite';
-import DevReboot from '../src/api/protocol-v2/DevReboot';
+import DeviceFactoryInfoGet from '../src/api/protocol-v2/DeviceFactoryInfoGet';
+import DeviceFactoryInfoSet from '../src/api/protocol-v2/DeviceFactoryInfoSet';
 import DeviceFirmwareUpdate from '../src/api/protocol-v2/DeviceFirmwareUpdate';
-import DeviceGetDeviceInfo from '../src/api/protocol-v2/DeviceGetDeviceInfo';
-import DeviceGetOnboardingStatus from '../src/api/protocol-v2/DeviceGetOnboardingStatus';
+import DeviceInfoGet from '../src/api/protocol-v2/DeviceInfoGet';
 import DeviceReboot from '../src/api/protocol-v2/DeviceReboot';
+import FilesystemPermissionFix from '../src/api/protocol-v2/FilesystemPermissionFix';
+import ProtocolInfoRequest from '../src/api/protocol-v2/ProtocolInfoRequest';
 import EVMSignTypedData from '../src/api/evm/EVMSignTypedData';
 import EVMSignMessageEIP712 from '../src/api/evm/EVMSignMessageEIP712';
 import FirmwareUpdateV3 from '../src/api/FirmwareUpdateV3';
@@ -35,8 +37,6 @@ import TonSignData from '../src/api/ton/TonSignData';
 import TonSignMessage from '../src/api/ton/TonSignMessage';
 import TonSignProof from '../src/api/ton/TonSignProof';
 import TronGetAddress from '../src/api/tron/TronGetAddress';
-import TronSignMessage from '../src/api/tron/TronSignMessage';
-import XrpSignTransaction from '../src/api/xrp/XrpSignTransaction';
 import StellarGetAddress from '../src/api/stellar/StellarGetAddress';
 import BenfenSignMessage from '../src/api/benfen/BenfenSignMessage';
 import { getBitcoinForkVersionRange } from '../src/api/btc/helpers/versionLimit';
@@ -45,17 +45,14 @@ import { Device } from '../src/device/Device';
 import { UI_REQUEST } from '../src/events/ui-request';
 import {
   PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
-  buildMockProtocolV2DeviceInfo,
   requestProtocolV2DeviceInfo,
-  setProtocolV2DeviceInfoMock,
 } from '../src/protocols/protocol-v2/features';
-import {
-  buildProfileFromProtocolV2,
-  buildProtocolV2FeaturesPayload,
-} from '../src/deviceProfile';
+import { buildProfileFromProtocolV2, buildProtocolV2FeaturesPayload } from '../src/deviceProfile';
 import {
   getDeviceType,
   getFirmwareType,
+  getFirmwareUpdateField,
+  getFirmwareUpdateFieldArray,
   getMethodVersionRange,
   isMethodVersionRangeUnsupported,
 } from '../src/utils';
@@ -74,12 +71,6 @@ jest.mock('../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
-// DeviceGetDeviceInfo mock 开关默认开启（早期工程板固件没有该消息）。
-// 本测试文件验证的是真实 wire 调用行为，统一关闭；mock 行为单独有用例覆盖。
-beforeAll(() => {
-  setProtocolV2DeviceInfoMock(false);
-});
-
 const descriptor = {
   id: 'ble-id',
   path: 'usb-path',
@@ -97,12 +88,11 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
   d.getCurrentFirmwareType ??= () => getFirmwareType(d.features);
   d.getCurrentFirmwareVersionString ??= () =>
     d.features ? getDeviceFirmwareVersion(d.features).join('.') : undefined;
-  d.getCurrentBLEFirmwareVersionString ??= () => d.features?.onekey_ble_version;
-  d.getCurrentSafetyChecks ??= () => d.features?.safety_checks;
-  d.getCurrentDeviceId ??= () => d.features?.device_id || undefined;
-  d.getCurrentSerialNo ??= () => d.features?.serial_no || d.features?.onekey_serial_no || '';
-  d.getCurrentPassphraseProtection ??= () =>
-    d.features?.passphrase_protection;
+  d.getCurrentBLEFirmwareVersionString ??= () => d.features?.bleVersion;
+  d.getCurrentSafetyChecks ??= () => d.features?.safetyChecks;
+  d.getCurrentDeviceId ??= () => d.features?.deviceId || undefined;
+  d.getCurrentSerialNo ??= () => d.features?.serialNo || '';
+  d.getCurrentPassphraseProtection ??= () => d.features?.passphraseProtection;
   d.getCurrentMethodVersionRange ??= (fn: (model: any) => any) => {
     const deviceType = d.getCurrentDeviceType();
     const range = fn(deviceType);
@@ -121,7 +111,19 @@ function normalizeProtocolV2Features(_descriptor: unknown, deviceInfo?: Protocol
   return buildProtocolV2FeaturesPayload(deviceInfo);
 }
 
-async function requestProtocolV2LegacyFeatures({
+const protocolV2BootloaderDeviceInfo: ProtocolV2DeviceInfo = {
+  protocol_version: 1,
+  hw: {
+    serial_no: 'PR9999999999',
+  },
+  fw: {
+    bootloader: {
+      version: '0.0.1',
+    },
+  },
+};
+
+async function requestProtocolV2Features({
   commands,
   descriptor: inputDescriptor,
 }: {
@@ -133,30 +135,6 @@ async function requestProtocolV2LegacyFeatures({
 }
 
 describe('Protocol V2 feature adapter', () => {
-  test('skips DeviceGetDeviceInfo wire call and returns mock when mock is enabled', async () => {
-    const typedCall = jest.fn();
-    setProtocolV2DeviceInfoMock(true);
-    try {
-      const deviceInfo = await requestProtocolV2DeviceInfo({
-        commands: { typedCall } as unknown as DeviceCommands,
-      });
-      expect(typedCall).not.toHaveBeenCalled();
-      expect(deviceInfo).toEqual(buildMockProtocolV2DeviceInfo());
-      const profile = buildProfileFromProtocolV2({
-        deviceInfo,
-      });
-      expect(profile).toMatchObject({
-        protocol: 'V2',
-        deviceId: '',
-        serialNo: '',
-        status: { initialized: true },
-        versions: { firmware: '0.1.0' },
-      });
-    } finally {
-      setProtocolV2DeviceInfoMock(false);
-    }
-  });
-
   test('normalizes Protocol V2 DeviceInfo into existing Features fields', () => {
     const features = normalizeProtocolV2Features(descriptor as any, {
       protocol_version: 1,
@@ -164,31 +142,31 @@ describe('Protocol V2 feature adapter', () => {
         serial_no: 'PR2SERIAL',
       },
       fw: {
-        board: {
+        application_data: {
           version: '0.1.0',
           hash: [1, 2, 255],
         },
-        boot: {
+        bootloader: {
           version: '0.2.0',
           build_id: 'boot-build',
           hash: new Uint8Array([10, 11]),
         },
-        app: {
+        application: {
           version: '1.2.3',
           build_id: 'app-build',
           hash: 'abc123',
         },
       },
-      bt: {
-        app: {
+      coprocessor: {
+        application: {
           version: '4.5.6',
           build_id: 'bt-build',
           hash: [12, 13],
         },
-        adv_name: 'Pro2 BLE',
+        bt_adv_name: 'Pro2 BLE',
       },
       se1: {
-        app: {
+        application: {
           version: '7.8.9',
           build_id: 'se-build',
           hash: [14, 15],
@@ -196,61 +174,79 @@ describe('Protocol V2 feature adapter', () => {
         state: 85,
       },
       se2: {
-        app: {
+        application: {
           version: '8.0.0',
         },
         state: 0,
       },
       status: {
-        label: 'My Pro2',
-        language: 'en-US',
-        bt_enable: true,
+        device_id: 'PRO2-DEVICE-ID',
+        unlocked: true,
         init_states: false,
         backup_required: true,
-        passphrase_protection: true,
+        passphrase_enabled: true,
+        attach_to_pin_enabled: true,
+        unlocked_by_attach_to_pin: true,
+      },
+    });
+
+    expect(features.deviceId).toBe('PRO2-DEVICE-ID');
+    expect(features.serialNo).toBe('PR2SERIAL');
+    expect(features.deviceType).toBe('pro2');
+    expect(features.protocolVersion).toBe(1);
+    expect(features.firmwareVersion).toBe('1.2.3');
+    expect(features.verify?.firmwareBuildId).toBe('app-build');
+    expect(features.verify?.firmwareHash).toBe('abc123');
+    expect(features.bootloaderVersion).toBe('0.2.0');
+    expect(features.verify?.bootloaderBuildId).toBe('boot-build');
+    expect(features.verify?.bootloaderHash).toBe('0a0b');
+    expect(features.verify?.boardHash).toBe('0102ff');
+    expect(features.bleName).toBe('Pro2 BLE');
+    expect(features.bleVersion).toBe('4.5.6');
+    expect(features.verify?.bleHash).toBe('0c0d');
+    expect(features.se01Version).toBe('7.8.9');
+    expect(features.verify?.se01Hash).toBe('0e0f');
+    expect(features.label).toBeNull();
+    expect(features.language).toBeNull();
+    expect(features.initialized).toBe(false);
+    expect(features.unlocked).toBe(true);
+    expect(features.backupRequired).toBe(true);
+    expect(features.passphraseProtection).toBe(true);
+    expect(features.attachToPinEnabled).toBe(true);
+    expect(features.unlockedAttachPin).toBe(true);
+    expect(features.bleEnabled).toBeNull();
+  });
+
+  test('marks Protocol V2 DeviceInfo without status as bootloader mode', () => {
+    const deviceInfo = {
+      protocol_version: 1,
+      hw: {
+        serial_no: 'PR2BOOT',
       },
-    });
+      fw: {
+        bootloader: {
+          version: '0.2.0',
+        },
+      },
+    };
+    const features = normalizeProtocolV2Features(descriptor as any, deviceInfo);
+    const profile = buildProfileFromProtocolV2({ deviceInfo });
 
-    expect(features.device_id).toBeNull();
-    expect(features.serial_no).toBe('PR2SERIAL');
-    expect(features.onekey_serial_no).toBe('PR2SERIAL');
-    expect(features.onekey_device_type).toBe('pro2');
-    expect(features.protocol_version).toBe(1);
-    expect(features.major_version).toBe(1);
-    expect(features.minor_version).toBe(2);
-    expect(features.patch_version).toBe(3);
-    expect(features.onekey_firmware_version).toBe('1.2.3');
-    expect(features.onekey_firmware_build_id).toBe('app-build');
-    expect(features.onekey_firmware_hash).toBe('abc123');
-    expect(features.bootloader_version).toBe('0.2.0');
-    expect(features.onekey_boot_build_id).toBe('boot-build');
-    expect(features.onekey_boot_hash).toBe('0a0b');
-    expect(features.onekey_board_hash).toBe('0102ff');
-    expect(features.ble_name).toBe('Pro2 BLE');
-    expect(features.onekey_ble_version).toBe('4.5.6');
-    expect(features.onekey_ble_hash).toBe('0c0d');
-    expect(features.onekey_se01_version).toBe('7.8.9');
-    expect(features.onekey_se01_hash).toBe('0e0f');
-    expect(features.onekey_se01_state).toBe('APP');
-    expect(features.onekey_se02_state).toBe('BOOT');
-    expect(features.label).toBe('My Pro2');
-    expect(features.language).toBe('en-US');
-    expect(features.initialized).toBe(false);
-    expect(features.needs_backup).toBe(true);
-    expect(features.passphrase_protection).toBe(true);
-    expect(features.ble_enable).toBe(true);
+    expect(features.mode).toBe('bootloader');
+    expect(features.bootloaderMode).toBe(true);
+    expect(features.initialized).toBeNull();
+    expect(profile.status.mode).toBe('bootloader');
+    expect(profile.status.bootloaderMode).toBe(true);
   });
 
-  test('uses GetPassphraseState payloads compatible with Pro series passphrase flow', async () => {
+  test('uses DeviceSessionGet for Protocol V2 passphrase sessions', async () => {
     const features = normalizeProtocolV2Features(descriptor as any);
-    // Pro2 版本线独立于 Pro 系列：V2 设备无论固件版本都支持 GetPassphraseState
-    features.onekey_firmware_version = '1.2.3';
+    features.firmwareVersion = '1.2.3';
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
+      type: 'DeviceSession',
       message: {
-        passphrase_state: 'state-1',
+        btc_test_address: 'state-1',
         session_id: 'session-1',
-        unlocked_attach_pin: false,
       },
     });
     const commands = { typedCall } as unknown as DeviceCommands;
@@ -261,35 +257,28 @@ describe('Protocol V2 feature adapter', () => {
     await getPassphraseState(device, {
       expectPassphraseState: 'state-1',
     });
-    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
-      passphrase_state: 'state-1',
-    });
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
 
     await getPassphraseState(device, {
       expectPassphraseState: 'state-2',
       allowCreateAttachPin: true,
     });
-    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
-      passphrase_state: 'state-2',
-      allow_create_attach_pin: true,
-    });
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
 
     await getPassphraseState(device, {
       onlyMainPin: true,
     });
-    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
-      _only_main_pin: true,
-    });
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('returns unified GetPassphraseState object payload for existing Pro devices', async () => {
     const features = {
-      device_id: 'pro-device-id',
-      onekey_device_type: 'PRO',
-      onekey_firmware_version: '4.15.0',
-      passphrase_protection: true,
-      session_id: 'feature-session',
-      unlocked_attach_pin: true,
+      deviceId: 'pro-device-id',
+      deviceType: 'pro',
+      firmwareVersion: '4.15.0',
+      passphraseProtection: true,
+      sessionId: 'feature-session',
+      unlockedAttachPin: true,
     };
     const typedCall = jest.fn().mockResolvedValue({
       type: 'PassphraseState',
@@ -307,7 +296,7 @@ describe('Protocol V2 feature adapter', () => {
       },
     });
     method.device = stubDevice({
-      originalDescriptor: { ...descriptor, protocolType: 'V2' },
+      originalDescriptor: { ...descriptor, protocolType: 'V1' },
       features,
       commands: { typedCall },
       updateInternalState,
@@ -316,10 +305,10 @@ describe('Protocol V2 feature adapter', () => {
     }) as any;
 
     await expect(method.run()).resolves.toEqual({
-      passphrase_state: 'state-pro',
-      session_id: 'session-pro',
-      unlocked_attach_pin: false,
-      passphrase_protection: true,
+      passphraseState: 'state-pro',
+      sessionId: 'session-pro',
+      unlockedAttachPin: false,
+      passphraseProtection: true,
     });
     expect(updateInternalState).toHaveBeenCalledWith(
       true,
@@ -332,19 +321,18 @@ describe('Protocol V2 feature adapter', () => {
 
   test('uses features for GetPassphraseState response metadata', async () => {
     const features = {
-      device_id: null,
-      onekey_device_type: 'PRO2',
-      onekey_firmware_version: '4.15.0',
-      passphrase_protection: true,
-      session_id: 'feature-session',
-      unlocked_attach_pin: true,
+      deviceId: null,
+      deviceType: 'pro2',
+      firmwareVersion: '4.15.0',
+      passphraseProtection: true,
+      sessionId: 'feature-session',
+      unlockedAttachPin: true,
     };
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
+      type: 'DeviceSession',
       message: {
-        passphrase_state: 'state-pro2',
+        btc_test_address: 'state-pro2',
         session_id: 'session-pro2',
-        unlocked_attach_pin: false,
       },
     });
     const updateInternalState = jest.fn();
@@ -367,30 +355,79 @@ describe('Protocol V2 feature adapter', () => {
     }) as any;
 
     await expect(method.run()).resolves.toEqual({
-      passphrase_state: 'state-pro2',
-      session_id: 'session-pro2',
-      unlocked_attach_pin: false,
-      passphrase_protection: true,
+      passphraseState: 'state-pro2',
+      sessionId: 'session-pro2',
+      unlockedAttachPin: true,
+      passphraseProtection: true,
     });
     expect(getFeatures).not.toHaveBeenCalled();
   });
 
+  test('honors initSession when getting Pro2 passphrase state', async () => {
+    const features = {
+      deviceId: 'pro2-device-id',
+      deviceType: 'pro2',
+      firmwareVersion: '9.9.9',
+      passphraseProtection: true,
+      sessionId: 'old-feature-session',
+      unlockedAttachPin: false,
+    };
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceSession',
+      message: {
+        btc_test_address: 'state-pro2-new',
+      },
+    });
+    const clearInternalState = jest.fn();
+    const updateInternalState = jest.fn();
+    const method = new GetPassphraseState({
+      payload: {
+        method: 'getPassphraseState',
+        connectId: 'connect-id',
+        initSession: true,
+      },
+    });
+    method.device = stubDevice({
+      originalDescriptor: { ...descriptor, protocolType: 'V2' },
+      features,
+      commands: { typedCall },
+      clearInternalState,
+      updateInternalState,
+      getCurrentDeviceId: () => 'pro2-device-id',
+      getCurrentPassphraseProtection: () => true,
+    }) as any;
+
+    await expect(method.run()).resolves.toEqual({
+      passphraseState: 'state-pro2-new',
+      sessionId: undefined,
+      unlockedAttachPin: false,
+      passphraseProtection: true,
+    });
+    expect(clearInternalState).toHaveBeenCalledTimes(1);
+    expect(updateInternalState).toHaveBeenCalledWith(
+      true,
+      'state-pro2-new',
+      'pro2-device-id',
+      undefined,
+      null
+    );
+  });
+
   test('stores Pro2 passphrase session cache without synthetic device id', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
+      type: 'DeviceSession',
       message: {
-        passphrase_state: 'state-profile',
+        btc_test_address: 'state-profile',
         session_id: 'session-profile',
-        unlocked_attach_pin: false,
       },
     });
 
     (device as any).features = {
       ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
         hw: { serial_no: 'PR2SERIAL' },
-        fw: { app: { version: '4.15.0' } },
-        status: { passphrase_protection: true },
+        fw: { application: { version: '4.15.0' } },
+        status: { passphrase_enabled: true },
       }),
       unlocked: true,
     };
@@ -400,17 +437,16 @@ describe('Protocol V2 feature adapter', () => {
 
     device.passphraseState = 'state-profile';
     expect(device.getInternalState()).toBe('session-profile');
-    expect(device.getInternalState('LEGACY-ID')).toBeUndefined();
+    expect(device.getInternalState('CACHED-ID')).toBeUndefined();
   });
 
   test('stores Pro2 passphrase sessions without selecting them implicitly', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
+      type: 'DeviceSession',
       message: {
-        passphrase_state: 'state-auto',
+        btc_test_address: 'state-auto',
         session_id: 'session-auto',
-        unlocked_attach_pin: false,
       },
     });
 
@@ -423,8 +459,8 @@ describe('Protocol V2 feature adapter', () => {
         hw: { serial_no: 'PR2SERIAL' },
       }
     );
-    (device as any).features.onekey_firmware_version = '4.15.0';
-    (device as any).features.passphrase_protection = true;
+    (device as any).features.firmwareVersion = '4.15.0';
+    (device as any).features.passphraseProtection = true;
     (device as any).features.unlocked = true;
     (device as any).commands = { typedCall };
 
@@ -434,23 +470,20 @@ describe('Protocol V2 feature adapter', () => {
     });
 
     expect(device.passphraseState).toBeUndefined();
-    expect(device.features?.passphrase_protection).toBe(true);
-    expect(device.features?.session_id).toBeNull();
+    expect(device.features?.passphraseProtection).toBe(true);
+    expect(device.features?.sessionId).toBeNull();
     expect(device.getInternalState()).toBeUndefined();
     device.passphraseState = 'state-auto';
     expect(device.getInternalState()).toBe('session-auto');
-    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
-      passphrase_state: undefined,
-    });
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('does not mark Pro2 passphrase enabled from a main PIN session alone', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
+      type: 'DeviceSession',
       message: {
         session_id: 'main-pin-session',
-        unlocked_attach_pin: false,
       },
     });
 
@@ -461,11 +494,11 @@ describe('Protocol V2 feature adapter', () => {
       } as any,
       {
         status: {
-          passphrase_protection: false,
+          passphrase_enabled: false,
         },
       }
     );
-    (device as any).features.onekey_firmware_version = '4.15.0';
+    (device as any).features.firmwareVersion = '4.15.0';
     (device as any).features.unlocked = true;
     (device as any).commands = { typedCall };
 
@@ -476,22 +509,19 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'main-pin-session',
     });
 
-    expect(device.features?.passphrase_protection).toBe(false);
-    expect(device.features?.session_id).toBeNull();
+    expect(device.features?.passphraseProtection).toBe(false);
+    expect(device.features?.sessionId).toBeNull();
     expect(device.getInternalState()).toBeUndefined();
-    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
-      _only_main_pin: true,
-    });
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('does not let skipPassphraseCheck hide Pro2 passphrase state mismatch', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
+      type: 'DeviceSession',
       message: {
-        passphrase_state: 'wrong-state',
+        btc_test_address: 'wrong-state',
         session_id: 'wrong-session',
-        unlocked_attach_pin: false,
       },
     });
 
@@ -499,8 +529,8 @@ describe('Protocol V2 feature adapter', () => {
       ...descriptor,
       protocolType: 'V2',
     } as any);
-    (device as any).features.onekey_firmware_version = '4.15.0';
-    (device as any).features.passphrase_protection = true;
+    (device as any).features.firmwareVersion = '4.15.0';
+    (device as any).features.passphraseProtection = true;
     (device as any).commands = { typedCall };
 
     await expect(device.checkPassphraseStateSafety('expected-state', false, true)).resolves.toBe(
@@ -508,23 +538,41 @@ describe('Protocol V2 feature adapter', () => {
     );
 
     expect(device.getInternalState()).toBeUndefined();
-    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetPassphraseState', 'PassphraseState', {
-      passphrase_state: 'expected-state',
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('marks fallback features as unavailable when DeviceInfo is missing', () => {
     const features = normalizeProtocolV2Features(descriptor as any);
 
-    expect(features.device_id).toBeNull();
-    expect(features.serial_no).toBeUndefined();
-    expect(features.onekey_serial_no).toBeUndefined();
+    expect(features.deviceId).toBeNull();
+    expect(features.serialNo).toBe('');
     expect(features.initialized).toBeNull();
     expect(features.unlocked).toBeNull();
-    expect(features.firmware_present).toBe(false);
+    expect(features.firmwarePresent).toBeNull();
+  });
+
+  test('uses Protocol V2 status.device_id and does not fall back to serial_no', () => {
+    const features = normalizeProtocolV2Features(
+      {
+        id: 'PR2000000000',
+        path: 'PR2000000000',
+        protocolType: 'V2',
+      } as any,
+      {
+        hw: {
+          serial_no: 'PR9999999999',
+        },
+        status: {
+          device_id: 'DEVICE-ID-9999',
+        },
+      }
+    );
+
+    expect(features.deviceId).toBe('DEVICE-ID-9999');
+    expect(features.serialNo).toBe('PR9999999999');
   });
 
-  test('does not use Protocol V2 serial_no as device_id', () => {
+  test('does not use Protocol V2 serial_no as deviceId when hw.device_id is absent', () => {
     const features = normalizeProtocolV2Features(
       {
         id: 'PR2000000000',
@@ -538,26 +586,25 @@ describe('Protocol V2 feature adapter', () => {
       }
     );
 
-    expect(features.device_id).toBeNull();
-    expect(features.onekey_serial_no).toBe('PR9999999999');
-    expect(features.serial_no).toBe('PR9999999999');
+    expect(features.deviceId).toBeNull();
+    expect(features.serialNo).toBe('PR9999999999');
   });
 
   test('uses Protocol V2 features directly when profile is absent', () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = {
       ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-      serial_no: 'LEGACY-SERIAL',
-      label: 'Legacy Label',
-      ble_name: 'Legacy BLE',
-      passphrase_protection: true,
+      serialNo: 'CACHED-SERIAL',
+      label: 'Cached Label',
+      bleName: 'Cached BLE',
+      passphraseProtection: true,
     };
 
     expect(device.toMessageObject()).toMatchObject({
-      uuid: 'LEGACY-SERIAL',
+      uuid: 'CACHED-SERIAL',
       deviceId: null,
-      bleName: 'Legacy BLE',
-      label: 'Legacy Label',
+      bleName: 'Cached BLE',
+      label: 'Cached Label',
       deviceType: 'pro2',
     });
     expect(device.getCurrentPassphraseProtection()).toBe(true);
@@ -568,54 +615,54 @@ describe('Protocol V2 feature adapter', () => {
     const cached = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (cached as any).features = {
       ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-      device_id: null,
-      serial_no: 'LEGACY-SERIAL',
-      onekey_serial_no: 'LEGACY-SERIAL',
+      deviceId: null,
+      serialNo: 'CACHED-SERIAL',
     };
 
     const current = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     current.updateFromCache(cached);
 
     expect(current.getCurrentDeviceId()).toBeUndefined();
-    expect(current.getCurrentSerialNo()).toBe('LEGACY-SERIAL');
+    expect(current.getCurrentSerialNo()).toBe('CACHED-SERIAL');
     expect(current.toMessageObject()).toMatchObject({
-      uuid: 'LEGACY-SERIAL',
+      uuid: 'CACHED-SERIAL',
       deviceId: null,
     });
   });
 
-  test('initializes Protocol V2 features from lightweight DeviceGetDeviceInfo', async () => {
+  test('initializes Protocol V2 features from lightweight DeviceInfoGet', async () => {
     const commands = {
       typedCall: jest.fn().mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
           status: {
+            device_id: 'PRO2-STATUS-ID',
             init_states: true,
-            passphrase_protection: true,
+            passphrase_enabled: true,
           },
         },
       }),
     };
 
-    const features = await requestProtocolV2LegacyFeatures({
+    const features = await requestProtocolV2Features({
       commands: commands as unknown as DeviceCommands,
       descriptor: descriptor as any,
     });
 
-    expect(features.device_id).toBeNull();
+    expect(features.deviceId).toBe('PRO2-STATUS-ID');
     expect(features.initialized).toBe(true);
-    expect(features.passphrase_protection).toBe(true);
+    expect(features.passphraseProtection).toBe(true);
     expect(commands.typedCall).toHaveBeenCalledTimes(1);
     expect(commands.typedCall).toHaveBeenNthCalledWith(
       1,
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: {
           hw: true,
           fw: true,
-          bt: true,
+          coprocessor: true,
           status: true,
         },
         types: {
@@ -627,13 +674,13 @@ describe('Protocol V2 feature adapter', () => {
     );
   });
 
-  test('fails initialization when Protocol V2 DeviceGetDeviceInfo fails', async () => {
+  test('fails initialization when Protocol V2 DeviceInfoGet fails', async () => {
     const commands = {
       typedCall: jest.fn().mockRejectedValueOnce(new Error('DeviceInfo not supported')),
     };
 
     await expect(
-      requestProtocolV2LegacyFeatures({
+      requestProtocolV2Features({
         commands: commands as unknown as DeviceCommands,
         descriptor: descriptor as any,
       })
@@ -646,20 +693,21 @@ describe('Protocol V2 feature adapter', () => {
       message: {
         hw: { serial_no: 'PR2SERIAL' },
         fw: {
-          app: {
+          application: {
             version: '5.6.7',
           },
         },
-        bt: {
-          app: {
+        coprocessor: {
+          application: {
             version: '8.9.10',
           },
-          adv_name: 'Raw Pro2 BLE',
+          bt_adv_name: 'Raw Pro2 BLE',
         },
         status: {
+          device_id: 'PRO2-BASIC-ID',
+          unlocked_by_attach_to_pin: true,
           init_states: true,
-          label: 'Raw Pro2',
-          passphrase_protection: true,
+          passphrase_enabled: true,
         },
       },
     });
@@ -676,9 +724,9 @@ describe('Protocol V2 feature adapter', () => {
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features: {
         ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-        device_id: 'LEGACY-ID',
-        serial_no: 'LEGACY-SERIAL',
-        label: 'Legacy Pro2',
+        device_id: 'CACHED-ID',
+        serial_no: 'CACHED-SERIAL',
+        label: 'Cached Pro2',
         onekey_firmware_version: '1.2.3',
         onekey_ble_version: '2.3.4',
       },
@@ -689,13 +737,13 @@ describe('Protocol V2 feature adapter', () => {
     const result = await method.run();
 
     expect(typedCall).toHaveBeenCalledWith(
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: {
           hw: true,
           fw: true,
-          bt: true,
+          coprocessor: true,
           status: true,
         },
         types: {
@@ -708,12 +756,13 @@ describe('Protocol V2 feature adapter', () => {
     expect(result).toMatchObject({
       protocol: 'V2',
       deviceType: 'pro2',
-      deviceId: '',
+      deviceId: 'PRO2-BASIC-ID',
       serialNo: 'PR2SERIAL',
-      label: 'Raw Pro2',
+      label: null,
       bleName: 'Raw Pro2 BLE',
       status: {
         initialized: true,
+        unlockedAttachPin: true,
         passphraseProtection: true,
       },
       versions: {
@@ -723,7 +772,7 @@ describe('Protocol V2 feature adapter', () => {
     });
   });
 
-  test('does not fill Protocol V2 DeviceProfile from legacy features', async () => {
+  test('does not fill Protocol V2 DeviceProfile from cached V1-shaped fields', async () => {
     const typedCall = jest.fn().mockResolvedValueOnce({
       type: 'DeviceInfo',
       message: {
@@ -744,10 +793,10 @@ describe('Protocol V2 feature adapter', () => {
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features: {
         ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-        device_id: 'LEGACY-ID',
-        serial_no: 'LEGACY-SERIAL',
-        label: 'Legacy Pro2',
-        ble_name: 'Legacy BLE',
+        device_id: 'STALE-ID',
+        serial_no: 'STALE-SERIAL',
+        label: 'Stale Pro2',
+        ble_name: 'Stale BLE',
         passphrase_protection: true,
         onekey_firmware_version: '1.2.3',
         onekey_ble_version: '2.3.4',
@@ -759,7 +808,7 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(result).toMatchObject({
       protocol: 'V2',
-      // 身份字段不得取自 legacy features（LEGACY-ID / LEGACY-SERIAL），
+      // 身份字段不得取自缓存的 V1-shaped features（STALE-ID / STALE-SERIAL），
       // hw.serial_no 缺失时也不回退 descriptor.path。
       deviceId: '',
       serialNo: '',
@@ -802,13 +851,13 @@ describe('Protocol V2 feature adapter', () => {
     await method.run();
 
     expect(typedCall).toHaveBeenCalledWith(
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: {
           hw: true,
           fw: true,
-          bt: true,
+          coprocessor: true,
           se1: true,
           se2: true,
           se3: true,
@@ -832,12 +881,12 @@ describe('Protocol V2 feature adapter', () => {
       message: {
         hw: { serial_no: 'PR2SERIAL' },
         se1: {
-          app: { version: '1.0.1' },
-          boot: { version: '1.0.0' },
+          application: { version: '1.0.1' },
+          bootloader: { version: '1.0.0' },
         },
         se2: {
-          app: { version: '2.0.1' },
-          boot: { version: '2.0.0' },
+          application: { version: '2.0.1' },
+          bootloader: { version: '2.0.0' },
         },
         status: { init_states: true },
       },
@@ -859,13 +908,13 @@ describe('Protocol V2 feature adapter', () => {
     const result = await method.run();
 
     expect(typedCall).toHaveBeenCalledWith(
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: {
           hw: true,
           fw: true,
-          bt: true,
+          coprocessor: true,
           se1: true,
           se2: true,
           se3: true,
@@ -904,10 +953,23 @@ describe('Protocol V2 feature adapter', () => {
     expect(checkedTypes).toEqual(['pro2']);
   });
 
+  test('uses firmware-v1 as the Pro2 remote firmware config field', () => {
+    const features = normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any);
+
+    expect(
+      getFirmwareUpdateField({
+        features,
+        updateType: 'firmware',
+        firmwareType: 'universal',
+      })
+    ).toBe('firmware-v1');
+    expect(getFirmwareUpdateFieldArray(features, 'firmware')).toEqual(['firmware-v1']);
+  });
+
   test('marks known unsupported public-chain methods as unsupported on Protocol V2', () => {
     const features = normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
       fw: {
-        app: {
+        application: {
           version: '9.9.9',
         },
       },
@@ -957,7 +1019,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(isMethodVersionRangeUnsupported(neuraiRange)).toBe(true);
   });
 
-  test('does not block legacy batch public key support checks on Protocol V2', async () => {
+  test('does not block batch public key support checks on Protocol V2', async () => {
     const paths = [{ address_n: [0x8000002c, 0x80000000, 0x80000000] }] as any;
     const typedCall = jest.fn().mockResolvedValue({
       type: 'EcdsaPublicKeys',
@@ -971,7 +1033,7 @@ describe('Protocol V2 feature adapter', () => {
       originalDescriptor: { protocolType: 'V2' },
       features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
         fw: {
-          app: {
+          application: {
             version: '4.14.0',
           },
         },
@@ -993,7 +1055,7 @@ describe('Protocol V2 feature adapter', () => {
     });
   });
 
-  test('returns Protocol V2 oneKey fields without calling legacy OnekeyGetFeatures', async () => {
+  test('does not call V1 OnekeyGetFeatures for Protocol V2 devices', async () => {
     const method = new GetOnekeyFeatures({
       id: 1,
       payload: {
@@ -1005,9 +1067,9 @@ describe('Protocol V2 feature adapter', () => {
       message: {
         protocol_version: 1,
         hw: { serial_no: 'PR2SERIAL' },
-        fw: { app: { version: '1.2.3', build_id: 'app-build' } },
-        bt: { adv_name: 'Pro2 BLE' },
-        status: { label: 'ignored label' },
+        fw: { application: { version: '1.2.3', build_id: 'app-build' } },
+        coprocessor: { bt_adv_name: 'Pro2 BLE' },
+        status: { init_states: true },
       },
     });
 
@@ -1018,10 +1080,10 @@ describe('Protocol V2 feature adapter', () => {
 
     const message = await method.run();
 
-    // V2 走 DeviceGetDeviceInfo 完整请求（含 SE 与 hash/build_id），而不是 legacy OnekeyGetFeatures
+    // V2 走 DeviceInfoGet 完整请求（含 SE 与 hash/build_id），而不是 V1 OnekeyGetFeatures
     expect(typedCall).toHaveBeenCalledTimes(1);
     expect(typedCall).toHaveBeenCalledWith(
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       expect.objectContaining({
         targets: expect.objectContaining({ se1: true, se2: true, se3: true, se4: true }),
@@ -1029,13 +1091,7 @@ describe('Protocol V2 feature adapter', () => {
       }),
       expect.anything()
     );
-    expect(message).toMatchObject({
-      onekey_device_type: 'pro2',
-      onekey_firmware_version: '1.2.3',
-      onekey_firmware_build_id: 'app-build',
-      onekey_serial_no: 'PR2SERIAL',
-      onekey_ble_name: 'Pro2 BLE',
-    });
+    expect(message).toEqual({});
     expect(message).not.toHaveProperty('label');
   });
 
@@ -1050,9 +1106,10 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
-          fw: { app: { version: '1.2.3' } },
+          fw: { application: { version: '1.2.3' } },
           status: {
-            passphrase_protection: true,
+            device_id: 'PRO2-REFRESH-ID',
+            passphrase_enabled: true,
           },
         },
       })
@@ -1062,8 +1119,8 @@ describe('Protocol V2 feature adapter', () => {
         message: {
           hw: { serial_no: 'PR2SERIAL' },
           status: {
-            passphrase_protection: false,
-            label: 'renamed',
+            device_id: 'PRO2-REFRESH-ID',
+            passphrase_enabled: false,
           },
         },
       });
@@ -1074,27 +1131,27 @@ describe('Protocol V2 feature adapter', () => {
     await device.initialize();
 
     expect(device.features).toMatchObject({
-      device_id: null,
-      onekey_firmware_version: '1.2.3',
-      passphrase_protection: false,
-      label: 'renamed',
+      deviceId: 'PRO2-REFRESH-ID',
+      firmwareVersion: '1.2.3',
+      passphraseProtection: false,
+      label: null,
     });
     expect((device as any).profile).toBeUndefined();
     // status 字段被第二次刷新更新
-    expect(device.features?.passphrase_protection).toBe(false);
-    expect(device.features?.label).toBe('renamed');
+    expect(device.features?.passphraseProtection).toBe(false);
+    expect(device.features?.label).toBeNull();
     // 轻量刷新不含 fw target，已有版本信息按字段级合并保留
-    expect(device.features?.onekey_firmware_version).toBe('1.2.3');
+    expect(device.features?.firmwareVersion).toBe('1.2.3');
     expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenNthCalledWith(
       1,
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: {
           hw: true,
           fw: true,
-          bt: true,
+          coprocessor: true,
           status: true,
         },
         types: {
@@ -1106,15 +1163,15 @@ describe('Protocol V2 feature adapter', () => {
         timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
       }
     );
-    // 第二次为 status-only 轻量请求（hw/bt 仅用于身份字段，避免顶层覆盖清空）
+    // 第二次为 status-only 轻量请求（hw/coprocessor 仅用于身份字段，避免顶层覆盖清空）
     expect(typedCall).toHaveBeenNthCalledWith(
       2,
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: {
           hw: true,
-          bt: true,
+          coprocessor: true,
           status: true,
         },
         types: {
@@ -1128,7 +1185,7 @@ describe('Protocol V2 feature adapter', () => {
     );
   });
 
-  test('refreshes Protocol V2 features without falling back to legacy GetFeatures', async () => {
+  test('refreshes Protocol V2 features without falling back to V1 GetFeatures', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
@@ -1139,7 +1196,7 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
-          fw: { app: { version: '1.2.3' } },
+          fw: { application: { version: '1.2.3' } },
           status: { init_states: true },
         },
       })
@@ -1147,8 +1204,8 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
-          fw: { app: { version: '1.2.4' } },
-          status: { init_states: true, passphrase_protection: true },
+          fw: { application: { version: '1.2.4' } },
+          status: { init_states: true, passphrase_enabled: true },
         },
       });
 
@@ -1158,26 +1215,26 @@ describe('Protocol V2 feature adapter', () => {
     const features = await device.getFeatures();
 
     expect(device.features).toMatchObject({
-      device_id: null,
-      onekey_firmware_version: '1.2.4',
-      passphrase_protection: true,
+      deviceId: null,
+      firmwareVersion: '1.2.4',
+      passphraseProtection: true,
     });
     expect(features).toMatchObject({
-      onekey_device_type: 'pro2',
-      onekey_serial_no: 'PR2SERIAL',
-      onekey_firmware_version: '1.2.4',
-      passphrase_protection: true,
+      deviceType: 'pro2',
+      serialNo: 'PR2SERIAL',
+      firmwareVersion: '1.2.4',
+      passphraseProtection: true,
     });
     expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenNthCalledWith(
       2,
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: {
           hw: true,
           fw: true,
-          bt: true,
+          coprocessor: true,
           status: true,
         },
         types: {
@@ -1190,14 +1247,14 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).not.toHaveBeenCalledWith('GetFeatures', 'Features', {});
   });
 
-  test('keeps Protocol V2 features available for legacy method internals such as evmSignTypedData', async () => {
+  test('keeps Protocol V2 features available for method internals such as evmSignTypedData', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     const typedCall = jest.fn().mockResolvedValueOnce({
       type: 'DeviceInfo',
       message: {
         hw: { serial_no: 'PR2SERIAL' },
-        fw: { app: { version: '1.2.4' } },
-        status: { init_states: true, passphrase_protection: true },
+        fw: { application: { version: '1.2.4' } },
+        status: { init_states: true, passphrase_enabled: true },
       },
     });
     (device as any).commands = { typedCall };
@@ -1251,7 +1308,7 @@ describe('Protocol V2 feature adapter', () => {
       { ...descriptor, protocolType: 'V2' } as any,
       {
         hw: { serial_no: 'PR2SERIAL' },
-        fw: { app: { version: '1.2.3' } },
+        fw: { application: { version: '1.2.3' } },
         status: { init_states: true },
       }
     );
@@ -1262,9 +1319,9 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).not.toHaveBeenCalledWith('GetAddress', 'Address', expect.anything());
     expect(typedCall).not.toHaveBeenCalledWith('GetFeatures', 'Features', {});
     expect(features).toMatchObject({
-      onekey_device_type: 'pro2',
-      device_id: null,
-      onekey_firmware_version: '1.2.3',
+      deviceType: 'pro2',
+      deviceId: null,
+      firmwareVersion: '1.2.3',
       unlocked: true,
     });
   });
@@ -1275,14 +1332,15 @@ describe('Protocol V2 feature adapter', () => {
       { ...descriptor, protocolType: 'V2' } as any,
       {
         hw: { serial_no: 'PR2SERIAL' },
-        fw: { app: { version: '4.15.0' } },
-        status: { passphrase_protection: false },
+        fw: { application: { version: '4.15.0' } },
+        status: { passphrase_enabled: false },
       }
     );
     const typedCall = jest.fn().mockResolvedValue({
       type: 'UnLockDeviceResponse',
       message: {
         unlocked: true,
+        unlocked_attach_pin: true,
         passphrase_protection: true,
       },
     });
@@ -1291,7 +1349,8 @@ describe('Protocol V2 feature adapter', () => {
     await device.unlockDevice();
 
     expect((device as any).profile).toBeUndefined();
-    expect(device.features?.passphrase_protection).toBe(true);
+    expect(device.features?.passphraseProtection).toBe(true);
+    expect(device.features?.unlockedAttachPin).toBe(true);
   });
 });
 
@@ -1310,7 +1369,7 @@ describe('API compatibility handling', () => {
     method.init();
     (method as any).device = stubDevice({
       features: {
-        onekey_device_type: 'pro2',
+        deviceType: 'pro2',
       },
       originalDescriptor: {
         protocolType: 'V2',
@@ -1328,27 +1387,9 @@ describe('API compatibility handling', () => {
     );
   });
 
-  test('returns a typed unsupported error for Tron sign message V1 before device binding', () => {
-    const method = new TronSignMessage({
-      id: 1,
-      payload: {
-        method: 'tronSignMessage',
-        path: "m/44'/195'/0'/0/0",
-        messageHex: '0x1234',
-        messageType: 'V1',
-      },
-    });
-
-    expect(() => method.init()).toThrow(
-      expect.objectContaining({
-        errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-      })
-    );
-  });
-
-  test('does not mark Pro2 Tron, Solana, TON, SUI and Polkadot methods as unsupported', () => {
+  test('does not mark supported Pro2 Tron, Solana, TON, SUI and Polkadot methods as unsupported', () => {
     const features = {
-      onekey_device_type: 'pro2',
+      deviceType: 'pro2',
     } as Features;
 
     const tronMethod = new TronGetAddress({
@@ -1467,9 +1508,7 @@ describe('API compatibility handling', () => {
     });
     expect(
       getMethodVersionRange(features, type => tonSignDataMethod.getVersionRange()[type])
-    ).toEqual({
-      min: '0.0.0',
-    });
+    ).toBeUndefined();
     expect(
       getMethodVersionRange(features, type => suiGetAddressMethod.getVersionRange()[type])
     ).toEqual({
@@ -1499,7 +1538,7 @@ describe('API compatibility handling', () => {
 
   test('allows Pro2 Solana signing methods through Protocol V2 version checks', () => {
     const features = {
-      onekey_device_type: 'pro2',
+      deviceType: 'pro2',
     } as Features;
 
     const solSignMessageMethod = new SolSignMessage({
@@ -1563,15 +1602,6 @@ describe('API compatibility handling', () => {
     });
   });
 
-  test('includes TON signData in the Protocol V2 protobuf schema', () => {
-    const protocolV2Messages = DataManager.getProtobufMessages('v2Schema') as any;
-
-    expect(protocolV2Messages.nested.TonSignData).toBeDefined();
-    expect(protocolV2Messages.nested.TonSignedData).toBeDefined();
-    expect(protocolV2Messages.nested.MessageType.values.MessageType_TonSignData).toBe(11908);
-    expect(protocolV2Messages.nested.MessageType.values.MessageType_TonSignedData).toBe(11909);
-  });
-
   test('uses chunk transfer for large Sui transactions on Protocol V2', async () => {
     const rawTx = '0x'.concat('ab'.repeat(5000));
     const typedCall = jest.fn(() => ({
@@ -1593,7 +1623,7 @@ describe('API compatibility handling', () => {
     method.init();
     (method as any).device = stubDevice({
       features: {
-        onekey_device_type: 'pro2',
+        deviceType: 'pro2',
       },
       originalDescriptor: {
         protocolType: 'V2',
@@ -1616,54 +1646,6 @@ describe('API compatibility handling', () => {
     expect(params.data_initial_chunk).toHaveLength(2048);
   });
 
-  test('accepts string XRP payment amount values', () => {
-    const method = new XrpSignTransaction({
-      id: 1,
-      payload: {
-        method: 'xrpSignTransaction',
-        path: "m/44'/144'/0'/0/0",
-        transaction: {
-          fee: '100000',
-          flags: 2147483648,
-          sequence: 25,
-          maxLedgerVersion: 8820051,
-          payment: {
-            amount: '100000000',
-            destination: 'rBKz5MC2iXdoS3XgnNSYmF69K1Yo4NS3Ws',
-          },
-        },
-      },
-    });
-
-    expect(() => method.init()).not.toThrow();
-    expect(method.params.payment?.amount).toBe('100000000');
-  });
-
-  test('accepts Conflux base32 recipient addresses without hex formatting them', () => {
-    const to = 'cfx:aak2rra2njvd77ezwjvx04kkds9fzagfe6ku8scz91';
-    const method = new ConfluxSignTransaction({
-      id: 1,
-      payload: {
-        method: 'confluxSignTransaction',
-        path: "m/44'/503'/0'/0/0",
-        transaction: {
-          to,
-          value: '0x0',
-          data: '0x',
-          chainId: 1,
-          nonce: '0x00',
-          epochHeight: '0x00',
-          gasLimit: '0x5208',
-          storageLimit: '0x5208',
-          gasPrice: '0xbebc200',
-        },
-      },
-    });
-
-    expect(() => method.init()).not.toThrow();
-    expect(method.formattedTx?.to).toBe(to);
-  });
-
   test('returns a typed unsupported error for Dynex signing on Protocol V2', async () => {
     const method = new DnxSignTransaction({
       id: 1,
@@ -1719,7 +1701,41 @@ describe('API compatibility handling', () => {
 });
 
 describe('Protocol V2 firmware update targets', () => {
-  test('keeps Protocol V2 firmware updates off the legacy firmwareUpdateV3 path', async () => {
+  const OKPP_HEADER_SIZE = 0x52a0;
+
+  const buildOkppHeader = ({
+    type = 'RESC',
+    version = [1, 0, 0],
+    payloadHash = 'ab'.repeat(64),
+    headerHash = 'cd'.repeat(64),
+  }: {
+    type?: string;
+    version?: [number, number, number];
+    payloadHash?: string;
+    headerHash?: string;
+  } = {}) => {
+    const header = new Uint8Array(OKPP_HEADER_SIZE);
+    const view = new DataView(header.buffer);
+    'OKPP'.split('').forEach((char, index) => {
+      header[index] = char.charCodeAt(0);
+    });
+    view.setUint32(0x04, 1, true);
+    type.split('').forEach((char, index) => {
+      header[0x08 + index] = char.charCodeAt(0);
+    });
+    view.setUint32(0x0c, OKPP_HEADER_SIZE, true);
+    view.setUint32(0x10, version[0] * 0x10000 + version[1] * 0x100 + version[2], true);
+    const writeHex = (offset: number, hex: string) => {
+      for (let i = 0; i < hex.length / 2; i++) {
+        header[offset + i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+      }
+    };
+    writeHex(0x200, payloadHash);
+    writeHex(0x240, headerHash);
+    return header;
+  };
+
+  test('keeps Protocol V2 firmware updates off the firmwareUpdateV3 path', async () => {
     const method = new FirmwareUpdateV3({
       id: 1,
       payload: {
@@ -1733,25 +1749,26 @@ describe('Protocol V2 firmware update targets', () => {
     await expect(method.run()).rejects.toThrow('firmwareUpdateV4');
   });
 
-  test('uses Protocol V2 features after BLE final reconnect without legacy Initialize', async () => {
+  test('uses Protocol V2 features after BLE final reconnect without V1 Initialize', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
+        coprocessorBinary: new Uint8Array([1, 2, 3]).buffer,
       },
     });
     const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-session' });
     const typedCall = jest.fn().mockImplementation((name: string) => {
-      if (name === 'DevGetDeviceInfo') {
+      if (name === 'DeviceInfoGet') {
         return Promise.resolve({
           type: 'DeviceInfo',
           message: {
             fw: {
-              boot: { version: '0.0.0' },
-              app: { version: '0.0.0' },
+              bootloader: { version: '0.0.0' },
+              application: { version: '0.0.0' },
             },
-            bt: {
-              app: { version: '0.0.0' },
+            coprocessor: {
+              application: { version: '0.0.0' },
             },
           },
         });
@@ -1765,7 +1782,13 @@ describe('Protocol V2 firmware update targets', () => {
       originalDescriptor: { id: 'ble-id', path: 'ble-path', protocolType: 'V2' },
       deviceConnector: { acquire },
       getCommands: () => commands,
-      _updateFeatures: jest.fn(),
+      updateProtocolV2Features: jest.fn(() => ({
+        bootloaderMode: false,
+        mode: 'normal',
+        firmwareVersion: '0.0.0',
+        bootloaderVersion: '0.0.0',
+        bleVersion: '0.0.0',
+      })),
     });
 
     const versions = await (method as any).waitForProtocolV2FinalFeatures();
@@ -1774,13 +1797,13 @@ describe('Protocol V2 firmware update targets', () => {
     // 更新完成判定使用 VERSIONS 请求（含 SE targets），scope 与请求内容一致
     expect(typedCall).toHaveBeenNthCalledWith(
       1,
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: {
           hw: true,
           fw: true,
-          bt: true,
+          coprocessor: true,
           se1: true,
           se2: true,
           se3: true,
@@ -1803,7 +1826,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('skips automatic Protocol V2 bootloader entry before upload while boot flow is disabled', async () => {
+  test('enters Protocol V2 bootloader before upload', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -1816,14 +1839,15 @@ describe('Protocol V2 firmware update targets', () => {
       originalDescriptor: { id: 'ble-id', path: 'ble-path', protocolType: 'V2' },
       features: { capabilities: [] },
     });
-    (method as any).prepareResourceBinary = jest.fn().mockResolvedValue(null);
-    (method as any).prepareFirmwareAndBleBinary = jest.fn().mockResolvedValue([
+    (method as any).prepareResourceBinaries = jest.fn().mockResolvedValue([]);
+    (method as any).prepareBootloaderBinary = jest.fn().mockReturnValue(null);
+    (method as any).collectExplicitTargetBinaries = jest.fn().mockReturnValue([
       {
-        fileName: 'ble-firmware.bin',
+        fileName: 'coprocessor.bin',
         binary: new Uint8Array([1, 2, 3]).buffer,
+        targetId: 6,
       },
     ]);
-    (method as any).prepareBootloaderBinary = jest.fn().mockResolvedValue(null);
     (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
     (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
@@ -1837,17 +1861,18 @@ describe('Protocol V2 firmware update targets', () => {
 
     await method.run();
 
+    expect((method as any).enterProtocolV2BootloaderMode).toHaveBeenCalledTimes(1);
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
-      resourceBinary: null,
+      resourceBinaryMap: [],
       fwBinaryMap: [
         {
-          fileName: 'ble-firmware.bin',
+          fileName: 'coprocessor.bin',
           binary: expect.any(ArrayBuffer),
+          targetId: 6,
         },
       ],
       bootloaderBinary: null,
     });
-    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
   });
 
   test('reboots Protocol V2 normal-mode device to bootloader before transfer', async () => {
@@ -1857,31 +1882,70 @@ describe('Protocol V2 firmware update targets', () => {
         method: 'firmwareUpdateV4',
       },
     });
-    const acquire = jest.fn().mockResolvedValue(undefined);
     (method as any).device = stubDevice({
       originalDescriptor: { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
       features: { bootloader_mode: false, capabilities: [] },
       isBootloader: () => false,
-      acquire,
     });
     (method as any).protocolV2Reboot = jest.fn().mockResolvedValue({
       message: 'Device rebooted successfully',
     });
-    (method as any).checkDeviceToBootloader = jest.fn(() => {
-      (method as any).checkPromise = { promise: Promise.resolve(true) };
+    (method as any).checkDeviceToBootloader = jest.fn();
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceInfo',
+      message: protocolV2BootloaderDeviceInfo,
+    });
+    const reconnectProtocolV2Device = jest.fn().mockImplementation(() => {
+      (method as any).device.isBootloader = () => true;
+      return Promise.resolve();
     });
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    (method as any).device.getCommands = () => ({ typedCall });
     method.postTipMessage = jest.fn();
 
     await (method as any).enterProtocolV2BootloaderMode();
 
     expect(method.postTipMessage).toHaveBeenCalledWith('AutoRebootToBootloader');
-    expect((method as any).protocolV2Reboot).toHaveBeenCalledWith(DevRebootType.Bootloader);
+    expect((method as any).protocolV2Reboot).toHaveBeenCalledWith(DeviceRebootType.Bootloader);
     expect(method.postTipMessage).toHaveBeenCalledWith('GoToBootloaderSuccess');
-    expect((method as any).checkDeviceToBootloader).toHaveBeenCalledWith(undefined);
-    expect(acquire).toHaveBeenCalledTimes(1);
+    expect((method as any).checkDeviceToBootloader).not.toHaveBeenCalled();
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+  });
+
+  test('polls until Protocol V2 bootloader descriptor is ready after reboot', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'app-path', protocolType: 'V2' },
+      features: { bootloader_mode: false, capabilities: [] },
+      isBootloader: () => false,
+    });
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceInfo',
+      message: protocolV2BootloaderDeviceInfo,
+    });
+    const reconnectProtocolV2Device = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('Device not found'))
+      .mockRejectedValueOnce(new Error('Device not found'))
+      .mockImplementation(() => {
+        (method as any).device.isBootloader = () => true;
+        return Promise.resolve();
+      });
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    (method as any).device.getCommands = () => ({ typedCall });
+
+    await (method as any).waitForProtocolV2BootloaderMode(60 * 1000, 0);
+
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(3);
+    expect(typedCall).toHaveBeenCalledTimes(1);
   });
 
-  test('reboots Protocol V2 firmware flow back to normal before final feature polling', async () => {
+  test('reboots Protocol V2 firmware flow back to normal after install status is finished', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -1896,7 +1960,7 @@ describe('Protocol V2 firmware update targets', () => {
     await (method as any).exitProtocolV2BootloaderToNormal();
 
     expect(method.postTipMessage).toHaveBeenCalledWith('SwitchFirmwareReconnectDevice');
-    expect((method as any).protocolV2Reboot).toHaveBeenCalledWith(DevRebootType.Normal);
+    expect((method as any).protocolV2Reboot).toHaveBeenCalledWith(DeviceRebootType.Normal);
   });
 
   test('treats iOS BLE RxError 6 during Protocol V2 reboot as expected disconnect', async () => {
@@ -1916,7 +1980,7 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => ({ typedCall }),
     });
 
-    await expect((method as any).protocolV2Reboot(DevRebootType.Normal)).resolves.toEqual({
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Normal)).resolves.toEqual({
       message: 'Device rebooted successfully',
     });
   });
@@ -1936,7 +2000,7 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => ({ typedCall }),
     });
 
-    await expect((method as any).protocolV2Reboot(DevRebootType.Normal)).resolves.toEqual({
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Normal)).resolves.toEqual({
       message: 'Device rebooted successfully',
     });
   });
@@ -1964,191 +2028,1011 @@ describe('Protocol V2 firmware update targets', () => {
 
     await expect(
       (method as any).protocolV2StartFirmwareUpdate({
-        targets: [{ target_id: 0, path: 'vol1:firmware.bin' }],
+        targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
       })
     ).resolves.toBeUndefined();
 
     expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
   });
 
-  test('continues Protocol V2 install polling through temporary expected V2 probe failures', async () => {
+  test('continues Protocol V2 install polling when update request transfer times out', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest
-      .fn()
-      .mockRejectedValueOnce(
-        new Error(
-          'Device protocol mismatch: expected V2, but device did not respond to expected protocol'
-        )
-      )
-      .mockResolvedValueOnce({
-        type: 'DevFirmwareUpdateStatus',
-        message: {
-          targets: [{ target_id: 2, status: 0 }],
-        },
-      });
-    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    const typedCall = jest.fn().mockRejectedValue(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
-    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
-    method.postProgressMessage = jest.fn();
+    method.postTipMessage = jest.fn();
 
-    await (method as any).waitForProtocolV2FirmwareUpdateComplete([
-      { target_id: 2, path: 'vol1:ble-firmware.bin' },
-    ]);
+    await expect(
+      (method as any).protocolV2StartFirmwareUpdate({
+        targets: [{ target_id: 1, path: 'vol1:resource.bin' }],
+      })
+    ).resolves.toBeUndefined();
 
-    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
   });
 
-  test('uses dev firmware status semantics for Protocol V2 install polling', () => {
+  test('continues Protocol V2 install polling through temporary expected V2 probe failures', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    method.postProgressMessage = jest.fn();
-
-    const expectedTargetIds = new Set([3]);
+    const typedCall = jest.fn().mockImplementation((name: string) => {
+      if (name === 'DeviceFirmwareUpdateStatusGet') {
+        const callCount = typedCall.mock.calls.filter(call => call[0] === name).length;
+        if (callCount === 1) {
+          return Promise.reject(
+            new Error(
+              'Device protocol mismatch: expected V2, but device did not respond to expected protocol'
+            )
+          );
+        }
+        return Promise.resolve({
+          type: 'DeviceFirmwareUpdateStatus',
+          message: {
+            records: [{ target_id: 6, status: 2 }],
+          },
+        });
+      }
+      if (name === 'DeviceInfoGet') {
+        return Promise.reject(new Error('DeviceInfo not ready'));
+      }
+      if (name === 'Ping') {
+        return Promise.resolve({ type: 'Success', message: { message: 'ready' } });
+      }
+      return Promise.reject(new Error(`unexpected call ${name}`));
+    });
+    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
 
-    expect(
-      (method as any).assertProtocolV2TargetStatus(
-        [{ target_id: 3, status: 0 }],
-        expectedTargetIds
-      )
-    ).toBe(true);
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    method.postProgressMessage = jest.fn();
 
-    expect(
-      (method as any).assertProtocolV2TargetStatus(
-        [{ target_id: 3, status: 1 }],
-        expectedTargetIds
-      )
-    ).toBe(false);
-    expect(method.postProgressMessage).toHaveBeenCalledWith(99, 'installingFirmware');
+    await (method as any).waitForProtocolV2FirmwareUpdateComplete([
+      { target_id: 6, path: 'vol1:ble-firmware.bin' },
+    ]);
 
-    try {
-      (method as any).assertProtocolV2TargetStatus(
-        [{ target_id: 3, status: 2 }],
-        expectedTargetIds
-      );
-      throw new Error('Expected Protocol V2 failed firmware status to throw');
-    } catch (error: any) {
-      expect(error.errorCode).toBe(HardwareErrorCode.FirmwareError);
-    }
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceFirmwareUpdateStatusGet',
+      'DeviceInfoGet',
+      'Ping',
+      'DeviceFirmwareUpdateStatusGet',
+    ]);
   });
 
-  test('passes resource, bootloader, BLE, SE and app files to DeviceFirmwareUpdate targets', async () => {
+  test('treats Protocol V2 normal mode after reconnect as firmware update complete', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-
-    const writtenPaths: string[] = [];
-    method.postTipMessage = jest.fn();
-    method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockImplementation(params => {
-      writtenPaths.push(params.filePath);
-      return Number(params.processedSize ?? 0) + Number(params.payload.byteLength);
+    const typedCall = jest.fn().mockImplementation((name: string) => {
+      if (name === 'DeviceFirmwareUpdateStatusGet') {
+        return Promise.reject(new Error('Device disconnected'));
+      }
+      if (name === 'DeviceInfoGet') {
+        return Promise.resolve({
+          type: 'DeviceInfo',
+          message: {
+            hw: { serial_no: 'PR9999999999' },
+            fw: {
+              bootloader: { version: '9.9.9' },
+              application: { version: '9.9.9' },
+            },
+            status: {
+              device_id: 'PRO2-DEVICE-ID',
+              init_states: true,
+            },
+          },
+        });
+      }
+      return Promise.reject(new Error(`unexpected call ${name}`));
+    });
+    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    const updateProtocolV2Features = jest.fn((deviceInfo: ProtocolV2DeviceInfo) =>
+      normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, deviceInfo)
+    );
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      updateProtocolV2Features,
+    });
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (method as any).waitForProtocolV2FirmwareUpdateComplete([
+        { target_id: 3, path: 'vol1:bootloader.bin' },
+        { target_id: 4, path: 'vol1:application_p1.bin' },
+      ])
+    ).resolves.toBeUndefined();
+
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+    expect(updateProtocolV2Features).toHaveBeenCalledTimes(1);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceFirmwareUpdateStatusGet',
+      'DeviceInfoGet',
+    ]);
+  });
+
+  test('uses SDK decoded enum names for Protocol V2 install polling', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    method.postProgressMessage = jest.fn();
+
+    const expectedTargetIds = new Set([4]);
+
+    expect(
+      (method as any).assertProtocolV2TargetStatus([{ target_id: 4, status: 2 }], expectedTargetIds)
+    ).toBe(true);
+    expect(
+      (method as any).assertProtocolV2TargetStatus(
+        [{ target_id: 4, status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED' }],
+        expectedTargetIds
+      )
+    ).toBe(true);
+    expect(
+      (method as any).assertProtocolV2TargetStatus(
+        [
+          {
+            target_id: 'FW_MGMT_TARGET_CRATE',
+            status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+          },
+          { target_id: 'FW_MGMT_TARGET_SE04', status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED' },
+        ],
+        new Set([1, 10])
+      )
+    ).toBe(true);
+
+    expect(
+      (method as any).assertProtocolV2TargetStatus([{ target_id: 4, status: 1 }], expectedTargetIds)
+    ).toBe(false);
+    expect(
+      (method as any).assertProtocolV2TargetStatus(
+        [{ target_id: 4, status: 'FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS' }],
+        expectedTargetIds
+      )
+    ).toBe(false);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(99, 'installingFirmware');
+
+    try {
+      (method as any).assertProtocolV2TargetStatus(
+        [{ target_id: 4, status: 3 }],
+        expectedTargetIds
+      );
+      throw new Error('Expected Protocol V2 failed firmware status to throw');
+    } catch (error: any) {
+      expect(error.errorCode).toBe(HardwareErrorCode.FirmwareError);
+    }
+
+    try {
+      (method as any).assertProtocolV2TargetStatus(
+        [{ target_id: 4, status: 'FW_MGMT_UPDATER_TASK_STATUS_FAILED_VERIFY' }],
+        expectedTargetIds
+      );
+      throw new Error('Expected Protocol V2 failed firmware status to throw');
+    } catch (error: any) {
+      expect(error.errorCode).toBe(HardwareErrorCode.FirmwareError);
+    }
+  });
+
+  test('passes resource, bootloader, coprocessor, SE and app files to DeviceFirmwareUpdate targets', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+
+    const writtenPaths: string[] = [];
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockImplementation(params => {
+      writtenPaths.push(params.filePath);
+      return Number(params.processedSize ?? 0) + Number(params.payload.byteLength);
+    });
+    (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
+      .fn()
+      .mockResolvedValue(undefined);
+
+    await (method as any).executeProtocolV2Update({
+      resourceBinaryMap: [
+        {
+          fileName: 'resource.bin',
+          binary: new Uint8Array([1, 2, 3]).buffer,
+          targetId: 1,
+        },
+      ],
+      bootloaderBinary: new Uint8Array([4, 5]).buffer,
+      fwBinaryMap: [
+        {
+          fileName: 'coprocessor.bin',
+          binary: new Uint8Array([6]).buffer,
+          targetId: 6,
+        },
+        {
+          fileName: 'se01.bin',
+          binary: new Uint8Array([7]).buffer,
+          targetId: 7,
+        },
+        {
+          fileName: 'application_p1.bin',
+          binary: new Uint8Array([8]).buffer,
+          targetId: 4,
+        },
+      ],
+    });
+
+    expect(writtenPaths).toEqual([
+      'vol1:resource.bin',
+      'vol1:bootloader.bin',
+      'vol1:coprocessor.bin',
+      'vol1:se01.bin',
+      'vol1:application_p1.bin',
+    ]);
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(1, {
+      targets: [{ target_id: 1, path: 'vol1:resource.bin' }],
+    });
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(2, {
+      targets: [
+        { target_id: 3, path: 'vol1:bootloader.bin' },
+        { target_id: 6, path: 'vol1:coprocessor.bin' },
+        { target_id: 7, path: 'vol1:se01.bin' },
+        { target_id: 4, path: 'vol1:application_p1.bin' },
+      ],
+    });
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'transferData');
+    expect((method as any).waitForProtocolV2FirmwareUpdateComplete).toHaveBeenCalled();
+  });
+
+  test('passes explicit per-target binaries through without file name heuristics', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        applicationP2Binary: new Uint8Array([2]).buffer,
+        se04Binary: new Uint8Array([3]).buffer,
+      },
+    });
+    method.init();
+
+    const explicit = (method as any).collectExplicitTargetBinaries();
+    expect(explicit).toEqual([
+      { fileName: 'application_p2.bin', binary: expect.anything(), targetId: 5 },
+      { fileName: 'se04.bin', binary: expect.anything(), targetId: 10 },
+    ]);
+
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+    (method as any).protocolV2CommonUpdateProcess = jest
+      .fn()
+      .mockImplementation(params =>
+        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
+      );
+    (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
+      .fn()
+      .mockResolvedValue(undefined);
+
+    await (method as any).executeProtocolV2Update({
+      resourceBinaryMap: [],
+      bootloaderBinary: null,
+      fwBinaryMap: explicit,
+    });
+
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
+      targets: [
+        { target_id: 5, path: 'vol1:application_p2.bin' },
+        { target_id: 10, path: 'vol1:se04.bin' },
+      ],
+    });
+  });
+
+  test('maps explicit Pro2 resource crate binaries to separate CRATE targets', async () => {
+    const firstResource = new Uint8Array([1]).buffer;
+    const secondResource = new Uint8Array([2]).buffer;
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        resourceBinaries: [firstResource, secondResource],
+      },
+    });
+    method.init();
+
+    const resourceTargets = await (method as any).prepareResourceBinaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '1.0.0',
+      capabilities: [],
+    });
+
+    expect(resourceTargets).toEqual([
+      {
+        fileName: 'resource-1.bin',
+        binary: firstResource,
+        targetId: 1,
+      },
+      {
+        fileName: 'resource-2.bin',
+        binary: secondResource,
+        targetId: 1,
+      },
+    ]);
+    expect((method as any).hasExplicitProtocolV2Payload([])).toBe(true);
+  });
+
+  test('rejects romloaderBinary before sending a Protocol V2 update request', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        romloaderBinary: new Uint8Array([1]).buffer,
+      },
+    });
+    method.init();
+
+    expect(() => (method as any).collectExplicitTargetBinaries()).toThrow(
+      'FW_MGMT_TARGET_ROMLOADER is not accepted'
+    );
+  });
+
+  test('maps Pro2 remote firmware-v1 components to Protocol V2 targets in installOrder', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+
+    const binaries = new Map(
+      [
+        'bootloader',
+        'applicationP1',
+        'applicationP2',
+        'coprocessor',
+        'se01',
+        'se02',
+        'se03',
+        'se04',
+      ].map((key, index) => [
+        `https://example.com/${key}.pp.bin`,
+        new Uint8Array([index + 1]).buffer,
+      ])
+    );
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockImplementation(url =>
+        Promise.resolve({
+          binary: binaries.get(url) ?? new Uint8Array([0]).buffer,
+        })
+      );
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: 'https://example.com/applicationP1.pp.bin',
+        bootloaderResource: 'https://example.com/bootloader.pp.bin',
+        bootloaderVersion: [1, 0, 0],
+        displayBootloaderVersion: [1, 0, 0],
+        upgradeType: 'payload-package-set',
+        installOrder: [
+          'bootloader',
+          'applicationP1',
+          'applicationP2',
+          'coprocessor',
+          'se01',
+          'se02',
+          'se03',
+          'se04',
+        ],
+        components: {
+          bootloader: {
+            target: 'BOOTLOADER',
+            url: 'https://example.com/bootloader.pp.bin',
+          },
+          applicationP1: {
+            target: 'APPLICATION_P1',
+            url: 'https://example.com/applicationP1.pp.bin',
+          },
+          applicationP2: {
+            target: 'APPLICATION_P2',
+            url: 'https://example.com/applicationP2.pp.bin',
+          },
+          coprocessor: {
+            target: 'COPROCESSOR',
+            url: 'https://example.com/coprocessor.pp.bin',
+          },
+          se01: { target: 'SE01', url: 'https://example.com/se01.pp.bin' },
+          se02: { target: 'SE02', url: 'https://example.com/se02.pp.bin' },
+          se03: { target: 'SE03', url: 'https://example.com/se03.pp.bin' },
+          se04: { target: 'SE04', url: 'https://example.com/se04.pp.bin' },
+        },
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '0.0.0',
+    });
+
+    expect(remoteBinaries.bootloaderBinary).toBe(
+      binaries.get('https://example.com/bootloader.pp.bin')
+    );
+    expect(remoteBinaries.fwBinaryMap).toEqual([
+      { fileName: 'application_p1.bin', binary: expect.anything(), targetId: 4 },
+      { fileName: 'application_p2.bin', binary: expect.anything(), targetId: 5 },
+      { fileName: 'coprocessor.bin', binary: expect.anything(), targetId: 6 },
+      { fileName: 'se01.bin', binary: expect.anything(), targetId: 7 },
+      { fileName: 'se02.bin', binary: expect.anything(), targetId: 8 },
+      { fileName: 'se03.bin', binary: expect.anything(), targetId: 9 },
+      { fileName: 'se04.bin', binary: expect.anything(), targetId: 10 },
+    ]);
+    expect(getSysResourceBinarySpy.mock.calls.map(call => call[0])).toEqual([
+      'https://example.com/bootloader.pp.bin',
+      'https://example.com/applicationP1.pp.bin',
+      'https://example.com/applicationP2.pp.bin',
+      'https://example.com/coprocessor.pp.bin',
+      'https://example.com/se01.pp.bin',
+      'https://example.com/se02.pp.bin',
+      'https://example.com/se03.pp.bin',
+      'https://example.com/se04.pp.bin',
+    ]);
+
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('skips Pro2 resource crate download when resourceManifest matches device OKPP headers', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+
+    const payloadHash = 'ab'.repeat(64);
+    const header = buildOkppHeader({ payloadHash });
+    const typedCall = jest.fn(
+      (name: string, _resType: string, params: { file: { offset: number }; chunk_len: number }) => {
+        if (name === 'FilesystemPathInfoQuery') {
+          return Promise.resolve({
+            type: 'FilesystemPathInfo',
+            message: { exist: true, directory: false, size: header.byteLength },
+          });
+        }
+        if (name === 'FilesystemFileRead') {
+          const { offset } = params.file;
+          const readLen = params.chunk_len;
+          return Promise.resolve({
+            type: 'FilesystemFile',
+            message: { data: header.slice(offset, offset + readLen) },
+          });
+        }
+        return Promise.reject(new Error(`unexpected call ${name}`));
+      }
+    );
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockResolvedValue({ binary: new Uint8Array([9]).buffer });
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        upgradeType: 'payload-package-set',
+        installOrder: ['resource'],
+        components: {
+          resource: {
+            target: 'CRATE',
+            url: 'https://example.com/pro2-resource.crate.okpkg',
+          },
+        },
+        resourceManifest: {
+          format: 'okpkg-crate',
+          target: 'CRATE',
+          version: [1, 0, 0],
+          packages: [
+            {
+              path: 'resource/images/images.okpkg',
+              type: 'RESC',
+              payloadHash,
+            },
+          ],
+        },
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '1.0.0',
+      capabilities: [],
+    });
+
+    expect(remoteBinaries).toEqual({
+      resourceBinaryMap: [],
+      bootloaderBinary: null,
+      fwBinaryMap: [],
+    });
+    expect(getSysResourceBinarySpy).not.toHaveBeenCalled();
+    expect(typedCall.mock.calls[0][2]).toEqual({
+      path: 'vol0:/resource/images/images.okpkg',
+    });
+
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('downloads Pro2 resource crate when resourceManifest package is missing', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+
+    const resourceBinary = new Uint8Array([9]).buffer;
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'FilesystemPathInfo',
+      message: { exist: false, directory: false, size: 0 },
+    });
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockResolvedValue({ binary: resourceBinary });
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        upgradeType: 'payload-package-set',
+        installOrder: ['resource'],
+        components: {
+          resource: {
+            target: 'CRATE',
+            url: 'https://example.com/pro2-resource.crate.okpkg',
+            resourceManifest: {
+              format: 'okpkg-crate',
+              target: 'CRATE',
+              version: [1, 0, 0],
+              packages: [{ path: 'resource/images/images.okpkg', type: 'RESC' }],
+            },
+          },
+        },
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '1.0.0',
+      capabilities: [],
+    });
+
+    expect(remoteBinaries.resourceBinaryMap).toEqual([
+      {
+        fileName: 'resource-resource.bin',
+        binary: resourceBinary,
+        targetId: 1,
+      },
+    ]);
+    expect(getSysResourceBinarySpy).toHaveBeenCalledWith(
+      'https://example.com/pro2-resource.crate.okpkg'
+    );
+
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('maps Pro2 CRATE remote component to resource binary target', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+
+    const resourceBinary = new Uint8Array([1, 2, 3]).buffer;
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockResolvedValue({ binary: resourceBinary });
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        upgradeType: 'payload-package-set',
+        installOrder: ['resource'],
+        components: {
+          resource: {
+            target: 'CRATE',
+            url: 'https://example.com/pro2-resource.crate.okpkg',
+          },
+        },
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '0.0.0',
+      capabilities: [],
+    });
+
+    expect(remoteBinaries).toEqual({
+      resourceBinaryMap: [
+        {
+          fileName: 'resource-resource.bin',
+          binary: resourceBinary,
+          targetId: 1,
+        },
+      ],
+      bootloaderBinary: null,
+      fwBinaryMap: [],
+    });
+
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('downloads only unmatched Pro2 resource crate components by component manifests', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+
+    const imagesPayloadHash = 'ab'.repeat(64);
+    const imagesHeader = buildOkppHeader({ payloadHash: imagesPayloadHash });
+    const fontsBinary = new Uint8Array([7, 8, 9]).buffer;
+    const typedCall = jest.fn(
+      (
+        name: string,
+        _resType: string,
+        params: { path?: string; file?: { offset: number }; chunk_len?: number }
+      ) => {
+        if (name === 'FilesystemPathInfoQuery') {
+          const exist = params.path === 'vol0:/resource/images/images.okpkg';
+          return Promise.resolve({
+            type: 'FilesystemPathInfo',
+            message: { exist, directory: false, size: exist ? imagesHeader.byteLength : 0 },
+          });
+        }
+        if (name === 'FilesystemFileRead') {
+          const offset = params.file?.offset ?? 0;
+          const readLen = params.chunk_len ?? 0;
+          return Promise.resolve({
+            type: 'FilesystemFile',
+            message: { data: imagesHeader.slice(offset, offset + readLen) },
+          });
+        }
+        return Promise.reject(new Error(`unexpected call ${name}`));
+      }
+    );
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockResolvedValue({ binary: fontsBinary });
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        upgradeType: 'payload-package-set',
+        installOrder: ['resourceImages', 'resourceFonts'],
+        components: {
+          resourceImages: {
+            target: 'CRATE',
+            url: 'https://example.com/pro2-resource-images.crate.okpkg',
+            resourceManifest: {
+              format: 'okpkg-crate',
+              target: 'CRATE',
+              version: [1, 0, 0],
+              packages: [
+                {
+                  path: 'resource/images/images.okpkg',
+                  type: 'RESC',
+                  payloadHash: imagesPayloadHash,
+                },
+              ],
+            },
+          },
+          resourceFonts: {
+            target: 'CRATE',
+            url: 'https://example.com/pro2-resource-fonts.crate.okpkg',
+            resourceManifest: {
+              format: 'okpkg-crate',
+              target: 'CRATE',
+              version: [1, 0, 0],
+              packages: [{ path: 'resource/font/noto.okpkg', type: 'RESC' }],
+            },
+          },
+        },
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '1.0.0',
+      capabilities: [],
+    });
+
+    expect(remoteBinaries.resourceBinaryMap).toEqual([
+      {
+        fileName: 'resource-resourceFonts.bin',
+        binary: fontsBinary,
+        targetId: 1,
+      },
+    ]);
+    expect(getSysResourceBinarySpy).toHaveBeenCalledTimes(1);
+    expect(getSysResourceBinarySpy).toHaveBeenCalledWith(
+      'https://example.com/pro2-resource-fonts.crate.okpkg'
+    );
+
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('installs multiple Pro2 resource crates as separate update requests', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
     });
+
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+    (method as any).protocolV2CommonUpdateProcess = jest
+      .fn()
+      .mockImplementation(params =>
+        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
+      );
     (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
       .fn()
       .mockResolvedValue(undefined);
 
     await (method as any).executeProtocolV2Update({
-      // resource 只支持单文件 .bin，整文件一次上传
-      resourceBinary: new Uint8Array([1, 2, 3]).buffer,
-      bootloaderBinary: new Uint8Array([4, 5]).buffer,
-      fwBinaryMap: [
+      resourceBinaryMap: [
         {
-          fileName: 'ble-firmware.bin',
-          binary: new Uint8Array([6]).buffer,
+          fileName: 'resource-images.bin',
+          binary: new Uint8Array([1]).buffer,
+          targetId: 1,
         },
         {
-          fileName: 'se1-firmware.bin',
-          binary: new Uint8Array([7]).buffer,
+          fileName: 'resource-fonts.bin',
+          binary: new Uint8Array([2]).buffer,
+          targetId: 1,
         },
+      ],
+      bootloaderBinary: null,
+      fwBinaryMap: [
         {
-          fileName: 'firmware.bin',
-          binary: new Uint8Array([8]).buffer,
+          fileName: 'application_p1.bin',
+          binary: new Uint8Array([3]).buffer,
+          targetId: 4,
         },
       ],
     });
 
-    expect(writtenPaths).toEqual([
-      'vol1:resource.bin',
-      'vol1:bootloader.bin',
-      'vol1:ble-firmware.bin',
-      'vol1:se1-firmware.bin',
-      'vol1:firmware.bin',
-    ]);
-    // DevFirmwareTargetType：RESOURCE=10, MAIN_BOOT=1, BT=2, SE1=3, MAIN_APP=0
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
-      targets: [
-        { target_id: 10, path: 'vol1:resource.bin' },
-        { target_id: 1, path: 'vol1:bootloader.bin' },
-        { target_id: 2, path: 'vol1:ble-firmware.bin' },
-        { target_id: 3, path: 'vol1:se1-firmware.bin' },
-        { target_id: 0, path: 'vol1:firmware.bin' },
-      ],
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(1, {
+      targets: [{ target_id: 1, path: 'vol1:resource-images.bin' }],
+    });
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(2, {
+      targets: [{ target_id: 1, path: 'vol1:resource-fonts.bin' }],
+    });
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(3, {
+      targets: [{ target_id: 4, path: 'vol1:application_p1.bin' }],
     });
-    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'transferData');
-    expect((method as any).waitForProtocolV2FirmwareUpdateComplete).toHaveBeenCalled();
   });
 
-  test('passes explicit per-target binaries through without file name heuristics', async () => {
+  test('skips Pro2 firmware components when configured versions are already installed', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
-        romloaderBinary: new Uint8Array([1]).buffer,
-        applicationP2Binary: new Uint8Array([2]).buffer,
-        se04Binary: new Uint8Array([3]).buffer,
       },
     });
     method.init();
 
-    const explicit = (method as any).collectExplicitTargetBinaries();
-    expect(explicit).toEqual([
-      { fileName: 'romloader.bin', binary: expect.anything(), targetId: 1 },
-      { fileName: 'application_p2.bin', binary: expect.anything(), targetId: 0 },
-      { fileName: 'se04.bin', binary: expect.anything(), targetId: 6 },
-    ]);
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockResolvedValue({ binary: new Uint8Array([1]).buffer });
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: 'https://example.com/applicationP1.pp.bin',
+        bootloaderVersion: [1, 0, 0],
+        upgradeType: 'payload-package-set',
+        installOrder: ['bootloader', 'applicationP1', 'applicationP2'],
+        components: {
+          bootloader: {
+            target: 'BOOTLOADER',
+            url: 'https://example.com/bootloader.pp.bin',
+          },
+          applicationP1: {
+            target: 'APPLICATION_P1',
+            url: 'https://example.com/applicationP1.pp.bin',
+          },
+          applicationP2: {
+            target: 'APPLICATION_P2',
+            url: 'https://example.com/applicationP2.pp.bin',
+          },
+        },
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
 
-    method.postTipMessage = jest.fn();
-    method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest
-      .fn()
-      .mockImplementation(params =>
-        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
-      );
-    (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
-    (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
-      .fn()
-      .mockResolvedValue(undefined);
+    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '1.0.0',
+      bootloaderVersion: '1.0.0',
+      capabilities: [],
+    });
 
-    await (method as any).executeProtocolV2Update({
-      resourceBinary: null,
+    expect(remoteBinaries).toEqual({
+      resourceBinaryMap: [],
       bootloaderBinary: null,
-      fwBinaryMap: explicit,
+      fwBinaryMap: [],
     });
+    expect(getSysResourceBinarySpy).not.toHaveBeenCalled();
 
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
-      targets: [
-        { target_id: 1, path: 'vol1:romloader.bin' },
-        { target_id: 0, path: 'vol1:application_p2.bin' },
-        { target_id: 6, path: 'vol1:se04.bin' },
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('uses Pro2 remote components when firmwareUpdateV4 has no explicit binaries', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+
+    const remoteBinaries = {
+      resourceBinaryMap: [],
+      bootloaderBinary: new Uint8Array([1]).buffer,
+      fwBinaryMap: [
+        {
+          fileName: 'application_p1.bin',
+          binary: new Uint8Array([2]).buffer,
+          targetId: 4,
+        },
       ],
+    };
+
+    (method as any).device = stubDevice({
+      originalDescriptor: { protocolType: 'V2' },
+      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
+    });
+    (method as any).prepareResourceBinaries = jest.fn().mockResolvedValue([]);
+    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue(remoteBinaries);
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(true);
+    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
+      bootloaderVersion: '1.0.0',
+      bleVersion: '0.0.0',
+      firmwareVersion: '1.0.0',
+    });
+    method.postTipMessage = jest.fn();
+
+    await method.run();
+
+    expect((method as any).prepareRemoteProtocolV2Binaries).toHaveBeenCalledTimes(1);
+    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
+      resourceBinaryMap: remoteBinaries.resourceBinaryMap,
+      bootloaderBinary: remoteBinaries.bootloaderBinary,
+      fwBinaryMap: remoteBinaries.fwBinaryMap,
+    });
+  });
+
+  test('keeps explicit Protocol V2 binaries isolated from remote component auto-fill', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        coprocessorBinary: new Uint8Array([1]).buffer,
+      },
+    });
+    method.init();
+
+    (method as any).device = stubDevice({
+      originalDescriptor: { protocolType: 'V2' },
+      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
+    });
+    (method as any).prepareResourceBinaries = jest.fn().mockResolvedValue([]);
+    (method as any).prepareRemoteProtocolV2Binaries = jest.fn();
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(true);
+    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
+      bootloaderVersion: '1.0.0',
+      bleVersion: '0.0.0',
+      firmwareVersion: '1.0.0',
+    });
+    method.postTipMessage = jest.fn();
+
+    await method.run();
+
+    expect((method as any).prepareRemoteProtocolV2Binaries).not.toHaveBeenCalled();
+    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
+      resourceBinaryMap: [],
+      bootloaderBinary: null,
+      fwBinaryMap: [{ fileName: 'coprocessor.bin', binary: expect.anything(), targetId: 6 }],
     });
   });
 
@@ -2186,10 +3070,11 @@ describe('Protocol V2 firmware update targets', () => {
     });
 
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
-    expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 4096]);
-    expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([4096, 1]);
+    expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 4000]);
+    expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([4000, 97]);
     expect(writePayloads.map(payload => payload.overwrite)).toEqual([true, false]);
     expect(writePayloads.every(payload => payload.append === false)).toBe(true);
+    expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 100]);
   });
 
   test('continues to DeviceFirmwareUpdate when FilesystemFileWrite returns processed chunk length', async () => {
@@ -2208,9 +3093,17 @@ describe('Protocol V2 firmware update targets', () => {
           },
         });
       }
-      if (name === 'DevFirmwareUpdate') {
+      if (name === 'DeviceFirmwareUpdateRequest') {
         return Promise.resolve({ type: 'Success', message: { message: 'ok' } });
       }
+      if (name === 'DeviceFirmwareUpdateStatusGet') {
+        return Promise.resolve({
+          type: 'DeviceFirmwareUpdateStatus',
+          message: {
+            records: [{ target_id: 4, status: 2 }],
+          },
+        });
+      }
       return Promise.reject(new Error(`unexpected call ${name}`));
     });
 
@@ -2221,21 +3114,22 @@ describe('Protocol V2 firmware update targets', () => {
     method.postTipMessage = jest.fn();
 
     await (method as any).executeProtocolV2Update({
-      resourceBinary: null,
+      resourceBinaryMap: [],
       bootloaderBinary: null,
       fwBinaryMap: [
         {
           fileName: 'firmware.bin',
           binary: new Uint8Array(4097).buffer,
+          targetId: 4,
         },
       ],
     });
 
     expect(typedCall).toHaveBeenCalledWith(
-      'DevFirmwareUpdate',
-      ['Success', 'DevFirmwareUpdateStatus'],
+      'DeviceFirmwareUpdateRequest',
+      ['Success', 'DeviceFirmwareUpdateStatus'],
       {
-        targets: [{ target_id: 0, path: 'vol1:firmware.bin' }],
+        targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
       },
       expect.any(Object)
     );
@@ -2281,6 +3175,7 @@ describe('Protocol V2 firmware update targets', () => {
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
     expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 1800]);
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1800, 1]);
+    expect(writePayloads.map(payload => payload.ui_percentage)).toEqual([0, 100]);
   });
 
   test('consumes Protocol V2 install progress before final update success', async () => {
@@ -2299,18 +3194,18 @@ describe('Protocol V2 firmware update targets', () => {
     method.postTipMessage = jest.fn();
 
     await (method as any).protocolV2StartFirmwareUpdate({
-      targets: [{ target_id: 0, path: 'vol1:firmware.bin' }],
+      targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
     });
 
     const callOptions = typedCall.mock.calls[0][3];
-    expect(typedCall.mock.calls[0][1]).toEqual(['Success', 'DevFirmwareUpdateStatus']);
-    expect(callOptions.intermediateTypes).toEqual(['DevFirmwareInstallProgress']);
+    expect(typedCall.mock.calls[0][1]).toEqual(['Success', 'DeviceFirmwareUpdateStatus']);
+    expect(callOptions.intermediateTypes).toEqual(['DeviceFirmwareUpdateStatus']);
     callOptions.onIntermediateResponse({
-      type: 'DevFirmwareInstallProgress',
-      message: { target_id: 0, progress: 42 },
+      type: 'DeviceFirmwareUpdateStatus',
+      message: { records: [{ target_id: 4, status: 1 }] },
     });
 
-    expect(method.postProgressMessage).toHaveBeenCalledWith(42, 'installingFirmware');
+    expect(method.postProgressMessage).toHaveBeenCalledWith(99, 'installingFirmware');
   });
 
   test('accepts Protocol V2 firmware update status as start response', async () => {
@@ -2321,8 +3216,8 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'DevFirmwareUpdateStatus',
-      message: { targets: [{ target_id: 0, status: 1 }] },
+      type: 'DeviceFirmwareUpdateStatus',
+      message: { records: [{ target_id: 4, status: 1 }] },
     });
 
     (method as any).device = stubDevice({
@@ -2332,29 +3227,29 @@ describe('Protocol V2 firmware update targets', () => {
     method.postTipMessage = jest.fn();
 
     await (method as any).protocolV2StartFirmwareUpdate({
-      targets: [{ target_id: 0, path: 'vol1:firmware.bin' }],
+      targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
     });
 
-    expect(typedCall.mock.calls[0][1]).toEqual(['Success', 'DevFirmwareUpdateStatus']);
+    expect(typedCall.mock.calls[0][1]).toEqual(['Success', 'DeviceFirmwareUpdateStatus']);
     expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
   });
 });
 
 describe('Protocol V2 firmware update method', () => {
-  test('returns DevFirmwareUpdateStatus from low-level update trigger', async () => {
+  test('returns DeviceFirmwareUpdateStatus from low-level update trigger', async () => {
     const method = new DeviceFirmwareUpdate({
       id: 1,
       payload: {
         method: 'deviceFirmwareUpdate',
-        targetId: 0,
+        targetId: 4,
         path: 'vol0:firmware.bin',
       },
     });
     method.init();
 
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'DevFirmwareUpdateStatus',
-      message: { targets: [{ target_id: 0, status: 1 }] },
+      type: 'DeviceFirmwareUpdateStatus',
+      message: { records: [{ target_id: 4, status: 1 }] },
     });
 
     (method as any).device = stubDevice({
@@ -2362,11 +3257,11 @@ describe('Protocol V2 firmware update method', () => {
     });
 
     await expect(method.run()).resolves.toEqual({
-      targets: [{ target_id: 0, status: 1 }],
+      records: [{ target_id: 4, status: 1 }],
     });
-    expect(typedCall.mock.calls[0][1]).toEqual(['Success', 'DevFirmwareUpdateStatus']);
+    expect(typedCall.mock.calls[0][1]).toEqual(['Success', 'DeviceFirmwareUpdateStatus']);
     expect(typedCall.mock.calls[0][2]).toEqual({
-      targets: [{ target_id: 0, path: 'vol0:firmware.bin' }],
+      targets: [{ target_id: 4, path: 'vol0:firmware.bin' }],
     });
   });
 
@@ -2375,7 +3270,7 @@ describe('Protocol V2 firmware update method', () => {
       id: 1,
       payload: {
         method: 'deviceFirmwareUpdate',
-        targetId: 0,
+        targetId: 4,
         path: 'vol0:firmware.bin',
       },
     });
@@ -2429,7 +3324,7 @@ describe('Protocol V2 firmware update method', () => {
         targets: [
           {
             target_id: undefined,
-            targetId: 3,
+            targetId: 4,
             path: 'vol0:firmware.bin',
           },
         ],
@@ -2442,31 +3337,33 @@ describe('Protocol V2 firmware update method', () => {
 
     await method.run();
     expect(typedCall.mock.calls[0][2]).toEqual({
-      targets: [{ target_id: 3, path: 'vol0:firmware.bin' }],
+      targets: [{ target_id: 4, path: 'vol0:firmware.bin' }],
     });
   });
-});
 
-describe('Protocol V2 reboot methods', () => {
-  test('sends DevReboot from devReboot', async () => {
-    const typedCall = jest.fn().mockResolvedValue({ message: { message: 'ok' } });
-    const method = new DevReboot({
+  test('accepts firmware target enum names from low-level update params', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: {} });
+    const method = new DeviceFirmwareUpdate({
       id: 1,
       payload: {
-        method: 'devReboot',
-        rebootType: 2,
+        method: 'deviceFirmwareUpdate',
+        targetId: 'FW_MGMT_TARGET_CRATE',
+        path: 'vol0:resource.bin',
       },
     });
     method.init();
-    (method as any).device = stubDevice({ commands: { typedCall } });
+    (method as any).device = stubDevice({
+      commands: { typedCall },
+    });
 
     await method.run();
-
-    expect(typedCall).toHaveBeenCalledWith('DevReboot', 'Success', {
-      reboot_type: 2,
+    expect(typedCall.mock.calls[0][2]).toEqual({
+      targets: [{ target_id: 1, path: 'vol0:resource.bin' }],
     });
   });
+});
 
+describe('Protocol V2 reboot methods', () => {
   test('sends DeviceReboot from deviceReboot', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: { message: 'ok' } });
     const method = new DeviceReboot({
@@ -2487,12 +3384,80 @@ describe('Protocol V2 reboot methods', () => {
   });
 });
 
+describe('Protocol V2 current low-level methods', () => {
+  test('sends ProtocolInfoRequest from protocolInfoRequest', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: { version: 1 } });
+    const method = new ProtocolInfoRequest({
+      id: 1,
+      payload: { method: 'protocolInfoRequest' },
+    });
+    method.init();
+    (method as any).device = stubDevice({ commands: { typedCall } });
+
+    await method.run();
+
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {});
+  });
+
+  test('sends DeviceFactoryInfoSet and DeviceFactoryInfoGet', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: {} });
+    const setMethod = new DeviceFactoryInfoSet({
+      id: 1,
+      payload: {
+        method: 'deviceFactoryInfoSet',
+        serial_number: 'PR2SERIAL',
+        burn_in_completed: true,
+      },
+    });
+    setMethod.init();
+    (setMethod as any).device = stubDevice({ commands: { typedCall } });
+
+    await setMethod.run();
+
+    expect(typedCall).toHaveBeenCalledWith('DeviceFactoryInfoSet', 'Success', {
+      info: {
+        version: undefined,
+        serial_number: 'PR2SERIAL',
+        burn_in_completed: true,
+        factory_test_completed: undefined,
+        manufacture_time: undefined,
+      },
+    });
+
+    typedCall.mockResolvedValueOnce({ message: { serial_number: 'PR2SERIAL' } });
+    const getMethod = new DeviceFactoryInfoGet({
+      id: 2,
+      payload: { method: 'deviceFactoryInfoGet' },
+    });
+    getMethod.init();
+    (getMethod as any).device = stubDevice({ commands: { typedCall } });
+
+    await getMethod.run();
+
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceFactoryInfoGet', 'DeviceFactoryInfo', {});
+  });
+
+  test('sends FilesystemPermissionFix from filesystemPermissionFix', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: {} });
+    const method = new FilesystemPermissionFix({
+      id: 1,
+      payload: { method: 'filesystemPermissionFix' },
+    });
+    method.init();
+    (method as any).device = stubDevice({ commands: { typedCall } });
+
+    await method.run();
+
+    expect(typedCall).toHaveBeenCalledWith('FilesystemPermissionFix', 'Success', {});
+  });
+});
+
 describe('Protocol V2 raw device info method', () => {
   const buildMethod = (payload: Record<string, unknown> = {}) => {
-    const method = new DeviceGetDeviceInfo({
+    const method = new DeviceInfoGet({
       id: 1,
       payload: {
-        method: 'deviceGetDeviceInfo',
+        method: 'deviceInfoGet',
         ...payload,
       },
     });
@@ -2502,7 +3467,7 @@ describe('Protocol V2 raw device info method', () => {
 
   test('passes requested targets/types through and returns the raw DeviceInfo message', async () => {
     const method = buildMethod({
-      targets: { hw: true, se1: true, junk: true },
+      targets: { hw: true, se1: true },
       types: { version: true, hash: true },
     });
     const typedCall = jest.fn().mockResolvedValue({
@@ -2518,9 +3483,8 @@ describe('Protocol V2 raw device info method', () => {
       protocol_version: 1,
       hw: { serial_no: 'PR2SERIAL' },
     });
-    // 未知 key（junk）被过滤，已选 key 原样透传，不构建 DeviceProfile
     expect(typedCall).toHaveBeenCalledWith(
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: { hw: true, se1: true },
@@ -2530,6 +3494,20 @@ describe('Protocol V2 raw device info method', () => {
     );
   });
 
+  test('rejects removed target/type names before transport call', () => {
+    expect(() =>
+      buildMethod({
+        targets: { hw: true, bt: true },
+      })
+    ).toThrow('targets');
+
+    expect(() =>
+      buildMethod({
+        types: { version: true, digest: true },
+      })
+    ).toThrow('types');
+  });
+
   test('defaults to the basic targets/types when none are given', async () => {
     const method = buildMethod();
     const typedCall = jest.fn().mockResolvedValue({ type: 'DeviceInfo', message: {} });
@@ -2541,10 +3519,10 @@ describe('Protocol V2 raw device info method', () => {
     await method.run();
 
     expect(typedCall).toHaveBeenCalledWith(
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
-        targets: { hw: true, fw: true, bt: true, status: true },
+        targets: { hw: true, fw: true, coprocessor: true, status: true },
         types: { version: true, specific: true },
       },
       { timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS }
@@ -2564,48 +3542,6 @@ describe('Protocol V2 raw device info method', () => {
   });
 });
 
-describe('Protocol V2 onboarding status method', () => {
-  test('returns OnboardingStatus from low-level status query', async () => {
-    const method = new DeviceGetOnboardingStatus({
-      id: 1,
-      payload: {
-        method: 'deviceGetOnboardingStatus',
-      },
-    });
-    method.init();
-
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'OnboardingStatus',
-      message: {
-        step: 3,
-        setup: {
-          restore: {
-            mnemonic: true,
-          },
-        },
-        detail_code: 7,
-        detail_str: 'Recovery Phrase',
-      },
-    });
-
-    (method as any).device = stubDevice({
-      commands: { typedCall },
-    });
-
-    await expect(method.run()).resolves.toEqual({
-      step: 3,
-      setup: {
-        restore: {
-          mnemonic: true,
-        },
-      },
-      detail_code: 7,
-      detail_str: 'Recovery Phrase',
-    });
-    expect(typedCall).toHaveBeenCalledWith('GetOnboardingStatus', 'OnboardingStatus', {});
-  });
-});
-
 describe('Protocol V2 file write method', () => {
   test('rejects invalid write parameters before transport call', () => {
     expect(() => {
@@ -2655,17 +3591,22 @@ describe('Protocol V2 file write method', () => {
     method.init();
     await method.run();
 
-    expect(typedCall).toHaveBeenCalledWith('FilesystemFileWrite', 'FilesystemFile', {
-      file: {
-        path: 'vol1:test.bin',
-        offset: 1,
-        total_size: 2,
-        data: new Uint8Array([1]),
+    expect(typedCall).toHaveBeenCalledWith(
+      'FilesystemFileWrite',
+      'FilesystemFile',
+      {
+        file: {
+          path: 'vol1:test.bin',
+          offset: 1,
+          total_size: 2,
+          data: new Uint8Array([1]),
+        },
+        overwrite: false,
+        append: false,
+        ui_percentage: 100,
       },
-      overwrite: false,
-      append: false,
-      ui_percentage: 99,
-    }, { timeoutMs: undefined });
+      { timeoutMs: undefined }
+    );
     expect(method.postMessage).toHaveBeenCalledWith({
       event: 'UI_EVENT',
       type: UI_REQUEST.DEVICE_PROGRESS,
@@ -2698,28 +3639,40 @@ describe('Protocol V2 file write method', () => {
     const result = await method.run();
 
     expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenNthCalledWith(1, 'FilesystemFileWrite', 'FilesystemFile', {
-      file: {
-        path: 'vol1:test.bin',
-        offset: 0,
-        total_size: 4097,
-        data: data.slice(0, 4096),
-      },
-      overwrite: true,
-      append: false,
-      ui_percentage: 99,
-    }, { timeoutMs: undefined });
-    expect(typedCall).toHaveBeenNthCalledWith(2, 'FilesystemFileWrite', 'FilesystemFile', {
-      file: {
-        path: 'vol1:test.bin',
-        offset: 4096,
-        total_size: 4097,
-        data: data.slice(4096),
-      },
-      overwrite: false,
-      append: false,
-      ui_percentage: 99,
-    }, { timeoutMs: undefined });
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'FilesystemFileWrite',
+      'FilesystemFile',
+      {
+        file: {
+          path: 'vol1:test.bin',
+          offset: 0,
+          total_size: 4097,
+          data: data.slice(0, 4000),
+        },
+        overwrite: true,
+        append: false,
+        ui_percentage: 0,
+      },
+      { timeoutMs: undefined }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'FilesystemFileWrite',
+      'FilesystemFile',
+      {
+        file: {
+          path: 'vol1:test.bin',
+          offset: 4000,
+          total_size: 4097,
+          data: data.slice(4000),
+        },
+        overwrite: false,
+        append: false,
+        ui_percentage: 100,
+      },
+      { timeoutMs: undefined }
+    );
     expect(result).toMatchObject({
       path: 'vol1:test.bin',
       processed_byte: 4097,
@@ -2729,8 +3682,8 @@ describe('Protocol V2 file write method', () => {
       event: 'UI_EVENT',
       type: UI_REQUEST.DEVICE_PROGRESS,
       payload: expect.objectContaining({
-        progress: 99,
-        transferredBytes: 4096,
+        progress: 97,
+        transferredBytes: 4000,
         totalBytes: 4097,
         elapsedMs: expect.any(Number),
       }),
@@ -2855,7 +3808,7 @@ describe('Protocol V2 file read method', () => {
         total_size: 0,
       },
       chunk_len: 64,
-      ui_percentage: 99,
+      ui_percentage: 0,
     });
     expect(typedCall).toHaveBeenNthCalledWith(3, 'FilesystemFileRead', 'FilesystemFile', {
       file: {
@@ -2864,7 +3817,7 @@ describe('Protocol V2 file read method', () => {
         total_size: 0,
       },
       chunk_len: 1,
-      ui_percentage: 99,
+      ui_percentage: 100,
     });
     expect(result.data.byteLength).toBe(65);
     expect(result.data[0]).toBe(1);