@onekeyfe/hd-core 1.2.0-alpha.0 → 1.2.0-alpha.10

package/__tests__/protocol-v2.test.ts

@@ -1,17 +1,23 @@
 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 DeviceGetFirmwareUpdateStatus from '../src/api/protocol-v2/DeviceGetFirmwareUpdateStatus';
+import DeviceInfoGet from '../src/api/protocol-v2/DeviceInfoGet';
 import DeviceReboot from '../src/api/protocol-v2/DeviceReboot';
+import DeviceSessionGet from '../src/api/protocol-v2/DeviceSessionGet';
+import DeviceStatusGet from '../src/api/protocol-v2/DeviceStatusGet';
+import FilesystemFormat from '../src/api/protocol-v2/FilesystemFormat';
+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,27 +41,27 @@ 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';
 import { DataManager } from '../src/data-manager';
-import { Device } from '../src/device/Device';
+import { createCoreApi } from '../src/inject';
+import { Device, preloadSessionCache } 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,
-  buildProtocolV2GetFeaturesPayload,
-} from '../src/deviceProfile';
+  getProtocolV2WalletSession,
+  refreshProtocolV2DeviceStatus,
+} from '../src/protocols/protocol-v2/walletSession';
+import { buildProfileFromProtocolV2, buildProtocolV2FeaturesPayload } from '../src/deviceProfile';
 import {
   getDeviceType,
   getFirmwareType,
+  getFirmwareUpdateField,
+  getFirmwareUpdateFieldArray,
   getMethodVersionRange,
   isMethodVersionRangeUnsupported,
 } from '../src/utils';
@@ -74,12 +80,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',
@@ -91,47 +91,48 @@ const descriptor = {
  */
 function stubDevice<T extends Record<string, any>>(device: T): T {
   const d = device as any;
-  d.isProtocolV2 ??= () =>
-    d.profile?.protocol === 'V2' || d.originalDescriptor?.protocolType === 'V2';
+  d.isProtocolV2 ??= () => d.originalDescriptor?.protocolType === 'V2';
   d.getProtocol ??= () => (d.isProtocolV2() ? 'V2' : 'V1');
-  d.getCurrentDeviceType ??= () => d.profile?.deviceType ?? getDeviceType(d.features);
-  d.getCurrentFirmwareType ??= () => d.profile?.firmwareType ?? getFirmwareType(d.features);
+  d.getCurrentDeviceType ??= () => getDeviceType(d.features);
+  d.getCurrentFirmwareType ??= () => getFirmwareType(d.features);
   d.getCurrentFirmwareVersionString ??= () =>
-    d.profile?.versions?.firmware ??
-    (d.features ? getDeviceFirmwareVersion(d.features).join('.') : undefined);
-  d.getCurrentBLEFirmwareVersionString ??= () => d.profile?.versions?.ble ?? undefined;
-  d.getCurrentSafetyChecks ??= () => d.features?.safety_checks;
-  d.getCurrentDeviceId ??= () => d.profile?.deviceId || d.features?.device_id || undefined;
-  d.getCurrentSerialNo ??= () => d.profile?.serialNo || '';
-  d.getCurrentPassphraseProtection ??= () =>
-    d.profile ? d.profile.status?.passphraseProtection : d.features?.passphrase_protection;
+    d.features ? getDeviceFirmwareVersion(d.features).join('.') : undefined;
+  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);
     if (range) return range;
     return getMethodVersionRange(d.features, fn);
   };
-  d.updateProfile ??= (p: any) => {
-    d.profile = p;
-  };
-  d.applyProfileUpdate ??= (p: any) => {
-    d.profile = p;
-    return p;
+  d.updateProtocolV2Features ??= (deviceInfo?: ProtocolV2DeviceInfo) => {
+    d.features = buildProtocolV2FeaturesPayload(deviceInfo, d.features);
+    return d.features;
   };
   return device;
 }
 
 // 直接复用生产映射函数，避免测试内副本与实现漂移（之前的手抄副本已缺失 se boot 字段）
 function normalizeProtocolV2Features(_descriptor: unknown, deviceInfo?: ProtocolV2DeviceInfo) {
-  const profile = buildProfileFromProtocolV2({
-    deviceInfo,
-    sources: ['deviceInfo'],
-    scope: 'verify',
-  });
-  return buildProtocolV2GetFeaturesPayload(profile, deviceInfo);
+  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,
 }: {
@@ -143,32 +144,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());
-      // 空 serial_no + fallbackSerialNo：身份字段回退 transport path
-      const profile = buildProfileFromProtocolV2({
-        deviceInfo,
-        fallbackSerialNo: 'usb-path',
-      });
-      expect(profile).toMatchObject({
-        protocol: 'V2',
-        deviceId: 'usb-path',
-        serialNo: 'usb-path',
-        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,
@@ -176,31 +151,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],
@@ -208,61 +183,80 @@ 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.device_id).toBe('PR2SERIAL');
-    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.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.needs_backup).toBe(true);
-    expect(features.passphrase_protection).toBe(true);
-    expect(features.ble_enable).toBe(true);
+    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.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';
+    features.passphraseProtection = true;
     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;
@@ -273,35 +267,294 @@ 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 expect(
+      getPassphraseState(device, {
+        expectPassphraseState: 'state-2',
+        allowCreateAttachPin: true,
+      })
+    ).rejects.toEqual(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+      })
+    );
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
 
     await getPassphraseState(device, {
-      expectPassphraseState: 'state-2',
-      allowCreateAttachPin: true,
+      onlyMainPin: true,
+    });
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
+  });
+
+  test('deviceStatusGet returns raw DeviceStatus without updating features', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceStatus',
+      message: { device_id: 'device-1', unlocked: true },
     });
-    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
-      passphrase_state: 'state-2',
-      allow_create_attach_pin: true,
+    const updateProtocolV2Features = jest.fn();
+    const method = new DeviceStatusGet({
+      payload: { method: 'deviceStatusGet', connectId: 'connect-id' },
     });
+    method.init();
+    method.device = stubDevice({
+      originalDescriptor: { ...descriptor, protocolType: 'V2' },
+      commands: { typedCall },
+      updateProtocolV2Features,
+    }) as any;
 
-    await getPassphraseState(device, {
-      onlyMainPin: true,
+    await expect(method.run()).resolves.toEqual({ device_id: 'device-1', unlocked: true });
+    expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(updateProtocolV2Features).not.toHaveBeenCalled();
+  });
+
+  test('deviceSessionGet maps sessionId and does not mutate wallet cache', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceSession',
+      message: { session_id: 'new-session', btc_test_address: 'state-a' },
+    });
+    const updateInternalState = jest.fn();
+    const method = new DeviceSessionGet({
+      payload: {
+        method: 'deviceSessionGet',
+        connectId: 'connect-id',
+        sessionId: 'cached-session',
+      },
+    });
+    method.init();
+    method.device = stubDevice({
+      originalDescriptor: { ...descriptor, protocolType: 'V2' },
+      commands: { typedCall },
+      updateInternalState,
+    }) as any;
+
+    await expect(method.run()).resolves.toEqual({
+      session_id: 'new-session',
+      btc_test_address: 'state-a',
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'cached-session',
+    });
+    expect(updateInternalState).not.toHaveBeenCalled();
+  });
+
+  test('routes raw status and session methods through CoreApi', async () => {
+    const call = jest.fn().mockResolvedValue({ success: true, payload: {} });
+    const api = createCoreApi(call as any);
+
+    await api.deviceStatusGet('connect-id', { retryCount: 1 });
+    await api.deviceSessionGet('connect-id', { sessionId: 'cached-session' });
+
+    expect(call).toHaveBeenNthCalledWith(1, {
+      method: 'deviceStatusGet',
+      connectId: 'connect-id',
+      retryCount: 1,
+    });
+    expect(call).toHaveBeenNthCalledWith(2, {
+      method: 'deviceSessionGet',
+      connectId: 'connect-id',
+      sessionId: 'cached-session',
+    });
+  });
+
+  test('reuses the cached session id for the selected Pro2 wallet', async () => {
+    const device = Device.fromDescriptor({
+      id: 'cache-device-1',
+      path: 'cache-path-1',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: 'stable-device-1',
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    device.passphraseState = 'state-a';
+    preloadSessionCache('stable-device-1', 'state-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceSession',
+      message: { session_id: 'session-b', btc_test_address: 'state-a' },
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
+      passphraseState: 'state-a',
+      newSession: 'session-b',
+    });
+
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'session-a',
+    });
+    expect(device.getInternalState()).toBe('session-b');
+  });
+
+  test('does not reuse another Pro2 wallet session without passphraseState', async () => {
+    const device = Device.fromDescriptor({
+      id: 'cache-device-2',
+      path: 'cache-path-2',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      { status: { device_id: 'stable-device-2', unlocked: true } }
+    );
+    preloadSessionCache('stable-device-2', 'state-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceSession',
+      message: { session_id: 'main-session' },
+    });
+    (device as any).commands = { typedCall };
+
+    await getProtocolV2WalletSession(device);
+
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(device.getInternalState()).toBeUndefined();
+  });
+
+  test('clears the selected Pro2 cache entry after invalid session rejection', async () => {
+    const device = Device.fromDescriptor({
+      id: 'cache-device-3',
+      path: 'cache-path-3',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: 'stable-device-3',
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    device.passphraseState = 'state-a';
+    preloadSessionCache('stable-device-3', 'state-a', 'session-a');
+    (device as any).commands = {
+      typedCall: jest.fn().mockRejectedValue(new Error('Failure_InvalidSession,no error message')),
+    };
+
+    await expect(getProtocolV2WalletSession(device)).rejects.toThrow('Failure_InvalidSession');
+    expect(device.getInternalState()).toBeUndefined();
+  });
+
+  test('rejects a mismatched Pro2 wallet state and clears the selected cache entry', async () => {
+    const device = Device.fromDescriptor({
+      id: 'cache-device-mismatch',
+      path: 'cache-path-mismatch',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: 'stable-device-mismatch',
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    device.passphraseState = 'state-a';
+    preloadSessionCache('stable-device-mismatch', 'state-a', 'session-a');
+    (device as any).commands = {
+      typedCall: jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: { session_id: 'session-b', btc_test_address: 'state-b' },
+      }),
+    };
+
+    await expect(
+      getPassphraseStateWithRefreshDeviceInfo(device, { expectPassphraseState: 'state-a' })
+    ).rejects.toEqual(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+      })
+    );
+    expect(device.getInternalState()).toBeUndefined();
+  });
+
+  test('rejects DeviceSessionGet while cached Pro2 status is locked', async () => {
+    const device = Device.fromDescriptor({
+      id: 'cache-device-4',
+      path: 'cache-path-4',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      { status: { device_id: 'stable-device-4', unlocked: false } }
+    );
+    const typedCall = jest.fn();
+    (device as any).commands = { typedCall };
+
+    await expect(getProtocolV2WalletSession(device)).rejects.toThrow('Device is locked');
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  test('does not request a Pro2 wallet session before features are initialized', async () => {
+    const device = Device.fromDescriptor({
+      id: 'cache-device-5',
+      path: 'cache-path-5',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest.fn();
+    (device as any).commands = { typedCall };
+
+    await expect(getPassphraseStateWithRefreshDeviceInfo(device)).resolves.toEqual({
+      passphraseState: undefined,
+      newSession: undefined,
+      unlockedAttachPin: undefined,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  test('merges DeviceStatus into existing Protocol V2 features', async () => {
+    const device = Device.fromDescriptor({
+      id: 'status-device',
+      path: 'status-path',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        protocol_version: 2,
+        fw: { application: { version: '1.2.3' } },
+        se1: { application: { version: '4.5.6' } },
+        status: { unlocked: false, passphrase_enabled: false },
+      }
+    );
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceStatus',
+      message: {
+        device_id: 'stable-status-device',
+        unlocked: true,
+        passphrase_enabled: true,
+      },
     });
-    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
-      _only_main_pin: true,
+    (device as any).commands = { typedCall };
+
+    const features = await refreshProtocolV2DeviceStatus(device);
+
+    expect(features).toMatchObject({
+      deviceId: 'stable-status-device',
+      unlocked: true,
+      passphraseProtection: true,
+      firmwareVersion: '1.2.3',
+      se01Version: '4.5.6',
     });
+    expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
   });
 
   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',
@@ -319,6 +572,7 @@ describe('Protocol V2 feature adapter', () => {
       },
     });
     method.device = stubDevice({
+      originalDescriptor: { ...descriptor, protocolType: 'V1' },
       features,
       commands: { typedCall },
       updateInternalState,
@@ -327,10 +581,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,
@@ -341,21 +595,20 @@ describe('Protocol V2 feature adapter', () => {
     );
   });
 
-  test('prefers DeviceProfile for GetPassphraseState response metadata', async () => {
+  test('uses features for GetPassphraseState response metadata', async () => {
     const features = {
-      device_id: 'legacy-pro-device-id',
-      onekey_device_type: 'PRO',
-      onekey_firmware_version: '4.15.0',
-      passphrase_protection: false,
-      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,66 +620,90 @@ describe('Protocol V2 feature adapter', () => {
       },
     });
     method.device = stubDevice({
+      originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features,
-      profile: {
-        protocol: 'V2',
-        sources: ['deviceInfo'],
-        deviceType: 'pro2',
-        firmwareType: 'universal',
-        deviceId: 'PR2SERIAL',
-        serialNo: 'PR2SERIAL',
-        label: null,
-        bleName: null,
-        status: {
-          mode: 'normal',
-          initialized: true,
-          bootloaderMode: false,
-          unlocked: null,
-          passphraseProtection: true,
-          backupRequired: false,
-          noBackup: null,
-          language: null,
-        },
-        versions: {
-          firmware: '4.15.0',
-          bootloader: null,
-          board: null,
-          ble: null,
-        },
-      },
       commands: { typedCall },
       updateInternalState,
       getFeatures,
       getCurrentDeviceType: () => 'pro2',
-      getCurrentDeviceId: () => 'PR2SERIAL',
+      getCurrentDeviceId: () => undefined,
       getCurrentPassphraseProtection: () => true,
     }) 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('uses DeviceProfile identity for Pro2 passphrase session cache', async () => {
+  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,
     };
@@ -436,17 +713,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,
       },
     });
 
@@ -459,8 +735,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 };
 
@@ -470,23 +746,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,
       },
     });
 
@@ -497,11 +770,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 };
 
@@ -512,22 +785,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,
       },
     });
 
@@ -535,32 +805,52 @@ 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(
-      false
+    await expect(device.checkPassphraseStateSafety('expected-state', false, true)).rejects.toEqual(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+      })
     );
 
     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).toBe('');
-    expect(features.serial_no).toBe('');
-    expect(features.onekey_serial_no).toBe('');
-    expect(features.initialized).toBe(false);
-    expect(features.unlocked).toBe(false);
-    expect(features.firmware_present).toBe(false);
+    expect(features.deviceId).toBeNull();
+    expect(features.serialNo).toBe('');
+    expect(features.initialized).toBeNull();
+    expect(features.unlocked).toBeNull();
+    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('uses Protocol V2 DeviceInfo serial_no as device_id instead of descriptor id', () => {
+  test('does not use Protocol V2 serial_no as deviceId when hw.device_id is absent', () => {
     const features = normalizeProtocolV2Features(
       {
         id: 'PR2000000000',
@@ -574,140 +864,83 @@ describe('Protocol V2 feature adapter', () => {
       }
     );
 
-    expect(features.device_id).toBe('PR9999999999');
-    expect(features.onekey_serial_no).toBe('PR9999999999');
-    expect(features.serial_no).toBe('PR9999999999');
+    expect(features.deviceId).toBeNull();
+    expect(features.serialNo).toBe('PR9999999999');
   });
 
-  test('does not expose legacy feature ids when Protocol V2 profile is incomplete', () => {
+  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),
-      device_id: 'LEGACY-ID',
-      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,
     };
-    device.updateProfile({
-      protocol: 'V2',
-      sources: ['deviceInfo'],
-      deviceType: 'pro2',
-      firmwareType: 'universal',
-      deviceId: '',
-      serialNo: '',
-      label: null,
-      bleName: null,
-      status: {
-        mode: 'normal',
-        initialized: true,
-        bootloaderMode: false,
-        unlocked: null,
-        passphraseProtection: null,
-        backupRequired: false,
-        noBackup: null,
-        language: null,
-      },
-      versions: {
-        firmware: null,
-        bootloader: null,
-        board: null,
-        ble: null,
-      },
-    });
 
     expect(device.toMessageObject()).toMatchObject({
-      uuid: '',
+      uuid: 'CACHED-SERIAL',
       deviceId: null,
-      bleName: null,
-      label: 'OneKey Pro2',
+      bleName: 'Cached BLE',
+      label: 'Cached Label',
       deviceType: 'pro2',
     });
-    expect(device.getCurrentPassphraseProtection()).toBeNull();
+    expect(device.getCurrentPassphraseProtection()).toBe(true);
     expect(device.hasUsePassphrase()).toBe(true);
-    expect(device.isInitialized()).toBe(true);
-    expect(device.getMode()).toBe('normal');
-    expect(device.getFirmwareVersion()).toBeNull();
   });
 
-  test('keeps Protocol V2 cached profile as identity source when syncing legacy features', () => {
+  test('syncs Protocol V2 cached features without cached profile', () => {
     const cached = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (cached as any).features = {
       ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-      device_id: 'LEGACY-ID',
-      serial_no: 'LEGACY-SERIAL',
-      onekey_serial_no: 'LEGACY-SERIAL',
+      deviceId: null,
+      serialNo: 'CACHED-SERIAL',
     };
-    cached.updateProfile({
-      protocol: 'V2',
-      sources: ['deviceInfo'],
-      deviceType: 'pro2',
-      firmwareType: 'universal',
-      deviceId: '',
-      serialNo: '',
-      label: null,
-      bleName: null,
-      status: {
-        mode: 'normal',
-        initialized: true,
-        bootloaderMode: false,
-        unlocked: null,
-        passphraseProtection: null,
-        backupRequired: false,
-        noBackup: null,
-        language: null,
-      },
-      versions: {
-        firmware: null,
-        bootloader: null,
-        board: null,
-        ble: null,
-      },
-    });
 
     const current = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     current.updateFromCache(cached);
 
     expect(current.getCurrentDeviceId()).toBeUndefined();
-    expect(current.getCurrentSerialNo()).toBe('');
+    expect(current.getCurrentSerialNo()).toBe('CACHED-SERIAL');
     expect(current.toMessageObject()).toMatchObject({
-      uuid: '',
+      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).toBe('PR2SERIAL');
+    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: {
@@ -719,13 +952,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,
       })
@@ -738,20 +971,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,
         },
       },
     });
@@ -768,27 +1002,26 @@ 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',
       },
       commands: { typedCall },
       _updateFeatures: jest.fn(),
-      updateProfile: jest.fn(),
     });
 
     const result = await method.run();
 
     expect(typedCall).toHaveBeenCalledWith(
-      'DevGetDeviceInfo',
+      'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: {
           hw: true,
           fw: true,
-          bt: true,
+          coprocessor: true,
           status: true,
         },
         types: {
@@ -801,12 +1034,13 @@ describe('Protocol V2 feature adapter', () => {
     expect(result).toMatchObject({
       protocol: 'V2',
       deviceType: 'pro2',
-      deviceId: 'PR2SERIAL',
+      deviceId: 'PRO2-BASIC-ID',
       serialNo: 'PR2SERIAL',
-      label: 'Raw Pro2',
+      label: null,
       bleName: 'Raw Pro2 BLE',
       status: {
         initialized: true,
+        unlockedAttachPin: true,
         passphraseProtection: true,
       },
       versions: {
@@ -816,7 +1050,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: {
@@ -837,26 +1071,25 @@ 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',
       },
       commands: { typedCall },
-      updateProfile: jest.fn(),
     });
 
     const result = await method.run();
 
     expect(result).toMatchObject({
       protocol: 'V2',
-      // 身份字段不得取自 legacy features（LEGACY-ID / LEGACY-SERIAL）；
-      // hw.serial_no 缺失时回退 descriptor.path（早期工程板无 serial 的 mock 身份）。
-      deviceId: 'usb-path',
-      serialNo: 'usb-path',
+      // 身份字段不得取自缓存的 V1-shaped features（STALE-ID / STALE-SERIAL），
+      // hw.serial_no 缺失时也不回退 descriptor.path。
+      deviceId: '',
+      serialNo: '',
       label: null,
       bleName: null,
       status: {
@@ -896,13 +1129,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,
@@ -926,12 +1159,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 },
       },
@@ -948,19 +1181,18 @@ describe('Protocol V2 feature adapter', () => {
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
       commands: { typedCall },
-      updateProfile: jest.fn(),
     });
 
     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,
@@ -999,10 +1231,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',
         },
       },
@@ -1052,7 +1297,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',
@@ -1066,7 +1311,7 @@ describe('Protocol V2 feature adapter', () => {
       originalDescriptor: { protocolType: 'V2' },
       features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
         fw: {
-          app: {
+          application: {
             version: '4.14.0',
           },
         },
@@ -1088,7 +1333,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: {
@@ -1100,9 +1345,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 },
       },
     });
 
@@ -1113,10 +1358,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 }),
@@ -1124,17 +1369,11 @@ 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');
   });
 
-  test('refreshes cached Protocol V2 profile with a lightweight status request on later runs', async () => {
+  test('refreshes cached Protocol V2 features with a lightweight status request on later runs', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
@@ -1145,9 +1384,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,
           },
         },
       })
@@ -1157,8 +1397,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,
           },
         },
       });
@@ -1169,27 +1409,27 @@ describe('Protocol V2 feature adapter', () => {
     await device.initialize();
 
     expect(device.features).toMatchObject({
-      device_id: 'PR2SERIAL',
-      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.profile?.deviceId).toBe('PR2SERIAL');
+    expect((device as any).profile).toBeUndefined();
     // status 字段被第二次刷新更新
-    expect(device.profile?.status.passphraseProtection).toBe(false);
-    expect(device.profile?.label).toBe('renamed');
+    expect(device.features?.passphraseProtection).toBe(false);
+    expect(device.features?.label).toBeNull();
     // 轻量刷新不含 fw target，已有版本信息按字段级合并保留
-    expect(device.profile?.versions.firmware).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: {
@@ -1201,15 +1441,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: {
@@ -1223,7 +1463,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',
@@ -1234,7 +1474,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 },
         },
       })
@@ -1242,8 +1482,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 },
         },
       });
 
@@ -1253,26 +1493,26 @@ describe('Protocol V2 feature adapter', () => {
     const features = await device.getFeatures();
 
     expect(device.features).toMatchObject({
-      device_id: 'PR2SERIAL',
-      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: {
@@ -1285,14 +1525,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 };
@@ -1319,7 +1559,6 @@ describe('Protocol V2 feature adapter', () => {
     });
     method.init();
     (method as any).device = stubDevice({
-      profile: device.profile,
       features: device.features,
       commands: { typedCall: jest.fn() },
     });
@@ -1330,90 +1569,155 @@ describe('Protocol V2 feature adapter', () => {
     await expect(method.run()).resolves.toEqual({ address: '0x0', signature: '0x1' });
   });
 
-  test('unlocks Protocol V2 devices via UnLockDevice regardless of Pro-series version gates', async () => {
+  test('unlocks Protocol V2 devices via DeviceSessionAskPin regardless of Pro-series version gates', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
     } as any);
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'UnLockDeviceResponse',
-      message: { unlocked: true, passphrase_protection: true },
+    const typedCall = jest.fn().mockImplementation(requestType => {
+      if (requestType === 'DeviceSessionAskPin') {
+        return {
+          type: 'DeviceSessionPinResult',
+          message: { unlocked: false, passphrase_protection: false },
+        };
+      }
+      if (requestType === 'DeviceStatusGet') {
+        return {
+          type: 'DeviceStatus',
+          message: {
+            device_id: 'PRO2-DEVICE-ID',
+            unlocked: true,
+            passphrase_enabled: true,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
     });
 
     (device as any).commands = { typedCall };
     // Pro2 版本线独立于 Pro（这里是 1.2.3，不满足 Pro 系列 4.15.0 门槛），
-    // Protocol V2 固件从首个版本即支持 UnLockDevice，不走 GetAddress 探测回退。
+    // Protocol V2 走独立的设备端 PIN 解锁流程，不走 Pro 系列版本门槛或 GetAddress 探测回退。
     (device as any).features = normalizeProtocolV2Features(
       { ...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 },
       }
     );
 
     const features = await device.unlockDevice();
 
-    expect(typedCall).toHaveBeenCalledWith('UnLockDevice', 'UnLockDeviceResponse');
+    expect(typedCall.mock.calls).toEqual([
+      ['DeviceSessionAskPin', 'DeviceSessionPinResult'],
+      ['DeviceStatusGet', 'DeviceStatus', {}],
+    ]);
     expect(typedCall).not.toHaveBeenCalledWith('GetAddress', 'Address', expect.anything());
     expect(typedCall).not.toHaveBeenCalledWith('GetFeatures', 'Features', {});
     expect(features).toMatchObject({
-      onekey_device_type: 'pro2',
-      device_id: 'PR2SERIAL',
-      onekey_firmware_version: '1.2.3',
+      deviceType: 'pro2',
+      deviceId: 'PRO2-DEVICE-ID',
+      firmwareVersion: '1.2.3',
       unlocked: true,
+      passphraseProtection: true,
     });
   });
 
-  test('syncs Protocol V2 profile passphrase state after unlock response', async () => {
+  test('syncs Protocol V2 features passphrase state from DeviceStatusGet after unlock', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = normalizeProtocolV2Features(
       { ...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 },
       }
     );
-    device.updateProfile({
-      protocol: 'V2',
-      sources: ['deviceInfo'],
-      deviceType: 'pro2',
-      firmwareType: 'universal',
-      deviceId: 'PR2SERIAL',
-      serialNo: 'PR2SERIAL',
-      label: null,
-      bleName: null,
-      status: {
-        mode: 'normal',
-        initialized: true,
-        bootloaderMode: false,
-        unlocked: null,
-        passphraseProtection: false,
-        backupRequired: false,
-        noBackup: null,
-        language: null,
-      },
-      versions: {
-        firmware: '4.15.0',
-        bootloader: null,
-        board: null,
-        ble: null,
-      },
+    const typedCall = jest.fn().mockImplementation(requestType => {
+      if (requestType === 'DeviceSessionAskPin') {
+        return {
+          type: 'DeviceSessionPinResult',
+          message: {
+            unlocked: false,
+            unlocked_attach_pin: false,
+            passphrase_protection: false,
+          },
+        };
+      }
+      if (requestType === 'DeviceStatusGet') {
+        return {
+          type: 'DeviceStatus',
+          message: {
+            unlocked: true,
+            unlocked_by_attach_to_pin: true,
+            passphrase_enabled: true,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
     });
+    (device as any).commands = { typedCall };
+
+    await device.unlockDevice();
+
+    expect((device as any).profile).toBeUndefined();
+    expect(device.features?.passphraseProtection).toBe(true);
+    expect(device.features?.unlockedAttachPin).toBe(true);
+  });
+
+  test('maps unsupported Protocol V2 DeviceSessionAskPin to DeviceNotSupportMethod', async () => {
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        fw: { application: { version: '1.2.3' } },
+        status: { unlocked: false },
+      }
+    );
+    const typedCall = jest
+      .fn()
+      .mockRejectedValue(new Error('Failure_UnexpectedMessage,Unknown message'));
+    (device as any).commands = { typedCall };
+
+    await expect(device.unlockDevice()).rejects.toEqual(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+      })
+    );
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall.mock.calls).toEqual([['DeviceSessionAskPin', 'DeviceSessionPinResult']]);
+    expect(typedCall).not.toHaveBeenCalledWith(
+      'DeviceSessionGet',
+      'DeviceSession',
+      expect.anything()
+    );
+  });
+
+  test('keeps Protocol V1 unlock response handling unchanged', async () => {
+    const device = Device.fromDescriptor({ path: 'v1-path', protocolType: 'V1' } as any);
+    (device as any).features = {
+      deviceType: 'pro',
+      firmwareVersion: '4.15.0',
+      capabilities: [],
+      unlocked: false,
+      passphraseProtection: false,
+    } as Features;
     const typedCall = jest.fn().mockResolvedValue({
       type: 'UnLockDeviceResponse',
       message: {
         unlocked: true,
+        unlocked_attach_pin: true,
         passphrase_protection: true,
       },
     });
     (device as any).commands = { typedCall };
 
-    await device.unlockDevice();
-
-    expect(device.profile?.status.passphraseProtection).toBe(true);
-    expect(device.features?.passphrase_protection).toBe(true);
+    await expect(device.unlockDevice()).resolves.toMatchObject({
+      unlocked: true,
+      unlockedAttachPin: true,
+      passphraseProtection: true,
+    });
+    expect(typedCall.mock.calls).toEqual([['UnLockDevice', 'UnLockDeviceResponse']]);
   });
 });
 
@@ -1432,7 +1736,7 @@ describe('API compatibility handling', () => {
     method.init();
     (method as any).device = stubDevice({
       features: {
-        onekey_device_type: 'pro2',
+        deviceType: 'pro2',
       },
       originalDescriptor: {
         protocolType: 'V2',
@@ -1450,27 +1754,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({
@@ -1589,9 +1875,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({
@@ -1621,7 +1905,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({
@@ -1685,15 +1969,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(() => ({
@@ -1715,7 +1990,7 @@ describe('API compatibility handling', () => {
     method.init();
     (method as any).device = stubDevice({
       features: {
-        onekey_device_type: 'pro2',
+        deviceType: 'pro2',
       },
       originalDescriptor: {
         protocolType: 'V2',
@@ -1738,54 +2013,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,
@@ -1841,7 +2068,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: {
@@ -1855,25 +2116,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' },
             },
           },
         });
@@ -1887,7 +2149,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();
@@ -1896,13 +2164,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,
@@ -1925,7 +2193,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: {
@@ -1938,14 +2206,14 @@ 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).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: 5,
       },
     ]);
-    (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({
@@ -1959,17 +2227,17 @@ describe('Protocol V2 firmware update targets', () => {
 
     await method.run();
 
+    expect((method as any).enterProtocolV2BootloaderMode).toHaveBeenCalledTimes(1);
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
-      resourceBinary: null,
       fwBinaryMap: [
         {
-          fileName: 'ble-firmware.bin',
+          fileName: 'coprocessor.bin',
           binary: expect.any(ArrayBuffer),
+          targetId: 5,
         },
       ],
       bootloaderBinary: null,
     });
-    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
   });
 
   test('reboots Protocol V2 normal-mode device to bootloader before transfer', async () => {
@@ -1979,31 +2247,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: {
@@ -2018,7 +2325,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 () => {
@@ -2038,7 +2345,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',
     });
   });
@@ -2058,7 +2365,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',
     });
   });
@@ -2086,192 +2393,811 @@ 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: 4, path: 'vol1:application_p1.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[] = [];
+    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_APPLICATION_P1',
+            status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+          },
+          { target_id: 'FW_MGMT_TARGET_SE04', status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED' },
+        ],
+        new Set([4, 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 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).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (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: [
         {
-          fileName: 'ble-firmware.bin',
+          fileName: 'coprocessor.bin',
           binary: new Uint8Array([6]).buffer,
+          targetId: 6,
         },
         {
-          fileName: 'se1-firmware.bin',
+          fileName: 'se01.bin',
           binary: new Uint8Array([7]).buffer,
+          targetId: 7,
         },
         {
-          fileName: 'firmware.bin',
+          fileName: 'application_p1.bin',
           binary: new Uint8Array([8]).buffer,
+          targetId: 4,
         },
       ],
     });
 
     expect(writtenPaths).toEqual([
-      'vol1:resource.bin',
-      'vol1:bootloader.bin',
-      'vol1:ble-firmware.bin',
-      'vol1:se1-firmware.bin',
-      'vol1:firmware.bin',
+      'vol0:/bootloader.bin',
+      'vol0:/coprocessor.bin',
+      'vol0:/se01.bin',
+      'vol0:/application_p1.bin',
     ]);
-    // DevFirmwareTargetType：RESOURCE=10, MAIN_BOOT=1, BT=2, SE1=3, MAIN_APP=0
+    expect((method as any).verifyProtocolV2StagedFile).toHaveBeenCalledTimes(4);
+    expect((method as any).verifyProtocolV2StagedFile).toHaveBeenNthCalledWith(
+      2,
+      'vol0:/coprocessor.bin',
+      1
+    );
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(1);
     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' },
+        { target_id: 3, path: 'vol0:/bootloader.bin' },
+        { target_id: 6, path: 'vol0:/coprocessor.bin' },
+        { target_id: 7, path: 'vol0:/se01.bin' },
+        { target_id: 4, path: 'vol0:/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('announces one transfer when syncing resource bundles and staging firmware', 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).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
+    (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
+      .fn()
+      .mockResolvedValue(undefined);
+
+    await (method as any).executeProtocolV2Update({
+      resourceBundles: [
+        {
+          name: 'images.okpkg',
+          binary: new Uint8Array([1, 2]).buffer,
+          devicePath: 'vol0:/bundles/images/images.okpkg',
+        },
+      ],
+      bootloaderBinary: null,
+      fwBinaryMap: [
+        {
+          fileName: 'application_p1.bin',
+          binary: new Uint8Array([3]).buffer,
+          targetId: 3,
+        },
+      ],
+    });
+
+    expect(method.postTipMessage).toHaveBeenCalledTimes(2);
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(1, 'StartTransferData');
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'ConfirmOnDevice');
+    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ processedSize: 0, totalSize: 3 })
+    );
+    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ processedSize: 2, totalSize: 3 })
+    );
+  });
+
+  test('does not request installation when the staged file size does not match', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).device = stubDevice({
+      getCommands: () => ({
+        typedCall: jest.fn().mockResolvedValue({
+          type: 'FilesystemPathInfo',
+          message: { exist: true, directory: false, size: 2 },
+        }),
+      }),
+    });
+    (method as any).protocolV2StartFirmwareUpdate = jest.fn();
+
+    await expect(
+      (method as any).executeProtocolV2Update({
+        bootloaderBinary: null,
+        fwBinaryMap: [
+          {
+            fileName: 'coprocessor.bin',
+            binary: new Uint8Array([1, 2, 3]).buffer,
+            targetId: 5,
+          },
+        ],
+      })
+    ).rejects.toThrow(/staged file verification failed/);
+    expect((method as any).protocolV2StartFirmwareUpdate).not.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).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
+    (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
+      .fn()
+      .mockResolvedValue(undefined);
+
+    await (method as any).executeProtocolV2Update({
+      bootloaderBinary: null,
+      fwBinaryMap: explicit,
+    });
+
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
+      targets: [
+        { target_id: 5, path: 'vol0:/application_p2.bin' },
+        { target_id: 10, path: 'vol0:/se04.bin' },
+      ],
+    });
+  });
+
+  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('maps remote Pro2 resource bundles to direct-write descriptors', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://example.com/images.okpkg',
+            devicePath: 'vol0:/resource/images/images.okpkg',
+            version: [2, 0, 0],
+            payloadHash: 'ab'.repeat(64),
+            headerHash: 'cd'.repeat(64),
+          },
+        ],
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    const bundles = (method as any).prepareProtocolV2ResourceBundles('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '1.0.0',
+      capabilities: [],
+    });
+
+    expect(bundles).toEqual([
+      {
+        name: 'images',
+        binary: expect.any(ArrayBuffer),
+        devicePath: 'vol0:/resource/images/images.okpkg',
+        url: 'https://example.com/images.okpkg',
+        version: [2, 0, 0],
+        payloadHash: 'ab'.repeat(64),
+        headerHash: 'cd'.repeat(64),
+      },
+    ]);
+    expect(bundles[0].binary.byteLength).toBe(0);
+
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
+  test('skips Pro2 firmware components when configured versions are already installed', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+      },
+    });
+    method.init();
+
+    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': '',
+        },
+      });
+
+    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '1.0.0',
+      bootloaderVersion: '1.0.0',
+      capabilities: [],
+    });
+
+    expect(remoteBinaries).toEqual({
+      bootloaderBinary: null,
+      fwBinaryMap: [],
+      installItems: [],
+    });
+    expect(getSysResourceBinarySpy).not.toHaveBeenCalled();
+
+    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 = {
+      bootloaderBinary: new Uint8Array([1]).buffer,
+      fwBinaryMap: [
+        {
+          fileName: 'application_p1.bin',
+          binary: new Uint8Array([2]).buffer,
+          targetId: 3,
+        },
+      ],
+    };
+
+    (method as any).device = stubDevice({
+      originalDescriptor: { protocolType: 'V2' },
+      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
+    });
+    (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({
+      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).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({
+      bootloaderBinary: null,
+      fwBinaryMap: [{ fileName: 'coprocessor.bin', binary: expect.anything(), targetId: 6 }],
+    });
+  });
+
+  test('treats manual resource bundles as explicit payload without remote firmware auto-fill', async () => {
+    const resourceBundle = new Uint8Array([1, 2, 3]).buffer;
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        resourceBundleFiles: [
+          {
+            binary: resourceBundle,
+            devicePath: 'vol0:/resource/images/images.okpkg',
+          },
+        ],
+      },
+    });
+    method.init();
+
+    (method as any).device = stubDevice({
+      originalDescriptor: { protocolType: 'V2' },
+      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
+    });
+    (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(
+      expect.objectContaining({
+        resourceBundles: [
+          {
+            name: 'images.okpkg',
+            binary: resourceBundle,
+            devicePath: 'vol0:/resource/images/images.okpkg',
+          },
+        ],
+      })
+    );
+  });
+
+  test('syncs resource bundles without sending a firmware install request', 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 },
-    ]);
 
     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);
+    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).protocolV2StartFirmwareUpdate = jest.fn();
+    (method as any).waitForProtocolV2FirmwareUpdateComplete = jest.fn();
 
     await (method as any).executeProtocolV2Update({
-      resourceBinary: null,
+      resourceBundles: [
+        {
+          name: 'images.okpkg',
+          binary: new Uint8Array([1, 2, 3]).buffer,
+          devicePath: 'vol0:/resource/images/images.okpkg',
+        },
+      ],
       bootloaderBinary: null,
-      fwBinaryMap: explicit,
+      fwBinaryMap: [],
     });
 
-    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' },
-      ],
-    });
+    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2StartFirmwareUpdate).not.toHaveBeenCalled();
+    expect((method as any).waitForProtocolV2FirmwareUpdateComplete).not.toHaveBeenCalled();
   });
 
   test('uses absolute processed_byte offsets and disables append for firmware file writes', async () => {
@@ -2308,10 +3234,65 @@ 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('restarts the whole file from offset zero after an ambiguous chunk write failure', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const writeOffsets: number[] = [];
+    let failedSecondChunk = false;
+    const typedCall = jest.fn(
+      (
+        _name: string,
+        _resType: string,
+        params: { file: { offset: number; data: { byteLength: number } } }
+      ) => {
+        writeOffsets.push(params.file.offset);
+        if (params.file.offset === 4000 && !failedSecondChunk) {
+          failedSecondChunk = true;
+          return Promise.reject(new Error('response lost after device write'));
+        }
+        return Promise.resolve({
+          type: 'FilesystemFile',
+          message: {
+            processed_byte: params.file.offset + params.file.data.byteLength,
+          },
+        });
+      }
+    );
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: (...args: any[]) => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await (method as any).protocolV2CommonUpdateProcess({
+        payload: new Uint8Array(8001).buffer,
+        filePath: 'vol0:/firmware.bin',
+        processedSize: 0,
+        totalSize: 8001,
+      });
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(writeOffsets).toEqual([0, 4000, 0, 4000, 8000]);
   });
 
   test('continues to DeviceFirmwareUpdate when FilesystemFileWrite returns processed chunk length', async () => {
@@ -2330,9 +3311,23 @@ describe('Protocol V2 firmware update targets', () => {
           },
         });
       }
-      if (name === 'DevFirmwareUpdate') {
+      if (name === 'FilesystemPathInfoQuery') {
+        return Promise.resolve({
+          type: 'FilesystemPathInfo',
+          message: { exist: true, directory: false, size: 4097 },
+        });
+      }
+      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}`));
     });
 
@@ -2343,23 +3338,25 @@ describe('Protocol V2 firmware update targets', () => {
     method.postTipMessage = jest.fn();
 
     await (method as any).executeProtocolV2Update({
-      resourceBinary: null,
       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: 'vol0:/firmware.bin' }],
       },
-      expect.any(Object)
+      expect.objectContaining({
+        timeoutMs: 3 * 60 * 1000,
+      })
     );
   });
 
@@ -2403,6 +3400,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 () => {
@@ -2421,18 +3419,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 () => {
@@ -2443,8 +3441,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({
@@ -2454,29 +3452,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({
@@ -2484,11 +3482,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' }],
     });
   });
 
@@ -2497,7 +3495,7 @@ describe('Protocol V2 firmware update method', () => {
       id: 1,
       payload: {
         method: 'deviceFirmwareUpdate',
-        targetId: 0,
+        targetId: 4,
         path: 'vol0:firmware.bin',
       },
     });
@@ -2542,6 +3540,30 @@ describe('Protocol V2 firmware update method', () => {
     expect(typedCall).not.toHaveBeenCalled();
   });
 
+  test.each([0, 2])(
+    'rejects firmware target %s because the Pro2 bootloader cannot install it',
+    async targetId => {
+      const typedCall = jest.fn();
+      const method = new DeviceFirmwareUpdate({
+        id: 1,
+        payload: {
+          method: 'deviceFirmwareUpdate',
+          targetId,
+          path: 'vol0:firmware.bin',
+        },
+      });
+      method.init();
+      (method as any).device = stubDevice({
+        commands: { typedCall },
+      });
+
+      await expect(method.run()).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      });
+      expect(typedCall).not.toHaveBeenCalled();
+    }
+  );
+
   test('accepts targetId alias inside firmware targets', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: {} });
     const method = new DeviceFirmwareUpdate({
@@ -2551,8 +3573,8 @@ describe('Protocol V2 firmware update method', () => {
         targets: [
           {
             target_id: undefined,
-            targetId: 3,
-            path: 'vol0:firmware.bin',
+            targetId: 1,
+            path: 'vol0:resource.crate.okpkg',
           },
         ],
       } as any,
@@ -2564,31 +3586,71 @@ 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: 1, path: 'vol0:resource.crate.okpkg' }],
     });
   });
-});
 
-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_APPLICATION_P1',
+        path: 'vol0:application_p1.bin',
       },
     });
     method.init();
-    (method as any).device = stubDevice({ commands: { typedCall } });
+    (method as any).device = stubDevice({
+      commands: { typedCall },
+    });
 
     await method.run();
+    expect(typedCall.mock.calls[0][2]).toEqual({
+      targets: [{ target_id: 4, path: 'vol0:application_p1.bin' }],
+    });
+  });
 
-    expect(typedCall).toHaveBeenCalledWith('DevReboot', 'Success', {
-      reboot_type: 2,
+  test('passes firmware update status fields through to Protocol V2', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      message: {
+        records: [{ target_id: 4, status: 2, payload_version: 1, path: 'vol1:application_p1.bin' }],
+      },
+    });
+    const method = new DeviceGetFirmwareUpdateStatus({
+      id: 1,
+      payload: {
+        method: 'deviceGetFirmwareUpdateStatus',
+        fields: {
+          status: true,
+          payload_version: true,
+          path: true,
+        },
+      },
     });
+    method.init();
+    (method as any).device = stubDevice({
+      commands: { typedCall },
+    });
+
+    await expect(method.run()).resolves.toEqual({
+      records: [{ target_id: 4, status: 2, payload_version: 1, path: 'vol1:application_p1.bin' }],
+    });
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateStatusGet',
+      'DeviceFirmwareUpdateStatus',
+      {
+        fields: {
+          status: true,
+          payload_version: true,
+          path: true,
+        },
+      }
+    );
   });
+});
 
+describe('Protocol V2 reboot methods', () => {
   test('sends DeviceReboot from deviceReboot', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: { message: 'ok' } });
     const method = new DeviceReboot({
@@ -2609,12 +3671,97 @@ 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', {});
+  });
+
+  test('sends required FilesystemFormat partition flags', async () => {
+    const typedCall = jest.fn().mockResolvedValue({ message: {} });
+    const method = new FilesystemFormat({
+      id: 1,
+      payload: { method: 'filesystemFormat' },
+    });
+    method.init();
+    (method as any).device = stubDevice({ commands: { typedCall } });
+
+    await method.run();
+
+    expect(typedCall).toHaveBeenCalledWith('FilesystemFormat', 'Success', {
+      data: true,
+      user: true,
+    });
+  });
+});
+
 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,
       },
     });
@@ -2624,7 +3771,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({
@@ -2640,9 +3787,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 },
@@ -2652,6 +3798,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: {} });
@@ -2663,10 +3823,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 }
@@ -2686,48 +3846,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(() => {
@@ -2777,17 +3895,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,
@@ -2820,28 +3943,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,
@@ -2851,8 +3986,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),
       }),
@@ -2901,6 +4036,36 @@ describe('Protocol V2 file write method', () => {
 });
 
 describe('Protocol V2 file read method', () => {
+  test('uses a 900-byte chunk limit by default in BLE environments', async () => {
+    const getSettingsSpy = jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native');
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { data: new Uint8Array(900) } })
+      .mockResolvedValueOnce({ message: { data: new Uint8Array(1) } });
+    const method = new FileRead({
+      id: 1,
+      payload: {
+        method: 'fileRead',
+        path: 'vol1:test.bin',
+        offset: 0,
+        totalSize: 901,
+      },
+    });
+    (method as any).device = stubDevice({ commands: { typedCall } });
+
+    try {
+      method.init();
+      await method.run();
+    } finally {
+      getSettingsSpy.mockRestore();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall.mock.calls[0][2].chunk_len).toBe(900);
+    expect(typedCall.mock.calls[1][2].file.offset).toBe(900);
+    expect(typedCall.mock.calls[1][2].chunk_len).toBe(1);
+  });
+
   test('rejects invalid read and directory parameters before transport call', () => {
     expect(() => {
       const method = new FileRead({
@@ -2977,7 +4142,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: {
@@ -2986,7 +4151,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);