@onekeyfe/hd-core 1.1.27-alpha.30 → 1.1.27-alpha.32

package/__tests__/protocol-v2.test.ts

@@ -1,19 +1,31 @@
 import JSZip from 'jszip';
-import { DevRebootType } from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceRebootType } from '@onekeyfe/hd-transport';
 
+import ConfluxSignTransaction from '../src/api/conflux/ConfluxSignTransaction';
+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 DevFirmwareUpdate from '../src/api/protocol-v2/DevFirmwareUpdate';
-import DevGetOnboardingStatus from '../src/api/protocol-v2/DevGetOnboardingStatus';
+import DeviceFirmwareUpdate from '../src/api/protocol-v2/DeviceFirmwareUpdate';
+import DeviceGetOnboardingStatus from '../src/api/protocol-v2/DeviceGetOnboardingStatus';
 import FirmwareUpdateV3 from '../src/api/FirmwareUpdateV3';
 import FirmwareUpdateV4 from '../src/api/FirmwareUpdateV4';
 import GetOnekeyFeatures from '../src/api/GetOnekeyFeatures';
+import { batchGetPublickeys } from '../src/api/helpers/batchGetPublickeys';
 import KaspaGetAddress from '../src/api/kaspa/KaspaGetAddress';
+import TronSignMessage from '../src/api/tron/TronSignMessage';
+import XrpSignTransaction from '../src/api/xrp/XrpSignTransaction';
 import { DataManager } from '../src/data-manager';
 import { Device } from '../src/device/Device';
 import { UI_REQUEST } from '../src/events/ui-request';
 import { getProtocolV2Features, normalizeProtocolV2Features } from '../src/protocols/protocol-v2';
 import { shouldSkipMethodSupportCheck } from '../src/utils';
+import {
+  getPassphraseState,
+  getPassphraseStateWithRefreshDeviceInfo,
+} from '../src/utils/deviceFeaturesUtils';
 
 import type { DeviceCommands } from '../src/device/DeviceCommands';
 
@@ -110,6 +122,113 @@ describe('Protocol V2 feature adapter', () => {
     expect(features.ble_enable).toBe(true);
   });
 
+  test('uses GetPassphraseState payloads compatible with Pro1 passphrase flow', async () => {
+    const features = normalizeProtocolV2Features(descriptor as any);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'PassphraseState',
+      message: {
+        passphrase_state: 'state-1',
+        session_id: 'session-1',
+        unlocked_attach_pin: false,
+      },
+    });
+    const commands = { typedCall } as unknown as DeviceCommands;
+
+    await getPassphraseState(features, commands, {
+      expectPassphraseState: 'state-1',
+    });
+    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
+      passphrase_state: 'state-1',
+    });
+
+    await getPassphraseState(features, commands, {
+      expectPassphraseState: 'state-2',
+      allowCreateAttachPin: true,
+    });
+    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
+      passphrase_state: 'state-2',
+      allow_create_attach_pin: true,
+    });
+
+    await getPassphraseState(features, commands, {
+      onlyMainPin: true,
+    });
+    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
+      _only_main_pin: true,
+    });
+  });
+
+  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',
+      message: {
+        passphrase_state: 'state-auto',
+        session_id: 'session-auto',
+        unlocked_attach_pin: false,
+      },
+    });
+
+    (device as any).features = normalizeProtocolV2Features({
+      ...descriptor,
+      protocolType: 'V2',
+    } as any);
+    (device as any).commands = { typedCall };
+
+    await expect(getPassphraseStateWithRefreshDeviceInfo(device)).resolves.toMatchObject({
+      passphraseState: 'state-auto',
+      newSession: 'session-auto',
+    });
+
+    expect(device.passphraseState).toBeUndefined();
+    expect(device.features?.passphrase_protection).toBe(true);
+    expect(device.features?.session_id).toBe('session-auto');
+    expect(device.getInternalState()).toBeUndefined();
+    device.passphraseState = 'state-auto';
+    expect(device.getInternalState()).toBe('session-auto');
+    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
+      passphrase_state: undefined,
+    });
+  });
+
+  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',
+      message: {
+        session_id: 'main-pin-session',
+        unlocked_attach_pin: false,
+      },
+    });
+
+    (device as any).features = normalizeProtocolV2Features(
+      {
+        ...descriptor,
+        protocolType: 'V2',
+      } as any,
+      {
+        status: {
+          passphrase_protection: false,
+        },
+      }
+    );
+    (device as any).commands = { typedCall };
+
+    await expect(
+      getPassphraseStateWithRefreshDeviceInfo(device, { onlyMainPin: true })
+    ).resolves.toMatchObject({
+      passphraseState: undefined,
+      newSession: 'main-pin-session',
+    });
+
+    expect(device.features?.passphrase_protection).toBe(false);
+    expect(device.features?.session_id).toBe('main-pin-session');
+    expect(device.getInternalState()).toBeUndefined();
+    expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
+      _only_main_pin: true,
+    });
+  });
+
   test('marks fallback features as unavailable when DeviceInfo is missing', () => {
     const features = normalizeProtocolV2Features(descriptor as any);
 
@@ -131,10 +250,45 @@ describe('Protocol V2 feature adapter', () => {
     expect(shouldSkipMethodSupportCheck(features)).toBe(true);
   });
 
-  test('initializes Protocol V2 features with Ping only while DeviceInfo is unsupported', async () => {
+  test('initializes Protocol V2 features from DeviceGetDeviceInfo after Ping', async () => {
+    const commands = {
+      typedCall: jest
+        .fn()
+        .mockResolvedValueOnce({ type: 'Success', message: { message: 'pong' } })
+        .mockResolvedValueOnce({
+          type: 'DeviceInfo',
+          message: {
+            hw: { serial_no: 'PR2SERIAL' },
+            status: {
+              init_states: true,
+              passphrase_protection: true,
+            },
+          },
+        }),
+    };
+
+    const features = await getProtocolV2Features({
+      commands: commands as unknown as DeviceCommands,
+      descriptor: descriptor as any,
+    });
+
+    expect(features.device_id).toBe('PR2SERIAL');
+    expect(features.initialized).toBe(true);
+    expect(features.passphrase_protection).toBe(true);
+    expect(commands.typedCall).toHaveBeenNthCalledWith(1, 'Ping', 'Success', { message: 'init' });
+    expect(commands.typedCall).toHaveBeenNthCalledWith(2, 'DeviceGetDeviceInfo', 'DeviceInfo', {
+      targets: expect.objectContaining({ status: true }),
+      types: expect.objectContaining({ specific: true }),
+    });
+  });
+
+  test('falls back to descriptor features when Protocol V2 DeviceGetDeviceInfo fails', async () => {
     const onDeviceInfoError = jest.fn();
     const commands = {
-      typedCall: jest.fn().mockResolvedValueOnce({ type: 'Success', message: { message: 'pong' } }),
+      typedCall: jest
+        .fn()
+        .mockResolvedValueOnce({ type: 'Success', message: { message: 'pong' } })
+        .mockRejectedValueOnce(new Error('DeviceInfo not supported')),
     };
 
     const features = await getProtocolV2Features({
@@ -144,9 +298,8 @@ describe('Protocol V2 feature adapter', () => {
     });
 
     expect(features.device_id).toBe('usb-path');
-    expect(commands.typedCall).toHaveBeenNthCalledWith(1, 'Ping', 'Success', { message: 'init' });
-    expect(commands.typedCall).toHaveBeenCalledTimes(1);
-    expect(onDeviceInfoError).not.toHaveBeenCalled();
+    expect(features.passphrase_protection).toBeNull();
+    expect(onDeviceInfoError).toHaveBeenCalledWith(expect.any(Error));
   });
 
   test('does not block method-level legacy version checks on Protocol V2', async () => {
@@ -182,6 +335,35 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenCalledWith('KaspaGetAddress', 'KaspaAddress', expect.any(Object));
   });
 
+  test('does not block legacy 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',
+      message: {
+        root_fingerprint: 123,
+        public_keys: [],
+        hd_nodes: [{}],
+      },
+    });
+    const device = {
+      originalDescriptor: { protocolType: 'V2' },
+      features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
+      commands: { typedCall },
+    };
+
+    await expect(
+      batchGetPublickeys(device as any, paths, 'secp256k1', 0, { includeNode: true })
+    ).resolves.toMatchObject({
+      root_fingerprint: 123,
+      hd_nodes: [{}],
+    });
+    expect(typedCall).toHaveBeenCalledWith('BatchGetPublickeys', 'EcdsaPublicKeys', {
+      paths,
+      ecdsa_curve_name: 'secp256k1',
+      include_node: true,
+    });
+  });
+
   test('returns Protocol V2 oneKey fields without calling legacy OnekeyGetFeatures', async () => {
     const method = new GetOnekeyFeatures({
       id: 1,
@@ -224,15 +406,25 @@ describe('Protocol V2 feature adapter', () => {
     } as any);
     const typedCall = jest
       .fn()
-      .mockResolvedValueOnce({ type: 'Success', message: { message: 'init' } });
+      .mockResolvedValueOnce({ type: 'Success', message: { message: 'init' } })
+      .mockResolvedValueOnce({
+        type: 'DeviceInfo',
+        message: {
+          hw: { serial_no: 'PR2SERIAL' },
+          status: {
+            passphrase_protection: true,
+          },
+        },
+      });
 
     (device as any).commands = { typedCall };
 
     await device.initialize();
     await device.initialize();
 
-    expect(device.features?.device_id).toBe('usb-path');
-    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(device.features?.device_id).toBe('PR2SERIAL');
+    expect(device.features?.passphrase_protection).toBe(true);
+    expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenNthCalledWith(
       1,
       'Ping',
@@ -242,6 +434,139 @@ describe('Protocol V2 feature adapter', () => {
         timeoutMs: 10000,
       }
     );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'DeviceGetDeviceInfo',
+      'DeviceInfo',
+      {
+        targets: expect.objectContaining({ status: true }),
+        types: expect.objectContaining({ specific: true }),
+      },
+      {
+        timeoutMs: 10000,
+      }
+    );
+  });
+});
+
+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('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,
+      payload: {
+        method: 'dnxSignTransaction',
+        path: "m/44'/29538'/0'/0/0",
+        inputs: [
+          {
+            prevIndex: 1,
+            globalIndex: 1,
+            txPubkey: '00',
+            prevOutPubkey: '00',
+            amount: '1',
+          },
+        ],
+        toAddress: 'dnx-address',
+        amount: '1',
+        fee: '1',
+      },
+    });
+
+    method.init();
+    (method as any).device = {
+      originalDescriptor: { protocolType: 'V2' },
+      features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
+    };
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+    });
+  });
+
+  test('returns a typed unsupported error for Dynex address on Protocol V2', async () => {
+    const method = new DnxGetAddress({
+      id: 1,
+      payload: {
+        method: 'dnxGetAddress',
+        path: "m/44'/29538'/0'/0/0",
+        showOnOneKey: false,
+      },
+    });
+
+    method.init();
+    (method as any).device = {
+      originalDescriptor: { protocolType: 'V2' },
+      features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
+    };
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+    });
   });
 });
 
@@ -272,6 +597,9 @@ describe('Protocol V2 firmware update targets', () => {
       if (name === 'Ping') {
         return Promise.resolve({ type: 'Success', message: { message: 'init' } });
       }
+      if (name === 'DeviceGetDeviceInfo') {
+        return Promise.resolve({ type: 'DeviceInfo', message: {} });
+      }
       return Promise.reject(new Error(`unexpected call ${name}`));
     });
     const commands = { typedCall };
@@ -294,7 +622,17 @@ describe('Protocol V2 firmware update targets', () => {
       { message: 'init' },
       { timeoutMs: 5000 }
     );
-    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'DeviceGetDeviceInfo',
+      'DeviceInfo',
+      {
+        targets: expect.objectContaining({ status: true }),
+        types: expect.objectContaining({ specific: true }),
+      },
+      { timeoutMs: 5000 }
+    );
+    expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).not.toHaveBeenCalledWith('Initialize', 'Features', {});
     expect(versions).toEqual({
       bootloaderVersion: '0.0.0',
@@ -346,7 +684,7 @@ describe('Protocol V2 firmware update targets', () => {
       ],
       bootloaderBinary: null,
     });
-    expect((method as any).protocolV2Reboot).not.toHaveBeenCalledWith(DevRebootType.Bootloader);
+    expect((method as any).protocolV2Reboot).not.toHaveBeenCalledWith(DeviceRebootType.Bootloader);
     expect(method.postTipMessage).not.toHaveBeenCalledWith('AutoRebootToBootloader');
   });
 
@@ -365,7 +703,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 () => {
@@ -385,7 +723,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',
     });
   });
@@ -405,7 +743,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',
     });
   });
@@ -425,7 +763,7 @@ describe('Protocol V2 firmware update targets', () => {
         )
       )
       .mockResolvedValueOnce({
-        type: 'DevFirmwareUpdateStatus',
+        type: 'DeviceFirmwareUpdateStatus',
         message: {
           targets: [{ target_id: 2, status: 0 }],
         },
@@ -446,7 +784,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(2);
   });
 
-  test('passes resource, bootloader, BLE, SE and app files to DevFirmwareUpdate targets', async () => {
+  test('passes resource, bootloader, BLE, SE and app files to DeviceFirmwareUpdate targets', async () => {
     const resourceZip = new JSZip();
     resourceZip.file('icons/home.png', new Uint8Array([1, 2, 3]));
     const resourceBinary = await resourceZip.generateAsync({ type: 'arraybuffer' });
@@ -499,10 +837,10 @@ describe('Protocol V2 firmware update targets', () => {
     expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
       targets: [
         { target_id: 10, path: 'vol1:res/' },
-        { 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: 2, path: 'vol1:bootloader.bin' },
+        { target_id: 5, path: 'vol1:ble-firmware.bin' },
+        { target_id: 6, path: 'vol1:se1-firmware.bin' },
+        { target_id: 3, path: 'vol1:firmware.bin' },
       ],
     });
     expect((method as any).waitForProtocolV2FirmwareUpdateComplete).toHaveBeenCalled();
@@ -621,10 +959,10 @@ describe('Protocol V2 firmware update targets', () => {
     });
 
     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(['DeviceFirmwareInstallProgress']);
     callOptions.onIntermediateResponse({
-      type: 'DevFirmwareInstallProgress',
+      type: 'DeviceFirmwareInstallProgress',
       message: { target_id: 0, progress: 42 },
     });
 
@@ -639,7 +977,7 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'DevFirmwareUpdateStatus',
+      type: 'DeviceFirmwareUpdateStatus',
       message: { targets: [{ target_id: 0, status: 1 }] },
     });
 
@@ -653,24 +991,25 @@ describe('Protocol V2 firmware update targets', () => {
       targets: [{ target_id: 0, 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 () => {
-    const method = new DevFirmwareUpdate({
+  test('returns DeviceFirmwareUpdateStatus from low-level update trigger', async () => {
+    const method = new DeviceFirmwareUpdate({
       id: 1,
       payload: {
-        method: 'devFirmwareUpdate',
+        method: 'deviceFirmwareUpdate',
+        targetId: 3,
         path: 'vol0:firmware.bin',
       },
     });
     method.init();
 
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'DevFirmwareUpdateStatus',
+      type: 'DeviceFirmwareUpdateStatus',
       message: { targets: [{ target_id: 0, status: 1 }] },
     });
 
@@ -681,22 +1020,71 @@ describe('Protocol V2 firmware update method', () => {
     await expect(method.run()).resolves.toEqual({
       targets: [{ target_id: 0, 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: 3, path: 'vol0:firmware.bin' }],
+    });
+  });
+
+  test('rejects missing or invalid firmware targets before transport call', async () => {
+    const typedCall = jest.fn();
+    const method = new DeviceFirmwareUpdate({
+      id: 1,
+      payload: {
+        method: 'deviceFirmwareUpdate',
+        path: 'vol0:firmware.bin',
+      },
+    });
+    method.init();
+    (method as any).device = {
+      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({
+      id: 1,
+      payload: {
+        method: 'deviceFirmwareUpdate',
+        targets: [
+          {
+            target_id: undefined,
+            targetId: 3,
+            path: 'vol0:firmware.bin',
+          },
+        ],
+      } as any,
+    });
+    method.init();
+    (method as any).device = {
+      commands: { typedCall },
+    };
+
+    await method.run();
+    expect(typedCall.mock.calls[0][2]).toEqual({
+      targets: [{ target_id: 3, path: 'vol0:firmware.bin' }],
+    });
   });
 });
 
 describe('Protocol V2 onboarding status method', () => {
-  test('returns DevOnboardingStatus from low-level status query', async () => {
-    const method = new DevGetOnboardingStatus({
+  test('returns DeviceOnboardingStatus from low-level status query', async () => {
+    const method = new DeviceGetOnboardingStatus({
       id: 1,
       payload: {
-        method: 'devGetOnboardingStatus',
+        method: 'deviceGetOnboardingStatus',
       },
     });
     method.init();
 
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'DevOnboardingStatus',
+      type: 'DeviceOnboardingStatus',
       message: {
         page_index: 2,
         page_count: 5,
@@ -713,11 +1101,45 @@ describe('Protocol V2 onboarding status method', () => {
       page_count: 5,
       page_name: 'backup',
     });
-    expect(typedCall).toHaveBeenCalledWith('DevGetOnboardingStatus', 'DevOnboardingStatus', {});
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceGetOnboardingStatus',
+      'DeviceOnboardingStatus',
+      {}
+    );
   });
 });
 
 describe('Protocol V2 file write method', () => {
+  test('rejects invalid write parameters before transport call', () => {
+    expect(() => {
+      const method = new FileWrite({
+        id: 1,
+        payload: {
+          method: 'fileWrite',
+          path: 'vol1:test.bin',
+          offset: -1,
+          data: new Uint8Array([1]),
+        },
+      });
+      method.init();
+    }).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.CallMethodInvalidParameter })
+    );
+
+    expect(() => {
+      const method = new FileWrite({
+        id: 1,
+        payload: {
+          method: 'fileWrite',
+          path: 'vol1:test.bin',
+        } as any,
+      });
+      method.init();
+    }).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.CallMethodInvalidParameter })
+    );
+  });
+
   test('uses demo-aligned overwrite and append defaults', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: { processed_byte: 1 } });
     const method = new FileWrite({
@@ -860,6 +1282,50 @@ describe('Protocol V2 file write method', () => {
 });
 
 describe('Protocol V2 file read method', () => {
+  test('rejects invalid read and directory parameters before transport call', () => {
+    expect(() => {
+      const method = new FileRead({
+        id: 1,
+        payload: {
+          method: 'fileRead',
+          path: '',
+          offset: 0,
+        },
+      });
+      method.init();
+    }).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.CallMethodInvalidParameter })
+    );
+
+    expect(() => {
+      const method = new FileRead({
+        id: 1,
+        payload: {
+          method: 'fileRead',
+          path: 'vol1:test.bin',
+          totalSize: -1,
+        },
+      });
+      method.init();
+    }).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.CallMethodInvalidParameter })
+    );
+
+    expect(() => {
+      const method = new DirList({
+        id: 1,
+        payload: {
+          method: 'dirList',
+          path: 'vol1:',
+          depth: -1,
+        },
+      });
+      method.init();
+    }).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.CallMethodInvalidParameter })
+    );
+  });
+
   test('reads full file in chunks when read length is 0', async () => {
     const firstChunk = new Uint8Array(64).fill(1);
     const typedCall = jest