@onekeyfe/hd-core 1.2.0-alpha.98 → 1.2.0

package/__tests__/check-firmware-release-protocol-v2.test.ts

@@ -16,8 +16,6 @@ jest.mock('../src/data/config', () => ({
 const release: IFirmwareReleaseInfo = {
   required: false,
   version: [2, 0, 0],
-  url: 'https://example.com/application-p1.okpkg',
-  fingerprint: 'release-fingerprint',
   changelog: {
     'zh-CN': '更新',
     'en-US': 'Update',
@@ -68,6 +66,37 @@ const createDevice = (deviceType: 'pro2' | 'neo') => ({
   }),
 });
 
+const createFeaturelessDevice = (protocolV2: boolean) => {
+  const device = {
+    isProtocolV2: jest.fn(() => protocolV2),
+    features: undefined,
+    getDeviceState: jest.fn(),
+  };
+  device.getDeviceState.mockImplementation(() => {
+    Object.assign(device, {
+      features: {
+        deviceType: 'pro2',
+        firmwareVersion: '1.0.0',
+      },
+    });
+    return Promise.resolve({
+      identity: {
+        deviceType: 'pro2',
+        firmwareType: EFirmwareType.Universal,
+      },
+      status: { mode: 'bootloader' },
+      versions: {
+        firmware: '1.0.0',
+        applicationP1: '1.0.0',
+        bootloader: '1.0.0',
+        board: '1.0.0',
+        ble: '1.0.0',
+      },
+    });
+  });
+  return device;
+};
+
 describe.each(['pro2', 'neo'] as const)('Protocol V2 release checks for %s', deviceType => {
   afterEach(() => {
     jest.restoreAllMocks();
@@ -147,7 +176,7 @@ describe.each(['pro2', 'neo'] as const)('Protocol V2 release checks for %s', dev
       deviceType,
       status: 'outdated',
       hasUpgrade: true,
-      targetsToUpdate: ['boot', 'app_v1', 'coprocessor'],
+      targetsToUpdate: ['boot', 'app_v1', 'coprocessor', 'resource'],
       firmware: { status: 'outdated', shouldUpdate: true },
       ble: {
         status: 'outdated',
@@ -168,12 +197,50 @@ describe.each(['pro2', 'neo'] as const)('Protocol V2 release checks for %s', dev
   });
 });
 
-test('returns null from optional release probes when device features are unavailable', async () => {
-  const deviceWithoutFeatures = {
-    isProtocolV2: jest.fn(() => true),
-    features: undefined,
-    getDeviceState: jest.fn(),
-  };
+test('probes Protocol V2 loader state before requiring initialized features', async () => {
+  jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
+  const firmwareDevice = createFeaturelessDevice(true);
+  const bleDevice = createFeaturelessDevice(true);
+  const bootloaderDevice = createFeaturelessDevice(true);
+  const firmwareMethod = new CheckFirmwareRelease({
+    id: 1,
+    payload: { method: 'checkFirmwareRelease' },
+  });
+  const bleMethod = new CheckBLEFirmwareRelease({
+    id: 2,
+    payload: { method: 'checkBLEFirmwareRelease' },
+  });
+  const bootloaderMethod = new CheckBootloaderRelease({
+    id: 3,
+    payload: { method: 'checkBootloaderRelease' },
+  });
+
+  firmwareMethod.device = firmwareDevice as unknown as CheckFirmwareRelease['device'];
+  bleMethod.device = bleDevice as unknown as CheckBLEFirmwareRelease['device'];
+  bootloaderMethod.device = bootloaderDevice as unknown as CheckBootloaderRelease['device'];
+
+  await expect(firmwareMethod.run()).resolves.toMatchObject({
+    status: 'outdated',
+    shouldUpdate: true,
+  });
+  await expect(bleMethod.run()).resolves.toMatchObject({
+    status: 'outdated',
+    shouldUpdate: true,
+  });
+  await expect(bootloaderMethod.run()).resolves.toMatchObject({
+    status: 'outdated',
+    shouldUpdate: true,
+  });
+  for (const device of [firmwareDevice, bleDevice, bootloaderDevice]) {
+    expect(device.isProtocolV2).toHaveBeenCalled();
+    expect(device.getDeviceState).toHaveBeenCalledTimes(1);
+  }
+});
+
+test('keeps featureless Protocol V1 release probes optional', async () => {
+  const firmwareDevice = createFeaturelessDevice(false);
+  const bleDevice = createFeaturelessDevice(false);
+  const bootloaderDevice = createFeaturelessDevice(false);
   const firmwareMethod = new CheckFirmwareRelease({
     id: 1,
     payload: { method: 'checkFirmwareRelease' },
@@ -187,13 +254,15 @@ test('returns null from optional release probes when device features are unavail
     payload: { method: 'checkBootloaderRelease' },
   });
 
-  firmwareMethod.device = deviceWithoutFeatures as unknown as CheckFirmwareRelease['device'];
-  bleMethod.device = deviceWithoutFeatures as unknown as CheckBLEFirmwareRelease['device'];
-  bootloaderMethod.device = deviceWithoutFeatures as unknown as CheckBootloaderRelease['device'];
+  firmwareMethod.device = firmwareDevice as unknown as CheckFirmwareRelease['device'];
+  bleMethod.device = bleDevice as unknown as CheckBLEFirmwareRelease['device'];
+  bootloaderMethod.device = bootloaderDevice as unknown as CheckBootloaderRelease['device'];
 
   await expect(firmwareMethod.run()).resolves.toBeNull();
   await expect(bleMethod.run()).resolves.toBeNull();
   await expect(bootloaderMethod.run()).resolves.toBeNull();
-  expect(deviceWithoutFeatures.isProtocolV2).not.toHaveBeenCalled();
-  expect(deviceWithoutFeatures.getDeviceState).not.toHaveBeenCalled();
+  for (const device of [firmwareDevice, bleDevice, bootloaderDevice]) {
+    expect(device.isProtocolV2).toHaveBeenCalled();
+    expect(device.getDeviceState).not.toHaveBeenCalled();
+  }
 });

package/__tests__/device-connector-protocol.test.ts

@@ -1,4 +1,5 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { createProtocolV2LinkDisabledError } from '@onekeyfe/hd-transport';
 
 import DeviceConnector from '../src/device/DeviceConnector';
 
@@ -78,4 +79,24 @@ describe('DeviceConnector protocol validation', () => {
       'Device protocol mismatch: expected V2, detected V1'
     );
   });
+
+  it('preserves the Protocol V2 USB-priority failure as public BLE error 723', async () => {
+    transportManagerMock.default.getTransport.mockReturnValue({
+      acquire: jest
+        .fn()
+        .mockRejectedValue(
+          createProtocolV2LinkDisabledError('Failure_ProcessError', 'link disabled')
+        ),
+      getProtocolType: jest.fn(() => undefined),
+    });
+    const connector = new DeviceConnector();
+
+    await expect(connector.acquire('pro2-id', undefined, undefined, 'V2')).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleUnavailableWhileUsbConnected,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        firmwareMessage: 'link disabled',
+      },
+    });
+  });
 });

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

@@ -1,12 +1,21 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
-
-import { initConnector, initCore } from '../src/core';
+import { EDeviceType, ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
+import { DeviceType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+
+import {
+  initConnector,
+  initCore,
+  isMissingDetectedProtocolV2Error,
+  isProtocolV2PeerRemovedPairingError,
+  isRetryableBleConnectionError,
+  isRetryableBleProtocolV2ProbeError,
+} from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
 import { Device } from '../src/device/Device';
+import { cancelDeviceInPrompt, cancelDeviceWithInitialize } from '../src/device/DeviceCommands';
 import { DevicePool } from '../src/device/DevicePool';
 import { CORE_EVENT, DEVICE, IFRAME } from '../src/events';
+import { PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE } from '../src/protocols/protocol-v2';
 
 import type Core from '../src/core';
 import type { CoreMessage } from '../src/events';
@@ -80,6 +89,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();
@@ -109,7 +135,7 @@ describe('public device lifecycle events', () => {
 
     await device.acquire();
 
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V1', undefined);
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V1', undefined, undefined);
     expect(device.getProtocol()).toBe('V1');
     expect(device.originalDescriptor.protocolType).toBe('V1');
   });
@@ -127,7 +153,9 @@ describe('public device lifecycle events', () => {
 
     await device.acquire(undefined, { forceProtocolDetection: true });
 
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, undefined);
+    // Explicit active detection forwards forceProtocolDetection so the
+    // transport bypasses its protocol cache.
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, undefined, true);
     expect(device.getProtocol()).toBe('V2');
     expect(device.originalDescriptor.protocolType).toBe('V2');
   });
@@ -228,10 +256,76 @@ describe('public device lifecycle events', () => {
 
     await device.acquire('V2');
 
-    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V2', undefined);
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V2', undefined, undefined);
     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.each([
+    [HardwareErrorCode.RuntimeError, true],
+    [HardwareErrorCode.BleDeviceBondError, false],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, false],
+  ] as const)(
+    'retries a Protocol V2 probe mismatch with error code %s: %s',
+    (errorCode, expected) => {
+      const method = { payload: { connectProtocol: 'V2' } } as never;
+      const error = {
+        errorCode,
+        message:
+          'Device protocol mismatch: expected V2, but device did not respond to expected protocol',
+      };
+
+      expect(isRetryableBleProtocolV2ProbeError(method, error)).toBe(expected);
+    }
+  );
+
+  test.each([
+    [HardwareErrorCode.BleConnectedError, true],
+    [HardwareErrorCode.BleTimeoutError, true],
+    [HardwareErrorCode.PollingTimeout, false],
+    [HardwareErrorCode.BleDeviceBondError, false],
+    [HardwareErrorCode.BlePeerRemovedPairingInformation, false],
+  ] as const)('retries a BLE connection error with error code %s: %s', (errorCode, expected) => {
+    const method = { payload: { connectProtocol: 'V2' } } as never;
+    const error = {
+      errorCode,
+      message: 'BLE setup wedged repeatedly',
+    };
+
+    expect(isRetryableBleConnectionError(method, error)).toBe(expected);
+  });
+
+  test.each([
+    ['V2', true],
+    ['V1', false],
+    [undefined, false],
+  ] as const)(
+    'treats peer-removed pairing as terminal only for Protocol %s: %s',
+    (connectProtocol, expected) => {
+      const method = { payload: { connectProtocol } } as never;
+      const error = {
+        errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
+      };
+
+      expect(isProtocolV2PeerRemovedPairingError(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();
@@ -271,6 +365,332 @@ describe('public device lifecycle events', () => {
     expect(device.isUsedHere()).toBe(false);
   });
 
+  test.each([
+    ['V2', 'Cancel', 'webusb'],
+    ['V2', 'Cancel', 'desktop-web-ble'],
+    ['V2', 'Cancel', 'react-native'],
+    ['V1', 'Initialize', 'webusb'],
+    ['V1', 'Cancel', 'desktop-web-ble'],
+  ] as const)(
+    'sends Protocol %s %s without treating the acquired %s session as disconnected',
+    async (protocol, messageType, env) => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      const device = createInitializedDevice(protocol);
+      const post = jest.fn().mockResolvedValue(undefined);
+      const call = jest.fn().mockResolvedValue(undefined);
+      const cancel = jest.fn().mockResolvedValue(undefined);
+      device.originalDescriptor.session = device.mainId;
+      (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+      (device as any).commands = { transport: { post, call }, cancel };
+      device.setCancelableAction(() =>
+        messageType === 'Cancel'
+          ? cancelDeviceInPrompt(device, false)
+          : cancelDeviceWithInitialize(device)
+      );
+
+      await device.interruptionFromUser();
+
+      if (messageType === 'Cancel') {
+        expect(post).toHaveBeenCalledWith(device.mainId, 'Cancel', {});
+        expect(call).not.toHaveBeenCalled();
+      } else {
+        expect(call).toHaveBeenCalledWith(device.mainId, 'Initialize', {});
+        expect(post).not.toHaveBeenCalled();
+      }
+      expect(cancel).toHaveBeenCalledTimes(1);
+      expect(device.hasDeviceAcquire()).toBe(true);
+    }
+  );
+
+  test.each(['react-native', 'webusb', 'desktop-webusb'] as const)(
+    'sends a fallback Cancel for an acquired Protocol V2 %s call with an open UI',
+    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;
+      device.createProtocolV2UiPhaseMetadata('button', 'start');
+
+      await device.interruptionFromUser();
+
+      expect(cancelDevice).toHaveBeenCalledTimes(1);
+      expect(post).toHaveBeenCalledWith(device.mainId, 'Cancel', {});
+      expect(cancel).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  test.each(['react-native', 'webusb', 'desktop-webusb'] as const)(
+    'does not send Cancel for an acquired Protocol V2 %s connect without an open UI',
+    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);
+      const disconnect = jest.fn().mockResolvedValue(undefined);
+      device.originalDescriptor.session = device.mainId;
+      (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+      device.deviceConnector = { disconnect } as never;
+      device.commands = {
+        transport: { post },
+        cancelDevice,
+        cancel,
+      } as never;
+
+      await device.interruptionFromUser();
+
+      expect(cancelDevice).not.toHaveBeenCalled();
+      expect(post).not.toHaveBeenCalled();
+      expect(disconnect).not.toHaveBeenCalled();
+      expect(cancel).toHaveBeenCalledTimes(1);
+    }
+  );
+
+  test('disconnects a BLE link without sending Cancel when the session is not acquired', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' 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);
+    const disconnect = jest.fn().mockResolvedValue(undefined);
+    device.deviceConnector = { disconnect } as never;
+    device.commands = {
+      transport: { post },
+      cancelDevice,
+      cancel,
+    } as never;
+
+    await device.interruptionFromUser();
+
+    expect(cancelDevice).not.toHaveBeenCalled();
+    expect(post).not.toHaveBeenCalled();
+    expect(disconnect).toHaveBeenCalledWith(device.mainId);
+    expect(device.hasDeviceAcquire()).toBe(false);
+    expect(device.wasInterruptedByUser()).toBe(true);
+    expect(cancel).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not finish acquire after the user already cancelled', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = createInitializedDevice('V2');
+    const disconnect = jest.fn().mockResolvedValue(undefined);
+    let resolveAcquire: ((value: { uuid: string; protocolType: 'V2' }) => void) | undefined;
+    const acquire = jest.fn(
+      () =>
+        new Promise<{ uuid: string; protocolType: 'V2' }>(resolve => {
+          resolveAcquire = resolve;
+        })
+    );
+    device.deviceConnector = { acquire, disconnect } as never;
+
+    const acquirePromise = device.acquire('V2');
+    await device.interruptionFromUser();
+    resolveAcquire?.({ uuid: 'late-session', protocolType: 'V2' });
+
+    await expect(acquirePromise).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInterruptedFromUser,
+    });
+    expect(disconnect).toHaveBeenCalledWith('late-session');
+    expect(device.hasDeviceAcquire()).toBe(false);
+  });
+
+  test('does not retry a BLE connection error after the user cancelled', () => {
+    const device = createInitializedDevice('V2');
+    device.beginConnectionAttempt();
+    (device as unknown as { interruptedAttempt: number }).interruptedAttempt = (
+      device as unknown as { connectionAttempt: number }
+    ).connectionAttempt;
+    const method = { payload: { connectProtocol: 'V2' }, device } as never;
+    const error = {
+      errorCode: HardwareErrorCode.BleConnectedError,
+      message: 'BLE setup wedged repeatedly',
+    };
+
+    expect(isRetryableBleConnectionError(method, error)).toBe(false);
+  });
+
+  test('keeps a user cancel across a later BLE poll iteration', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = createInitializedDevice('V2');
+    const disconnect = jest.fn().mockResolvedValue(undefined);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'poll-session', protocolType: 'V2' });
+    device.deviceConnector = { acquire, disconnect } as never;
+
+    // First ensureConnected poll iteration.
+    device.beginConnectionAttempt();
+    await device.interruptionFromUser();
+    expect(device.wasInterruptedByUser()).toBe(true);
+
+    // A later poll must not call beginConnectionAttempt() again.
+    await expect(device.acquire('V2')).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInterruptedFromUser,
+    });
+    expect(device.wasInterruptedByUser()).toBe(true);
+    expect(acquire).not.toHaveBeenCalled();
+  });
+
+  test('allows a new BLE connect after the previous attempt was cancelled', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = createInitializedDevice('V2');
+    const disconnect = jest.fn().mockResolvedValue(undefined);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'next-session', protocolType: 'V2' });
+    device.deviceConnector = { acquire, disconnect } as never;
+
+    device.beginConnectionAttempt();
+    await device.interruptionFromUser();
+    expect(device.wasInterruptedByUser()).toBe(true);
+
+    device.beginConnectionAttempt();
+    await expect(device.acquire('V2')).resolves.toBeUndefined();
+
+    expect(device.wasInterruptedByUser()).toBe(false);
+    expect(device.hasDeviceAcquire()).toBe(true);
+    expect(acquire).toHaveBeenCalledTimes(1);
+  });
+
+  test('discards a late cancelled acquire after a newer connect attempt starts', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = createInitializedDevice('V2');
+    const disconnect = jest.fn().mockResolvedValue(undefined);
+    let resolveAcquire: ((value: { uuid: string; protocolType: 'V2' }) => void) | undefined;
+    const acquire = jest.fn(
+      () =>
+        new Promise<{ uuid: string; protocolType: 'V2' }>(resolve => {
+          resolveAcquire = resolve;
+        })
+    );
+    device.deviceConnector = { acquire, disconnect } as never;
+
+    device.beginConnectionAttempt();
+    const cancelledAcquire = device.acquire('V2');
+    await device.interruptionFromUser();
+    device.beginConnectionAttempt();
+    resolveAcquire?.({ uuid: 'stale-session', protocolType: 'V2' });
+
+    await expect(cancelledAcquire).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceInterruptedFromUser,
+    });
+    expect(disconnect).toHaveBeenCalledWith('stale-session');
+    expect(device.hasDeviceAcquire()).toBe(false);
+    expect(device.wasInterruptedByUser()).toBe(false);
+  });
+
+  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],
+    [EDeviceType.Pro2, 'desktop-web-ble', true, DeviceType.PRO2],
+    [EDeviceType.Neo, 'desktop-web-ble', true, DeviceType.NEO],
+    [EDeviceType.Pro2, 'react-native', true, DeviceType.PRO2],
+    [EDeviceType.Neo, 'react-native', true, DeviceType.NEO],
+    [EDeviceType.Pro2, 'lowlevel', false, DeviceType.PRO2],
+  ] as const)(
+    'refreshes %s runtime state after acquiring a fresh %s session',
+    async (deviceType, env, isBle, protocolV2DeviceType) => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      const device = createInitializedDevice('V2');
+      const staleProtocolInfo = {
+        version: 1,
+        build_fingerprint: 'bootloader__1.0.0__abcdef0__PROD__RELEASE',
+        supported_messages: [],
+      };
+      const freshProtocolInfo = {
+        version: 1,
+        build_fingerprint: 'application__5.0.0__abcdef0__PROD__RELEASE',
+        supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
+      };
+      device.updateState(
+        {
+          identity: { deviceType },
+          status: { mode: 'bootloader' },
+          raw: { protocolV2ProtocolInfo: staleProtocolInfo },
+        },
+        'initialize'
+      );
+      const acquire = jest
+        .fn()
+        .mockResolvedValue(isBle ? { uuid: 'fresh-session', protocolType: 'V2' } : 'fresh-session');
+      device.deviceConnector = { acquire } as never;
+
+      await device.acquire('V2', { throwOnRunPromiseError: true });
+      const typedCall = jest.fn().mockImplementation((requestType: string) => {
+        if (requestType === 'DeviceInfoGet') {
+          return {
+            message: {
+              protocol_version: 2,
+              hw: { Device_type: protocolV2DeviceType, serial_no: 'SERIAL-001' },
+              main_mcu: { application: { version: '5.0.0' } },
+            },
+          };
+        }
+        if (requestType === 'ProtocolInfoRequest') {
+          return { message: freshProtocolInfo };
+        }
+        if (requestType === 'DeviceStatusGet') {
+          return {
+            message: { init_states: true, unlocked: true, device_id: 'wallet-device-id' },
+          };
+        }
+        throw new Error(`Unexpected request: ${requestType}`);
+      });
+      device.commands.typedCall = typedCall as never;
+
+      await device.initialize();
+
+      expect(typedCall.mock.calls.map(callArgs => callArgs[0])).toEqual([
+        'DeviceInfoGet',
+        'ProtocolInfoRequest',
+        'DeviceStatusGet',
+      ]);
+      expect(device.state?.status.mode).toBe('normal');
+      expect(device.state?.identity.deviceType).toBe(deviceType);
+      expect(device.hasDeviceAcquire()).toBe(true);
+    }
+  );
+
   test('exposes the current transport usage state in public device snapshots', () => {
     const getSettings = jest
       .spyOn(DataManager, 'getSettings')

package/__tests__/device-pool-state.test.ts

@@ -38,6 +38,31 @@ describe('DevicePool state lifecycle', () => {
     expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['settings'] });
   });
 
+  test('refreshes Protocol V2 discovery state without legacy-specific options', async () => {
+    const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'bootloader' } });
+    const run = jest.fn(async (callback: () => Promise<void>) => callback());
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState,
+      run,
+    } as any;
+
+    await (DevicePool as any)._refreshRuntimeState(device, {
+      refreshRuntimeState: true,
+    });
+
+    expect(run).toHaveBeenCalledWith(expect.any(Function), {
+      connectProtocol: undefined,
+      forceProtocolDetection: undefined,
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, {
+      refreshSections: ['status'],
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['settings'],
+    });
+  });
+
   test('actively re-detects a cached device when protocol detection is forced', async () => {
     const descriptor = { path: 'cached-path', protocolType: 'V1' } as any;
     const device = Device.fromDescriptor(descriptor);