@onekeyfe/hd-core 1.2.0-alpha.134 → 1.2.0-alpha.135

package/__tests__/DeviceCommands.test.ts

@@ -485,7 +485,7 @@ describe('DeviceCommands failure mapping', () => {
     });
   });
 
-  it.each(['Cancelled on device', 'Confirm dismissed'])(
+  it.each(['Cancelled on device', 'Confirm dismissed', 'Update cancelled'])(
     'maps legacy Protocol V2 cancellation message "%s" without a subcode',
     async message => {
       const commands = createCommands();
@@ -800,7 +800,13 @@ describe('DeviceCommands cancellation', () => {
     try {
       const commands = createCommands();
       commands.disposed = false;
+      commands.mainId = 'main-id';
       commands.callPromise = new Promise(() => {});
+      const disconnect = jest.fn().mockResolvedValue(undefined);
+      commands.transport = {
+        name: 'ReactNativeBleTransport',
+        disconnect,
+      } as any;
       const dispose = jest.fn().mockResolvedValue(undefined);
       commands.dispose = dispose;
 
@@ -810,6 +816,7 @@ describe('DeviceCommands cancellation', () => {
 
       await expect(cancellation).resolves.toBeUndefined();
       expect(dispose).toHaveBeenCalledWith(true);
+      expect(disconnect).toHaveBeenCalledWith('main-id');
       expect(commands.callPromise).toBeUndefined();
     } finally {
       jest.useRealTimers();

package/__tests__/device-lifecycle-events.test.ts

@@ -1,7 +1,7 @@
-import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 import { DeviceType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 
-import { initConnector, initCore } from '../src/core';
+import { initConnector, initCore, isMissingDetectedProtocolV2Error } from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
 import { Device } from '../src/device/Device';
@@ -82,6 +82,23 @@ describe('public device lifecycle events', () => {
     expect(DevicePool.emitter.listenerCount(DEVICE.DISCONNECT)).toBe(1);
   });
 
+  test('isolates pending cancellation cleanup by connect id', () => {
+    core = initCore();
+    const context = (core as any).getCoreContext();
+    const firstCleanup = createDeferred<void>();
+    const replacementCleanup = createDeferred<void>();
+
+    context.setPrePendingCallPromise('device-a', firstCleanup.promise);
+
+    expect(context.getPrePendingCallPromise('device-a')).toBe(firstCleanup.promise);
+    expect(context.getPrePendingCallPromise('device-b')).toBeUndefined();
+
+    context.setPrePendingCallPromise('device-a', replacementCleanup.promise);
+    context.removePrePendingCallPromise('device-a', firstCleanup.promise);
+
+    expect(context.getPrePendingCallPromise('device-a')).toBe(replacementCleanup.promise);
+  });
+
   test('keeps shared device lifecycle listeners across a device cache reset', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -234,6 +251,22 @@ describe('public device lifecycle events', () => {
     expect(device.getProtocol()).toBe('V2');
   });
 
+  test.each([
+    ['V2', true],
+    ['V1', false],
+  ] as const)(
+    'retries a missing detected protocol only for an explicit Protocol %s connection',
+    (connectProtocol, expected) => {
+      const method = { payload: { connectProtocol } } as never;
+      const error = {
+        errorCode: HardwareErrorCode.RuntimeError,
+        message: 'Device protocol has not been detected for ble-id',
+      };
+
+      expect(isMissingDetectedProtocolV2Error(method, error)).toBe(expected);
+    }
+  );
+
   test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();
@@ -310,6 +343,66 @@ describe('public device lifecycle events', () => {
     }
   );
 
+  test.each(['react-native', 'webusb', 'desktop-webusb'] as const)(
+    'sends a fallback Cancel for an acquired Protocol V2 %s call without a prompt callback',
+    async env => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      const device = createInitializedDevice('V2');
+      const post = jest.fn().mockResolvedValue(undefined);
+      const cancelDevice = jest.fn(() => cancelDeviceInPrompt(device, false));
+      const cancel = jest.fn().mockResolvedValue(undefined);
+      device.originalDescriptor.session = device.mainId;
+      (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+      device.commands = {
+        transport: { post },
+        cancelDevice,
+        cancel,
+      } as never;
+
+      await device.interruptionFromUser();
+
+      expect(cancelDevice).toHaveBeenCalledTimes(1);
+      expect(post).toHaveBeenCalledWith(device.mainId, 'Cancel', {});
+      expect(cancel).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  test('waits for the canceled run to finish releasing before cancellation completes', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = createInitializedDevice('V2');
+    const operation = createDeferred<void>();
+    const releaseGate = createDeferred<void>();
+    const cancelError = ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+    const release = jest.spyOn(device, 'release').mockImplementation(() => releaseGate.promise);
+    device.commands = {
+      disposed: false,
+      cancel: jest.fn(() => {
+        operation.reject(cancelError);
+        return Promise.resolve();
+      }),
+    } as never;
+    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+
+    const runResult = device.run(() => operation.promise).catch(error => error);
+    const cancellation = device.interruptionFromUser();
+    let cancellationCompleted = false;
+    cancellation.then(() => {
+      cancellationCompleted = true;
+    });
+
+    await new Promise(resolve => {
+      setImmediate(resolve);
+    });
+    expect(release).toHaveBeenCalledTimes(1);
+    expect(cancellationCompleted).toBe(false);
+
+    releaseGate.resolve();
+    await cancellation;
+    await expect(runResult).resolves.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInterruptedFromUser,
+    });
+  });
+
   test.each([
     [EDeviceType.Pro2, 'webusb', false, DeviceType.PRO2],
     [EDeviceType.Neo, 'webusb', false, DeviceType.NEO],

package/__tests__/device-settings.test.ts

@@ -2,6 +2,9 @@ import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import DeviceSettings from '../src/api/device/DeviceSettings';
+import { Device } from '../src/device/Device';
+import { DEVICE } from '../src/events';
+import { PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE } from '../src/protocols/protocol-v2';
 import { DEVICE_SETTINGS_NEVER_TIMEOUT_MS } from '../src/utils/deviceSettings';
 
 import type { Features } from '../src/types';
@@ -21,6 +24,9 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
   const typedCall = jest.fn().mockResolvedValue({ message: { message: 'Success' } });
   const updateState = jest.fn();
   const getDeviceState = jest.fn();
+  const refreshProtocolV2SettingsAfterMutation = jest.fn(() =>
+    getDeviceState({ refreshSections: ['status', 'settings'] })
+  );
   return {
     device: {
       features,
@@ -29,6 +35,7 @@ function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
       commands: { typedCall },
       updateState,
       getDeviceState,
+      refreshProtocolV2SettingsAfterMutation,
     },
     typedCall,
     updateState,
@@ -181,7 +188,98 @@ describe('DeviceSettings protocol routing', () => {
     expect(updateState).not.toHaveBeenCalled();
   });
 
-  it('uses the Pro2 passphrase page as a device-side toggle and verifies the target state', async () => {
+  it('reconciles stale passphrase and label after an unrelated Protocol V2 setting change', async () => {
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceSettingsSet') {
+        return { message: { message: 'Success' } };
+      }
+      if (requestType === 'DeviceStatusGet') {
+        return {
+          message: {
+            init_states: true,
+            unlocked: false,
+            passphrase_enabled: false,
+          },
+        };
+      }
+      if (requestType === 'DeviceSettingsGet') {
+        return {
+          message: {
+            label: 'Current Label',
+            brightness: 80,
+            passphrase_enable: false,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const device = Device.fromDescriptor({
+      id: 'pro2',
+      path: 'pro2',
+      protocolType: 'V2',
+    } as never);
+    (device as any).commands = { typedCall };
+    device.updateState(
+      {
+        protocol: 'V2',
+        identity: {
+          deviceType: EDeviceType.Pro2,
+          label: 'Stale Label',
+        },
+        status: {
+          mode: 'normal',
+          unlocked: false,
+          passphraseProtection: true,
+        },
+        settings: { brightness: 20 },
+        raw: {
+          protocolV2ProtocolInfo: {
+            version: 1,
+            build_fingerprint: 'application__5.0.0__abcdef0__PROD__RELEASE',
+            supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
+          },
+        },
+      },
+      'initialize'
+    );
+    const onState = jest.fn();
+    device.on(DEVICE.STATE, onState);
+    const method = new DeviceSettings({
+      id: 3,
+      payload: {
+        method: 'deviceSettings',
+        brightness: 80,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceSettingsSet',
+      'DeviceStatusGet',
+      'DeviceSettingsGet',
+    ]);
+    expect(device.state).toMatchObject({
+      identity: { label: 'Current Label' },
+      status: { passphraseProtection: false },
+      settings: { brightness: 80 },
+    });
+    expect(onState).toHaveBeenLastCalledWith(
+      device,
+      expect.objectContaining({
+        source: 'settings-read',
+        state: expect.objectContaining({
+          identity: expect.objectContaining({ label: 'Current Label' }),
+          status: expect.objectContaining({ passphraseProtection: false }),
+          settings: expect.objectContaining({ brightness: 80 }),
+        }),
+      })
+    );
+  });
+
+  it('uses the Pro2 passphrase page and refreshes device state after the toggle', async () => {
     const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
     getDeviceState
       .mockResolvedValueOnce({
@@ -263,8 +361,8 @@ describe('DeviceSettings protocol routing', () => {
     expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['settings'] });
   });
 
-  it('rejects a successful Pro2 page response when the hardware did not reach the target', async () => {
-    const { device, getDeviceState } = createDevice({ protocol: 'V2' });
+  it('does not overwrite Pro2 passphrase state when refreshed state does not match', async () => {
+    const { device, getDeviceState, updateState } = createDevice({ protocol: 'V2' });
     getDeviceState.mockResolvedValue({
       status: { passphraseProtection: false },
     });
@@ -278,14 +376,12 @@ describe('DeviceSettings protocol routing', () => {
     method.init();
     (method as any).device = device;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.RuntimeError,
-      message: 'Protocol V2 passphrase setting did not reach the requested value.',
-    });
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(updateState).not.toHaveBeenCalled();
   });
 
-  it('accepts a locked Pro2 as confirmation after disabling passphrase', async () => {
-    const { device, getDeviceState } = createDevice({ protocol: 'V2' });
+  it('keeps the previous Pro2 passphrase state when refreshed state is unavailable after locking', async () => {
+    const { device, getDeviceState, updateState } = createDevice({ protocol: 'V2' });
     getDeviceState
       .mockResolvedValueOnce({
         status: { unlocked: true, passphraseProtection: true },
@@ -304,6 +400,68 @@ describe('DeviceSettings protocol routing', () => {
     (method as any).device = device;
 
     await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(updateState).not.toHaveBeenCalled();
+  });
+
+  it('preserves confirmed Pro2 passphrase state when the post-toggle status is locked', async () => {
+    let statusReadCount = 0;
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceStatusGet') {
+        statusReadCount += 1;
+        return {
+          message:
+            statusReadCount === 1
+              ? { init_states: true, unlocked: true, passphrase_enabled: true }
+              : { init_states: true, unlocked: false, passphrase_enabled: false },
+        };
+      }
+      if (requestType === 'DeviceSettingsPageShow') {
+        return { message: { message: 'Success' } };
+      }
+      if (requestType === 'DeviceSettingsGet') {
+        return { message: { label: 'Pro 2' } };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const device = Device.fromDescriptor({
+      id: 'pro2-passphrase',
+      path: 'pro2-passphrase',
+      protocolType: 'V2',
+    } as never);
+    (device as any).commands = { typedCall };
+    device.updateState(
+      {
+        protocol: 'V2',
+        identity: { deviceType: EDeviceType.Pro2 },
+        status: {
+          mode: 'normal',
+          unlocked: true,
+          passphraseProtection: true,
+        },
+        raw: {
+          protocolV2ProtocolInfo: {
+            version: 1,
+            supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
+          },
+        },
+      },
+      'initialize'
+    );
+    const method = new DeviceSettings({
+      id: 6,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: false,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(device.state?.status).toMatchObject({
+      unlocked: false,
+      passphraseProtection: true,
+    });
   });
 
   it('keeps Protocol V1 passphrase settings on ApplySettings', async () => {

package/__tests__/device-wallet-session-store.test.ts

@@ -352,7 +352,7 @@ describe('Protocol V1 wallet identity initialization', () => {
     jest.restoreAllMocks();
   });
 
-  test('purges cached sessions and rejects when the live device identity changes', async () => {
+  test('verifies the live device id without resetting the cached wallet session', async () => {
     const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
     device.features = {
       protocol: 'V1',
@@ -363,7 +363,7 @@ describe('Protocol V1 wallet identity initialization', () => {
     deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
     const typedCall = jest.fn().mockResolvedValue({
       type: 'Features',
-      message: { device_id: 'live-device-b', session_id: 'wrong-device-session' },
+      message: { device_id: 'live-device-b' },
     });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
@@ -371,76 +371,11 @@ describe('Protocol V1 wallet identity initialization', () => {
     await expect(
       device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
-    // Identity is validated from the single Initialize round trip; no separate
-    // GetFeatures preflight.
     expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith(
-      'Initialize',
-      'Features',
-      expect.objectContaining({ passphrase_state: 'hidden-a' }),
-      expect.any(Object)
-    );
-    // Identity change purges the previous device's cached sessions (pre-existing
-    // reconcileDeviceIdentity behavior — never carry sessions across devices)…
-    expect(deviceWalletSessionStore.get('cached-device-a', 'hidden-a')).toBeUndefined();
-    // …and the session the mismatched Initialize cached under the wrong
-    // device's identity is dropped as well.
-    expect(deviceWalletSessionStore.get('live-device-b', 'hidden-a')).toBeUndefined();
+    expect(typedCall).toHaveBeenCalledWith('GetFeatures', 'Features', {});
   });
 
-  test('drops the wrong-device session even when reconfigure fails after Initialize', async () => {
-    const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
-    device.features = {
-      protocol: 'V1',
-      deviceId: 'cached-device-a',
-      unlocked: true,
-      passphraseProtection: true,
-    } as never;
-    deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'Features',
-      message: { device_id: 'live-device-b', session_id: 'wrong-device-session' },
-    });
-    device.commands = { typedCall } as never;
-    // Pre-encode resync succeeds; the post-response reconfigure inside
-    // callInitialize rejects — the session write has already happened by then.
-    jest
-      .spyOn(TransportManager, 'reconfigure')
-      .mockResolvedValueOnce(undefined)
-      .mockRejectedValueOnce(new Error('configure failed'));
-
-    await expect(
-      device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
-    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
-    // The wrong-device session must not survive the error path either.
-    expect(deviceWalletSessionStore.get('live-device-b', 'hidden-a')).toBeUndefined();
-  });
-
-  test('re-syncs the V1 message schema for this device before encoding Initialize', async () => {
-    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
-    device.features = {
-      protocol: 'V1',
-      deviceId: 'device-a',
-      unlocked: true,
-      passphraseProtection: true,
-    } as never;
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'Features',
-      message: { device_id: 'device-a' },
-    });
-    device.commands = { typedCall } as never;
-    const reconfigure = jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
-
-    await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
-
-    // A stale process-global schema (from another device) would silently strip
-    // passphrase_state from the wire message, so the resync must come first.
-    expect(reconfigure.mock.invocationCallOrder[0]).toBeLessThan(
-      typedCall.mock.invocationCallOrder[0]
-    );
-  });
-
-  test('resumes a cached V1 wallet with a single identity-validated Initialize', async () => {
+  test('resumes a cached V1 wallet after a non-destructive live identity read', async () => {
     const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
     device.features = {
       protocol: 'V1',
@@ -449,17 +384,22 @@ describe('Protocol V1 wallet identity initialization', () => {
       passphraseProtection: true,
     } as never;
     deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
-    const typedCall = jest.fn().mockResolvedValueOnce({
-      type: 'Features',
-      message: { device_id: 'device-a', session_id: 'session-a' },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
+      .mockResolvedValueOnce({
+        type: 'Features',
+        message: { device_id: 'device-a', session_id: 'session-a' },
+      });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
 
     await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
 
-    expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith(
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
       'Initialize',
       'Features',
       expect.objectContaining({
@@ -468,10 +408,9 @@ describe('Protocol V1 wallet identity initialization', () => {
       }),
       expect.any(Object)
     );
-    expect(deviceWalletSessionStore.get('device-a', 'hidden-a')).toBe('session-a');
   });
 
-  test('selects the standard V1 wallet with a single identity-validated Initialize', async () => {
+  test('selects the standard V1 wallet after a non-destructive live identity read', async () => {
     const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
     device.features = {
       protocol: 'V1',
@@ -481,14 +420,17 @@ describe('Protocol V1 wallet identity initialization', () => {
     } as never;
     const typedCall = jest
       .fn()
+      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
       .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
 
     await device.initialize({ deviceId: 'device-a' });
 
-    expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith(
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
       'Initialize',
       'Features',
       {

package/__tests__/firmware-update/firmware-update-v4-install-poll.test.ts

@@ -1,4 +1,4 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import FirmwareUpdateV4 from '../../src/api/FirmwareUpdateV4';
 
@@ -127,4 +127,40 @@ describe('FirmwareUpdateV4 install polling', () => {
       errorCode: HardwareErrorCode.CallQueueActionCancelled,
     });
   });
+
+  test('stops polling when the device cancels firmware installation', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        connectId: 'pro2-ble',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValue(ERRORS.TypedError(HardwareErrorCode.ActionCancelled));
+    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+
+    method.device = {
+      getCommands: () => ({ typedCall }),
+    } as unknown as Device;
+    const firmwareUpdate = method as unknown as {
+      waitForProtocolV2FirmwareUpdateComplete: (
+        targets: Array<{ target_id: number; path: string }>
+      ) => Promise<void>;
+      reconnectProtocolV2Device: () => Promise<void>;
+    };
+    firmwareUpdate.reconnectProtocolV2Device = reconnectProtocolV2Device;
+
+    await expect(
+      firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete([
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+      ])
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.ActionCancelled,
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(reconnectProtocolV2Device).not.toHaveBeenCalled();
+  });
 });

package/__tests__/protocol-v2-unlock-policy.test.ts

@@ -1,8 +1,12 @@
 import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import ConfluxSignMessageCIP23 from '../src/api/conflux/ConfluxSignMessageCIP23';
+import DeviceChangePin from '../src/api/device/DeviceChangePin';
 import DeviceLock from '../src/api/device/DeviceLock';
 import DeviceSettings from '../src/api/device/DeviceSettings';
+import DeviceVerify from '../src/api/device/DeviceVerify';
+import DeviceWipe from '../src/api/device/DeviceWipe';
+import FirmwareUpdateV4 from '../src/api/FirmwareUpdateV4';
 import OpenWalletSession from '../src/api/OpenWalletSession';
 import { runMethodWithUnlockPolicy } from '../src/protocols/protocol-v2/unlockPolicyRunner';
 
@@ -191,6 +195,61 @@ describe('Protocol V2 unlock semantics', () => {
     expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Any, expect.any(Object));
   });
 
+  test.each([
+    [
+      'PIN changes',
+      () =>
+        new DeviceChangePin({
+          id: 1,
+          payload: { method: 'deviceChangePin', remove: false },
+        }),
+    ],
+    ['device wipe', () => new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } })],
+    [
+      'firmware updates',
+      () =>
+        new FirmwareUpdateV4({
+          id: 1,
+          payload: { method: 'firmwareUpdateV4', platform: 'desktop' } as any,
+        }),
+    ],
+    [
+      'genuine-device verification',
+      () =>
+        new DeviceVerify({
+          id: 1,
+          payload: { method: 'deviceVerify', dataHex: '00' },
+        }),
+    ],
+  ])('allows either PIN type when pre-unlocking %s', async (_name, createMethod) => {
+    const method = createMethod();
+    method.init();
+    const features = { unlocked: false };
+    const device = {
+      features,
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: false } }),
+      },
+      isProtocolV2: () => true,
+      isBootloader: () => false,
+      isRomloader: () => false,
+      updateProtocolV2Status: jest.fn(() => features),
+      unlockDevice: jest.fn().mockImplementation(() => {
+        features.unlocked = true;
+        return Promise.resolve(features);
+      }),
+    };
+    method.run = jest.fn().mockResolvedValue({ message: 'ok' });
+
+    await expect(runMethodWithUnlockPolicy(method, device as any)).resolves.toEqual({
+      message: 'ok',
+    });
+
+    expect(method.unlockPolicy).toBe('unlock-before-run');
+    expect(method.getSupportedProtocols()).toContain('V2');
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Any, expect.any(Object));
+  });
+
   test('pre-unlocks a locked standard wallet before wallet-session preparation', async () => {
     const calls: string[] = [];
     const features = {