@onekeyfe/hd-core 1.2.0-alpha.8 → 1.2.0-alpha.9

package/__tests__/protocol-v2.test.ts

@@ -13,6 +13,9 @@ import DeviceFirmwareUpdate from '../src/api/protocol-v2/DeviceFirmwareUpdate';
 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';
@@ -42,12 +45,17 @@ 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,
   requestProtocolV2DeviceInfo,
 } from '../src/protocols/protocol-v2/features';
+import {
+  getProtocolV2WalletSession,
+  refreshProtocolV2DeviceStatus,
+} from '../src/protocols/protocol-v2/walletSession';
 import { buildProfileFromProtocolV2, buildProtocolV2FeaturesPayload } from '../src/deviceProfile';
 import {
   getDeviceType,
@@ -243,6 +251,7 @@ describe('Protocol V2 feature adapter', () => {
   test('uses DeviceSessionGet for Protocol V2 passphrase sessions', async () => {
     const features = normalizeProtocolV2Features(descriptor as any);
     features.firmwareVersion = '1.2.3';
+    features.passphraseProtection = true;
     const typedCall = jest.fn().mockResolvedValue({
       type: 'DeviceSession',
       message: {
@@ -260,10 +269,16 @@ describe('Protocol V2 feature adapter', () => {
     });
     expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
 
-    await getPassphraseState(device, {
-      expectPassphraseState: 'state-2',
-      allowCreateAttachPin: true,
-    });
+    await expect(
+      getPassphraseState(device, {
+        expectPassphraseState: 'state-2',
+        allowCreateAttachPin: true,
+      })
+    ).rejects.toEqual(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+      })
+    );
     expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
 
     await getPassphraseState(device, {
@@ -272,6 +287,266 @@ describe('Protocol V2 feature adapter', () => {
     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 },
+    });
+    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 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,
+      },
+    });
+    (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 = {
       deviceId: 'pro-device-id',
@@ -534,8 +809,10 @@ describe('Protocol V2 feature adapter', () => {
     (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();
@@ -1297,9 +1574,24 @@ describe('Protocol V2 feature adapter', () => {
       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 === 'UnLockDevice') {
+        return {
+          type: 'UnLockDeviceResponse',
+          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 };
@@ -1316,18 +1608,22 @@ describe('Protocol V2 feature adapter', () => {
 
     const features = await device.unlockDevice();
 
-    expect(typedCall).toHaveBeenCalledWith('UnLockDevice', 'UnLockDeviceResponse');
+    expect(typedCall.mock.calls).toEqual([
+      ['UnLockDevice', 'UnLockDeviceResponse'],
+      ['DeviceStatusGet', 'DeviceStatus', {}],
+    ]);
     expect(typedCall).not.toHaveBeenCalledWith('GetAddress', 'Address', expect.anything());
     expect(typedCall).not.toHaveBeenCalledWith('GetFeatures', 'Features', {});
     expect(features).toMatchObject({
       deviceType: 'pro2',
-      deviceId: null,
+      deviceId: 'PRO2-DEVICE-ID',
       firmwareVersion: '1.2.3',
       unlocked: true,
+      passphraseProtection: true,
     });
   });
 
-  test('syncs Protocol V2 features 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,
@@ -1337,6 +1633,74 @@ describe('Protocol V2 feature adapter', () => {
         status: { passphrase_enabled: false },
       }
     );
+    const typedCall = jest.fn().mockImplementation(requestType => {
+      if (requestType === 'UnLockDevice') {
+        return {
+          type: 'UnLockDeviceResponse',
+          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 UnLockDevice 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).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: {
@@ -1347,11 +1711,12 @@ describe('Protocol V2 feature adapter', () => {
     });
     (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);
+    await expect(device.unlockDevice()).resolves.toMatchObject({
+      unlocked: true,
+      unlockedAttachPin: true,
+      passphraseProtection: true,
+    });
+    expect(typedCall.mock.calls).toEqual([['UnLockDevice', 'UnLockDeviceResponse']]);
   });
 });
 
@@ -1840,13 +2205,12 @@ describe('Protocol V2 firmware update targets', () => {
       originalDescriptor: { id: 'ble-id', path: 'ble-path', protocolType: 'V2' },
       features: { capabilities: [] },
     });
-    (method as any).prepareResourceBinaries = jest.fn().mockResolvedValue([]);
     (method as any).prepareBootloaderBinary = jest.fn().mockReturnValue(null);
     (method as any).collectExplicitTargetBinaries = jest.fn().mockReturnValue([
       {
         fileName: 'coprocessor.bin',
         binary: new Uint8Array([1, 2, 3]).buffer,
-        targetId: 6,
+        targetId: 5,
       },
     ]);
     (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
@@ -1864,12 +2228,11 @@ describe('Protocol V2 firmware update targets', () => {
 
     expect((method as any).enterProtocolV2BootloaderMode).toHaveBeenCalledTimes(1);
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
-      resourceBinaryMap: [],
       fwBinaryMap: [
         {
           fileName: 'coprocessor.bin',
           binary: expect.any(ArrayBuffer),
-          targetId: 6,
+          targetId: 5,
         },
       ],
       bootloaderBinary: null,
@@ -2052,7 +2415,7 @@ describe('Protocol V2 firmware update targets', () => {
 
     await expect(
       (method as any).protocolV2StartFirmwareUpdate({
-        targets: [{ target_id: 1, path: 'vol1:resource.bin' }],
+        targets: [{ target_id: 4, path: 'vol1:application_p1.bin' }],
       })
     ).resolves.toBeUndefined();
 
@@ -2192,12 +2555,12 @@ describe('Protocol V2 firmware update targets', () => {
       (method as any).assertProtocolV2TargetStatus(
         [
           {
-            target_id: 'FW_MGMT_TARGET_CRATE',
+            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([1, 10])
+        new Set([4, 10])
       )
     ).toBe(true);
 
@@ -2233,7 +2596,7 @@ describe('Protocol V2 firmware update targets', () => {
     }
   });
 
-  test('passes resource, bootloader, coprocessor, SE and app files to DeviceFirmwareUpdate targets', async () => {
+  test('passes bootloader, coprocessor, SE and app files to DeviceFirmwareUpdate targets', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -2248,19 +2611,13 @@ describe('Protocol V2 firmware update targets', () => {
       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({
-      resourceBinaryMap: [
-        {
-          fileName: 'resource.bin',
-          binary: new Uint8Array([1, 2, 3]).buffer,
-          targetId: 1,
-        },
-      ],
       bootloaderBinary: new Uint8Array([4, 5]).buffer,
       fwBinaryMap: [
         {
@@ -2282,43 +2639,37 @@ describe('Protocol V2 firmware update targets', () => {
     });
 
     expect(writtenPaths).toEqual([
-      'vol1:resource.bin',
-      'vol1:bootloader.bin',
-      'vol1:coprocessor.bin',
-      'vol1:se01.bin',
-      'vol1:application_p1.bin',
+      'vol0:/bootloader.bin',
+      'vol0:/coprocessor.bin',
+      'vol0:/se01.bin',
+      'vol0:/application_p1.bin',
     ]);
+    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: 1, path: 'vol1:resource.bin' },
-        { target_id: 3, path: 'vol1:bootloader.bin' },
-        { target_id: 6, path: 'vol1:coprocessor.bin' },
-        { target_id: 7, path: 'vol1:se01.bin' },
-        { target_id: 4, path: 'vol1:application_p1.bin' },
+        { 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',
-        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();
@@ -2327,57 +2678,121 @@ describe('Protocol V2 firmware update targets', () => {
       .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({
-      resourceBinaryMap: [],
+      resourceBundles: [
+        {
+          name: 'images.okpkg',
+          binary: new Uint8Array([1, 2]).buffer,
+          devicePath: 'vol0:/bundles/images/images.okpkg',
+        },
+      ],
       bootloaderBinary: null,
-      fwBinaryMap: explicit,
+      fwBinaryMap: [
+        {
+          fileName: 'application_p1.bin',
+          binary: new Uint8Array([3]).buffer,
+          targetId: 3,
+        },
+      ],
     });
 
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
-      targets: [
-        { target_id: 5, path: 'vol1:application_p2.bin' },
-        { target_id: 10, path: 'vol1:se04.bin' },
-      ],
+    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('maps explicit Pro2 resource crate binaries to separate CRATE targets', async () => {
-    const firstResource = new Uint8Array([1]).buffer;
-    const secondResource = new Uint8Array([2]).buffer;
+  test('passes explicit per-target binaries through without file name heuristics', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
         platform: 'web',
-        resourceBinaries: [firstResource, secondResource],
+        applicationP2Binary: new Uint8Array([2]).buffer,
+        se04Binary: new Uint8Array([3]).buffer,
       },
     });
     method.init();
 
-    const resourceTargets = await (method as any).prepareResourceBinaries('universal', {
-      deviceType: 'pro2',
-      firmwareVersion: '1.0.0',
-      capabilities: [],
+    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(resourceTargets).toEqual([
-      {
-        fileName: 'resource-1.bin',
-        binary: firstResource,
-        targetId: 1,
-      },
-      {
-        fileName: 'resource-2.bin',
-        binary: secondResource,
-        targetId: 1,
-      },
-    ]);
-    expect((method as any).hasExplicitProtocolV2Payload([])).toBe(true);
+    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', () => {
@@ -2509,234 +2924,7 @@ describe('Protocol V2 firmware update targets', () => {
     getFirmwareLatestReleaseSpy.mockRestore();
   });
 
-  test('skips Pro2 resource crate download when resourceManifest matches device OKPP headers', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-      },
-    });
-    method.init();
-
-    const payloadHash = 'ab'.repeat(64);
-    const header = buildOkppHeader({ payloadHash });
-    const typedCall = jest.fn(
-      (name: string, _resType: string, params: { file: { offset: number }; chunk_len: number }) => {
-        if (name === 'FilesystemPathInfoQuery') {
-          return Promise.resolve({
-            type: 'FilesystemPathInfo',
-            message: { exist: true, directory: false, size: header.byteLength },
-          });
-        }
-        if (name === 'FilesystemFileRead') {
-          const { offset } = params.file;
-          const readLen = params.chunk_len;
-          return Promise.resolve({
-            type: 'FilesystemFile',
-            message: { data: header.slice(offset, offset + readLen) },
-          });
-        }
-        return Promise.reject(new Error(`unexpected call ${name}`));
-      }
-    );
-    (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall }),
-    });
-
-    const getSysResourceBinarySpy = jest
-      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
-      .mockResolvedValue({ binary: new Uint8Array([9]).buffer });
-    const getFirmwareLatestReleaseSpy = jest
-      .spyOn(DataManager, 'getFirmwareLatestRelease')
-      .mockReturnValue({
-        required: false,
-        version: [1, 0, 0],
-        url: '',
-        upgradeType: 'payload-package-set',
-        installOrder: ['resource'],
-        components: {
-          resource: {
-            target: 'CRATE',
-            url: 'https://example.com/pro2-resource.crate.okpkg',
-          },
-        },
-        resourceManifest: {
-          format: 'okpkg-crate',
-          target: 'CRATE',
-          version: [1, 0, 0],
-          packages: [
-            {
-              path: 'resource/images/images.okpkg',
-              type: 'RESC',
-              payloadHash,
-            },
-          ],
-        },
-        fingerprint: '',
-        changelog: {
-          'zh-CN': '',
-          'en-US': '',
-        },
-      });
-
-    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
-      deviceType: 'pro2',
-      firmwareVersion: '1.0.0',
-      capabilities: [],
-    });
-
-    expect(remoteBinaries).toEqual({
-      resourceBinaryMap: [],
-      bootloaderBinary: null,
-      fwBinaryMap: [],
-      installItems: [],
-    });
-    expect(getSysResourceBinarySpy).not.toHaveBeenCalled();
-    expect(typedCall.mock.calls[0][2]).toEqual({
-      path: 'vol0:/resource/images/images.okpkg',
-    });
-
-    getSysResourceBinarySpy.mockRestore();
-    getFirmwareLatestReleaseSpy.mockRestore();
-  });
-
-  test('downloads Pro2 resource crate when resourceManifest package is missing', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-      },
-    });
-    method.init();
-
-    const resourceBinary = new Uint8Array([9]).buffer;
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'FilesystemPathInfo',
-      message: { exist: false, directory: false, size: 0 },
-    });
-    (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall }),
-    });
-
-    const getSysResourceBinarySpy = jest
-      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
-      .mockResolvedValue({ binary: resourceBinary });
-    const getFirmwareLatestReleaseSpy = jest
-      .spyOn(DataManager, 'getFirmwareLatestRelease')
-      .mockReturnValue({
-        required: false,
-        version: [1, 0, 0],
-        url: '',
-        upgradeType: 'payload-package-set',
-        installOrder: ['resource'],
-        components: {
-          resource: {
-            target: 'CRATE',
-            url: 'https://example.com/pro2-resource.crate.okpkg',
-            resourceManifest: {
-              format: 'okpkg-crate',
-              target: 'CRATE',
-              version: [1, 0, 0],
-              packages: [{ path: 'resource/images/images.okpkg', type: 'RESC' }],
-            },
-          },
-        },
-        fingerprint: '',
-        changelog: {
-          'zh-CN': '',
-          'en-US': '',
-        },
-      });
-
-    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
-      deviceType: 'pro2',
-      firmwareVersion: '1.0.0',
-      capabilities: [],
-    });
-
-    expect(remoteBinaries.resourceBinaryMap).toEqual([
-      {
-        fileName: 'resource.bin',
-        binary: resourceBinary,
-        targetId: 1,
-      },
-    ]);
-    expect(getSysResourceBinarySpy).toHaveBeenCalledWith(
-      'https://example.com/pro2-resource.crate.okpkg'
-    );
-
-    getSysResourceBinarySpy.mockRestore();
-    getFirmwareLatestReleaseSpy.mockRestore();
-  });
-
-  test('maps Pro2 CRATE remote component to resource binary target', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'web',
-      },
-    });
-    method.init();
-
-    const resourceBinary = new Uint8Array([1, 2, 3]).buffer;
-    const getSysResourceBinarySpy = jest
-      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
-      .mockResolvedValue({ binary: resourceBinary });
-    const getFirmwareLatestReleaseSpy = jest
-      .spyOn(DataManager, 'getFirmwareLatestRelease')
-      .mockReturnValue({
-        required: false,
-        version: [1, 0, 0],
-        url: '',
-        upgradeType: 'payload-package-set',
-        installOrder: ['resource'],
-        components: {
-          resource: {
-            target: 'CRATE',
-            url: 'https://example.com/pro2-resource.crate.okpkg',
-          },
-        },
-        fingerprint: '',
-        changelog: {
-          'zh-CN': '',
-          'en-US': '',
-        },
-      });
-
-    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
-      deviceType: 'pro2',
-      firmwareVersion: '0.0.0',
-      capabilities: [],
-    });
-
-    expect(remoteBinaries).toEqual({
-      resourceBinaryMap: [
-        {
-          fileName: 'resource.bin',
-          binary: resourceBinary,
-          targetId: 1,
-        },
-      ],
-      bootloaderBinary: null,
-      fwBinaryMap: [],
-      installItems: [
-        {
-          fileName: 'resource.bin',
-          binary: resourceBinary,
-          targetId: 1,
-          kind: 'resource',
-        },
-      ],
-    });
-
-    getSysResourceBinarySpy.mockRestore();
-    getFirmwareLatestReleaseSpy.mockRestore();
-  });
-
-  test('downloads only unmatched Pro2 resource crate components by component manifests', async () => {
+  test('maps remote Pro2 resource bundles to direct-write descriptors', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -2746,76 +2934,22 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.init();
 
-    const imagesPayloadHash = 'ab'.repeat(64);
-    const imagesHeader = buildOkppHeader({ payloadHash: imagesPayloadHash });
-    const fontsBinary = new Uint8Array([7, 8, 9]).buffer;
-    const typedCall = jest.fn(
-      (
-        name: string,
-        _resType: string,
-        params: { path?: string; file?: { offset: number }; chunk_len?: number }
-      ) => {
-        if (name === 'FilesystemPathInfoQuery') {
-          const exist = params.path === 'vol0:/resource/images/images.okpkg';
-          return Promise.resolve({
-            type: 'FilesystemPathInfo',
-            message: { exist, directory: false, size: exist ? imagesHeader.byteLength : 0 },
-          });
-        }
-        if (name === 'FilesystemFileRead') {
-          const offset = params.file?.offset ?? 0;
-          const readLen = params.chunk_len ?? 0;
-          return Promise.resolve({
-            type: 'FilesystemFile',
-            message: { data: imagesHeader.slice(offset, offset + readLen) },
-          });
-        }
-        return Promise.reject(new Error(`unexpected call ${name}`));
-      }
-    );
-    (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall }),
-    });
-
-    const getSysResourceBinarySpy = jest
-      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
-      .mockResolvedValue({ binary: fontsBinary });
     const getFirmwareLatestReleaseSpy = jest
       .spyOn(DataManager, 'getFirmwareLatestRelease')
       .mockReturnValue({
         required: false,
         version: [1, 0, 0],
         url: '',
-        upgradeType: 'payload-package-set',
-        installOrder: ['resourceImages', 'resourceFonts'],
-        components: {
-          resourceImages: {
-            target: 'CRATE',
-            url: 'https://example.com/pro2-resource-images.crate.okpkg',
-            resourceManifest: {
-              format: 'okpkg-crate',
-              target: 'CRATE',
-              version: [1, 0, 0],
-              packages: [
-                {
-                  path: 'resource/images/images.okpkg',
-                  type: 'RESC',
-                  payloadHash: imagesPayloadHash,
-                },
-              ],
-            },
-          },
-          resourceFonts: {
-            target: 'CRATE',
-            url: 'https://example.com/pro2-resource-fonts.crate.okpkg',
-            resourceManifest: {
-              format: 'okpkg-crate',
-              target: 'CRATE',
-              version: [1, 0, 0],
-              packages: [{ path: 'resource/font/noto.okpkg', type: 'RESC' }],
-            },
+        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': '',
@@ -2823,89 +2957,28 @@ describe('Protocol V2 firmware update targets', () => {
         },
       });
 
-    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+    const bundles = (method as any).prepareProtocolV2ResourceBundles('universal', {
       deviceType: 'pro2',
       firmwareVersion: '1.0.0',
       capabilities: [],
     });
 
-    expect(remoteBinaries.resourceBinaryMap).toEqual([
+    expect(bundles).toEqual([
       {
-        fileName: 'resource-resourceFonts.bin',
-        binary: fontsBinary,
-        targetId: 1,
+        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(getSysResourceBinarySpy).toHaveBeenCalledTimes(1);
-    expect(getSysResourceBinarySpy).toHaveBeenCalledWith(
-      'https://example.com/pro2-resource-fonts.crate.okpkg'
-    );
+    expect(bundles[0].binary.byteLength).toBe(0);
 
-    getSysResourceBinarySpy.mockRestore();
     getFirmwareLatestReleaseSpy.mockRestore();
   });
 
-  test('installs merged Pro2 resource crate and firmware targets in one update request', async () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-      },
-    });
-
-    const operations: string[] = [];
-    method.postTipMessage = jest.fn();
-    method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest
-      .fn()
-      .mockImplementation(params => {
-        operations.push(`write:${params.filePath}`);
-        return Promise.resolve(
-          Number(params.processedSize ?? 0) + Number(params.payload.byteLength)
-        );
-      });
-    (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockImplementation(({ targets }) => {
-      operations.push(
-        `install:${targets.map((target: { path: string }) => target.path).join(',')}`
-      );
-      return Promise.resolve(undefined);
-    });
-    (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
-      .fn()
-      .mockResolvedValue(undefined);
-
-    await (method as any).executeProtocolV2Update({
-      resourceBinaryMap: [
-        {
-          fileName: 'resource.bin',
-          binary: new Uint8Array([1, 2]).buffer,
-          targetId: 1,
-        },
-      ],
-      bootloaderBinary: null,
-      fwBinaryMap: [
-        {
-          fileName: 'application_p1.bin',
-          binary: new Uint8Array([3]).buffer,
-          targetId: 4,
-        },
-      ],
-    });
-
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(1);
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
-      targets: [
-        { target_id: 1, path: 'vol1:resource.bin' },
-        { target_id: 4, path: 'vol1:application_p1.bin' },
-      ],
-    });
-    expect(operations).toEqual([
-      'write:vol1:resource.bin',
-      'write:vol1:application_p1.bin',
-      'install:vol1:resource.bin,vol1:application_p1.bin',
-    ]);
-  });
-
   test('skips Pro2 firmware components when configured versions are already installed', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -2957,7 +3030,6 @@ describe('Protocol V2 firmware update targets', () => {
     });
 
     expect(remoteBinaries).toEqual({
-      resourceBinaryMap: [],
       bootloaderBinary: null,
       fwBinaryMap: [],
       installItems: [],
@@ -2979,13 +3051,12 @@ describe('Protocol V2 firmware update targets', () => {
     method.init();
 
     const remoteBinaries = {
-      resourceBinaryMap: [],
       bootloaderBinary: new Uint8Array([1]).buffer,
       fwBinaryMap: [
         {
           fileName: 'application_p1.bin',
           binary: new Uint8Array([2]).buffer,
-          targetId: 4,
+          targetId: 3,
         },
       ],
     };
@@ -2994,7 +3065,6 @@ describe('Protocol V2 firmware update targets', () => {
       originalDescriptor: { protocolType: 'V2' },
       features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
     });
-    (method as any).prepareResourceBinaries = jest.fn().mockResolvedValue([]);
     (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue(remoteBinaries);
     (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(true);
     (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
@@ -3010,7 +3080,6 @@ describe('Protocol V2 firmware update targets', () => {
 
     expect((method as any).prepareRemoteProtocolV2Binaries).toHaveBeenCalledTimes(1);
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
-      resourceBinaryMap: remoteBinaries.resourceBinaryMap,
       bootloaderBinary: remoteBinaries.bootloaderBinary,
       fwBinaryMap: remoteBinaries.fwBinaryMap,
     });
@@ -3031,7 +3100,6 @@ describe('Protocol V2 firmware update targets', () => {
       originalDescriptor: { protocolType: 'V2' },
       features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
     });
-    (method as any).prepareResourceBinaries = jest.fn().mockResolvedValue([]);
     (method as any).prepareRemoteProtocolV2Binaries = jest.fn();
     (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(true);
     (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
@@ -3047,12 +3115,90 @@ describe('Protocol V2 firmware update targets', () => {
 
     expect((method as any).prepareRemoteProtocolV2Binaries).not.toHaveBeenCalled();
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
-      resourceBinaryMap: [],
       bootloaderBinary: null,
       fwBinaryMap: [{ fileName: 'coprocessor.bin', binary: expect.anything(), targetId: 6 }],
     });
   });
 
+  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',
+      },
+    });
+
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+    (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({
+      resourceBundles: [
+        {
+          name: 'images.okpkg',
+          binary: new Uint8Array([1, 2, 3]).buffer,
+          devicePath: 'vol0:/resource/images/images.okpkg',
+        },
+      ],
+      bootloaderBinary: null,
+      fwBinaryMap: [],
+    });
+
+    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 () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -3094,6 +3240,60 @@ describe('Protocol V2 firmware update targets', () => {
     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 () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -3110,6 +3310,12 @@ describe('Protocol V2 firmware update targets', () => {
           },
         });
       }
+      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' } });
       }
@@ -3131,7 +3337,6 @@ describe('Protocol V2 firmware update targets', () => {
     method.postTipMessage = jest.fn();
 
     await (method as any).executeProtocolV2Update({
-      resourceBinaryMap: [],
       bootloaderBinary: null,
       fwBinaryMap: [
         {
@@ -3146,9 +3351,11 @@ describe('Protocol V2 firmware update targets', () => {
       'DeviceFirmwareUpdateRequest',
       ['Success', 'DeviceFirmwareUpdateStatus'],
       {
-        targets: [{ target_id: 4, path: 'vol1:firmware.bin' }],
+        targets: [{ target_id: 4, path: 'vol0:/firmware.bin' }],
       },
-      expect.any(Object)
+      expect.objectContaining({
+        timeoutMs: 3 * 60 * 1000,
+      })
     );
   });
 
@@ -3332,6 +3539,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({
@@ -3341,8 +3572,8 @@ describe('Protocol V2 firmware update method', () => {
         targets: [
           {
             target_id: undefined,
-            targetId: 4,
-            path: 'vol0:firmware.bin',
+            targetId: 1,
+            path: 'vol0:resource.crate.okpkg',
           },
         ],
       } as any,
@@ -3354,7 +3585,7 @@ describe('Protocol V2 firmware update method', () => {
 
     await method.run();
     expect(typedCall.mock.calls[0][2]).toEqual({
-      targets: [{ target_id: 4, path: 'vol0:firmware.bin' }],
+      targets: [{ target_id: 1, path: 'vol0:resource.crate.okpkg' }],
     });
   });
 
@@ -3364,8 +3595,8 @@ describe('Protocol V2 firmware update method', () => {
       id: 1,
       payload: {
         method: 'deviceFirmwareUpdate',
-        targetId: 'FW_MGMT_TARGET_CRATE',
-        path: 'vol0:resource.bin',
+        targetId: 'FW_MGMT_TARGET_APPLICATION_P1',
+        path: 'vol0:application_p1.bin',
       },
     });
     method.init();
@@ -3375,7 +3606,7 @@ describe('Protocol V2 firmware update method', () => {
 
     await method.run();
     expect(typedCall.mock.calls[0][2]).toEqual({
-      targets: [{ target_id: 1, path: 'vol0:resource.bin' }],
+      targets: [{ target_id: 4, path: 'vol0:application_p1.bin' }],
     });
   });
 
@@ -3505,6 +3736,23 @@ describe('Protocol V2 current low-level methods', () => {
 
     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', () => {
@@ -3787,6 +4035,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({