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

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -95,7 +95,8 @@ describe('AllNetworkGetAddressBase tracing', () => {
       'hidden-state',
       false,
       undefined,
-      false
+      false,
+      undefined
     );
     expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
@@ -173,7 +174,13 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined, true);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
+      'hidden-state',
+      false,
+      undefined,
+      true,
+      undefined
+    );
     expect(calls).toEqual(['resume-cardano-session', 'run-cardano-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });
@@ -212,7 +219,10 @@ describe('AllNetworkGetAddressBase tracing', () => {
         bundle: [],
       },
     });
-    method.protocolV2UnlockContext = { preflightCompleted: true };
+    method.protocolV2UnlockContext = {
+      preflightCompleted: true,
+      preflightMainPinSelected: true,
+    };
     const typedCall = jest.fn();
     method.device = {
       checkPassphraseStateSafety,
@@ -250,7 +260,13 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(undefined, true, undefined, false);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
+      undefined,
+      true,
+      undefined,
+      false,
+      true
+    );
     expect(calls).toEqual(['resume-standard-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });

package/__tests__/DeviceCommands.test.ts

@@ -19,12 +19,28 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
-  it('logs passphrase call request and response without exposing the passphrase', async () => {
+  it.each(['File already exists', 'NFT already exists'])(
+    'maps duplicate file response "%s" to FileAlreadyExists',
+    async message => {
+      const commands = createCommands();
+      await expect(
+        commands._filterCommonTypes(
+          {
+            type: 'Failure',
+            message: { code: 'Failure_DataError', message },
+          } as any,
+          'NFTUpdate'
+        )
+      ).rejects.toMatchObject({ errorCode: HardwareErrorCode.FileAlreadyExists });
+    }
+  );
+
+  it('logs passphrase request and canonical response without exposing the passphrase', async () => {
     const commands = createCommands();
-    const requestLog = getLogger(LoggerNames.DeviceCommands);
-    const responseLog = getLogger(LoggerNames.Core);
-    requestLog.messages.length = 0;
-    responseLog.messages.length = 0;
+    const log = getLogger(LoggerNames.DeviceCommands);
+    const coreLog = getLogger(LoggerNames.Core);
+    log.messages.length = 0;
+    coreLog.messages.length = 0;
     commands.mainId = 'main-id';
     commands.transport = {
       call: jest.fn().mockResolvedValue({
@@ -36,13 +52,13 @@ describe('DeviceCommands failure mapping', () => {
     } as any;
 
     await expect(
-      commands.call('DeviceSessionAskPassphrase', {
+      commands._commonCall('DeviceSessionAskPassphrase', {
         passphrase: 'hidden-wallet-secret',
         on_device: false,
       })
     ).resolves.toMatchObject({ type: 'Success' });
 
-    expect(requestLog.messages.at(-1)?.message).toEqual([
+    expect(log.messages.at(-2)?.message).toEqual([
       '[DeviceCommands] [call] Sending',
       'DeviceSessionAskPassphrase',
       {
@@ -50,21 +66,82 @@ describe('DeviceCommands failure mapping', () => {
         on_device: false,
       },
     ]);
-    expect(responseLog.messages.at(-1)?.message).toEqual([
-      '[DeviceCommands] [call] Received',
-      'Success',
+    expect(log.messages.at(-1)?.message).toEqual([
+      '_filterCommonTypes: ',
+      {
+        request: 'DeviceSessionAskPassphrase',
+        response: {
+          type: 'Success',
+          message: {
+            message: 'Passphrase accepted',
+          },
+        },
+      },
+    ]);
+    expect(
+      coreLog.messages.some(entry => entry.message[0] === '[DeviceCommands] [call] Received')
+    ).toBe(false);
+    expect(JSON.stringify([...log.messages, ...coreLog.messages])).not.toContain(
+      'hidden-wallet-secret'
+    );
+  });
+
+  it('redacts passphrases from transport errors logged through Core', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.DeviceCommands);
+    const coreLog = getLogger(LoggerNames.Core);
+    log.messages.length = 0;
+    coreLog.messages.length = 0;
+    const transportError = Object.assign(new Error('transport failed'), {
+      response: {
+        data: {
+          passphrase: 'hidden-wallet-secret',
+        },
+      },
+    });
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockRejectedValue(transportError),
+    } as any;
+
+    await expect(
+      commands._commonCall('DeviceSessionAskPassphrase', {
+        passphrase: 'hidden-wallet-secret',
+        on_device: false,
+      })
+    ).rejects.toBe(transportError);
+
+    expect(coreLog.messages.at(-1)?.message).toEqual([
+      '[DeviceCommands] [call] Received error',
       {
-        message: 'Passphrase accepted',
+        request: 'DeviceSessionAskPassphrase',
+        errorCode: undefined,
+        response: {
+          passphrase: '[REDACTED]',
+        },
       },
     ]);
-    expect(JSON.stringify([...requestLog.messages, ...responseLog.messages])).not.toContain(
+    expect(JSON.stringify([...log.messages, ...coreLog.messages])).not.toContain(
       'hidden-wallet-secret'
     );
   });
 
-  it('logs DeviceStatus response fields without exposing the device ID', async () => {
+  it('preserves the Protocol V2 peer-removed pairing error code', async () => {
     const commands = createCommands();
-    const log = getLogger(LoggerNames.Core);
+    const transportError = Object.assign(new Error('Peer removed pairing information'), {
+      errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
+    });
+    commands.mainId = 'main-id';
+    commands.transport = {
+      call: jest.fn().mockRejectedValue(transportError),
+    } as any;
+
+    await expect(commands._commonCall('DeviceInfoGet', {})).rejects.toBe(transportError);
+  });
+
+  it('logs canonical DeviceStatus response fields without exposing the device ID', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.DeviceCommands);
     log.messages.length = 0;
     commands.mainId = 'main-id';
     commands.transport = {
@@ -82,22 +159,27 @@ describe('DeviceCommands failure mapping', () => {
       }),
     } as any;
 
-    await expect(commands.call('DeviceStatusGet', {})).resolves.toMatchObject({
+    await expect(commands._commonCall('DeviceStatusGet', {})).resolves.toMatchObject({
       type: 'DeviceStatus',
     });
 
     const receivedLog = log.messages.at(-1)?.message;
     expect(receivedLog).toEqual([
-      '[DeviceCommands] [call] Received',
-      'DeviceStatus',
+      '_filterCommonTypes: ',
       {
-        device_id: '[REDACTED]',
-        unlocked: true,
-        init_states: true,
-        backup_required: false,
-        passphrase_enabled: true,
-        attach_to_pin_enabled: false,
-        unlocked_by_attach_to_pin: false,
+        request: 'DeviceStatusGet',
+        response: {
+          type: 'DeviceStatus',
+          message: {
+            device_id: '[REDACTED]',
+            unlocked: true,
+            init_states: true,
+            backup_required: false,
+            passphrase_enabled: true,
+            attach_to_pin_enabled: false,
+            unlocked_by_attach_to_pin: false,
+          },
+        },
       },
     ]);
     expect(JSON.stringify(receivedLog)).not.toContain('sensitive-device-id');
@@ -125,6 +207,59 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
+  it('logs the sanitized DeviceInfo response payload', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.DeviceCommands);
+    log.messages.length = 0;
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'DeviceInfo',
+          message: {
+            protocol_version: 2,
+            hw: {
+              Device_type: 7,
+              hardware_version: '1.0.0',
+            },
+            main_mcu: {
+              application: {
+                version: '5.0.0',
+                build_id: '20260811',
+                hash: 'firmware-hash',
+              },
+            },
+          },
+        } as any,
+        'DeviceInfoGet'
+      )
+    ).resolves.toMatchObject({ type: 'DeviceInfo' });
+
+    expect(log.messages.at(-1)?.message).toEqual([
+      '_filterCommonTypes: ',
+      {
+        request: 'DeviceInfoGet',
+        response: {
+          type: 'DeviceInfo',
+          message: {
+            protocol_version: 2,
+            hw: {
+              Device_type: 7,
+              hardware_version: '1.0.0',
+            },
+            main_mcu: {
+              application: {
+                version: '5.0.0',
+                build_id: '20260811',
+                hash: 'firmware-hash',
+              },
+            },
+          },
+        },
+      },
+    ]);
+  });
+
   it('logs the sanitized DeviceFirmwareUpdateStatus response payload', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);
@@ -170,6 +305,32 @@ describe('DeviceCommands failure mapping', () => {
     ]);
   });
 
+  it.each(['Failure_ProcessError', 5])(
+    'maps USB-priority link disabled to public BLE error 723 for code %s',
+    async code => {
+      const commands = createCommands();
+
+      await expect(
+        commands._filterCommonTypes(
+          {
+            type: 'Failure',
+            message: {
+              code,
+              message: ' link disabled ',
+            },
+          } as any,
+          'DeviceInfo'
+        )
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleUnavailableWhileUsbConnected,
+        params: {
+          failureCode: code,
+          firmwareMessage: ' link disabled ',
+        },
+      });
+    }
+  );
+
   it('maps an invalid DeviceSessionGet resume to WalletSessionInvalid', async () => {
     const commands = createCommands();
 
@@ -337,7 +498,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();
@@ -561,17 +722,22 @@ describe('DeviceCommands failure mapping', () => {
 });
 
 describe('DeviceCommands Protocol V2 interactive response compatibility', () => {
-  it('still auto-acks ButtonRequest when no hardware UI listener is registered', async () => {
+  it('auto-acks Pro2 ButtonRequest and registers Cancel instead of Initialize', async () => {
     const commands = createCommands();
     const emit = jest.fn();
+    const cancelDevice = jest.spyOn(commands, 'cancelDevice').mockResolvedValue(undefined);
+    const cancelDeviceOnOneKeyDevice = jest
+      .spyOn(commands, 'cancelDeviceOnOneKeyDevice')
+      .mockResolvedValue(undefined);
     const commonCall = jest.fn().mockResolvedValue({
       type: 'Success',
       message: {},
     });
+    const setCancelableAction = jest.fn();
     commands.device = {
       ...commands.device,
       getCurrentDeviceType: jest.fn(() => 'pro2'),
-      setCancelableAction: jest.fn(),
+      setCancelableAction,
       emit,
       listenerCount: jest.fn(() => 0),
     } as any;
@@ -593,6 +759,9 @@ describe('DeviceCommands Protocol V2 interactive response compatibility', () =>
       expect.objectContaining({ code: 'ButtonRequest_PinEntry' })
     );
     expect(commonCall).toHaveBeenCalledWith('ButtonAck', {}, undefined);
+    await setCancelableAction.mock.calls[0][0]();
+    expect(cancelDevice).toHaveBeenCalledTimes(1);
+    expect(cancelDeviceOnOneKeyDevice).not.toHaveBeenCalled();
   });
 
   it('rejects PassphraseRequest when the Pro2 UI listener is not registered', async () => {
@@ -644,7 +813,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;
 
@@ -654,6 +829,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__/base64Data.test.ts

@@ -0,0 +1,69 @@
+import { Buffer } from 'buffer';
+import { encode as encodeJpeg } from 'jpeg-js';
+
+import { decodeCanonicalBase64, decodeJpegBase64ToRgba } from '../src/api/helpers/base64Data';
+
+const createJpegBase64 = (width: number, height: number) => {
+  const rgba = new Uint8Array(width * height * 4).fill(0xff);
+  return encodeJpeg({ width, height, data: rgba }, 80).data.toString('base64');
+};
+
+describe('Base64 resource data', () => {
+  test('decodes canonical Base64 to a detached Uint8Array', () => {
+    const decoded = decodeCanonicalBase64({
+      value: 'AQID',
+      parameterName: 'packageBase64',
+      maxBytes: 3,
+    });
+
+    expect(decoded).toBeInstanceOf(Uint8Array);
+    expect(Array.from(decoded)).toEqual([1, 2, 3]);
+  });
+
+  test.each(['', 'not-base64', 'AB==', 'data:image/jpeg;base64,AQID'])(
+    'rejects non-canonical Base64 input %p',
+    value => {
+      expect(() =>
+        decodeCanonicalBase64({ value, parameterName: 'data', maxBytes: 1024 })
+      ).toThrow();
+    }
+  );
+
+  test('rejects oversized Base64 before decoding', () => {
+    const value = Buffer.alloc(64 * 1024 + 17).toString('base64');
+    expect(() =>
+      decodeCanonicalBase64({ value, parameterName: 'data', maxBytes: 64 * 1024 })
+    ).toThrow('maximum supported size');
+  });
+
+  test('decodes and validates a JPEG with the expected dimensions', () => {
+    const decoded = decodeJpegBase64ToRgba({
+      jpegBase64: createJpegBase64(2, 1),
+      parameterName: 'jpegBase64',
+      expectedWidth: 2,
+      expectedHeight: 1,
+    });
+
+    expect(decoded).toMatchObject({ width: 2, height: 1 });
+    expect(decoded.data).toHaveLength(8);
+  });
+
+  test('rejects non-JPEG bytes and unexpected dimensions', () => {
+    expect(() =>
+      decodeJpegBase64ToRgba({
+        jpegBase64: 'AQID',
+        parameterName: 'jpegBase64',
+        expectedWidth: 2,
+        expectedHeight: 1,
+      })
+    ).toThrow('JPEG image');
+    expect(() =>
+      decodeJpegBase64ToRgba({
+        jpegBase64: createJpegBase64(2, 1),
+        parameterName: 'jpegBase64',
+        expectedWidth: 1,
+        expectedHeight: 1,
+      })
+    ).toThrow('1x1');
+  });
+});

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

@@ -33,8 +33,6 @@ const validComponentIntegrity = {
 const release: IFirmwareReleaseInfo = {
   required: true,
   version: [2, 0, 0],
-  url: 'https://example.com/application-p1.bin',
-  fingerprint: 'release-fingerprint',
   changelog: {
     'zh-CN': '更新',
     'en-US': 'Update',
@@ -620,6 +618,54 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
   });
 
+  test('selects the Protocol V2 resource archive using the DeviceState identity', async () => {
+    const releaseWithResources: IFirmwareReleaseInfo = {
+      ...release,
+      resources: { source: resourceSource },
+    };
+    const method = new CheckAllFirmwareRelease({
+      id: 1,
+      payload: {
+        method: 'checkAllFirmwareRelease',
+        platform: 'desktop',
+        protocolV2ForceUpdateTargets: ['resource'],
+      },
+    });
+    method.init();
+    method.device = {
+      isProtocolV2: () => true,
+      features: {
+        firmwareVersion: '1.0.0',
+        serialNo: 'device-without-model-prefix',
+      },
+      getDeviceState: jest.fn().mockResolvedValue({
+        identity: { deviceType: 'pro2', firmwareType: EFirmwareType.Universal },
+        status: { mode: 'normal' },
+        versions: currentVersions,
+      }),
+    } as unknown as CheckAllFirmwareRelease['device'];
+    const getLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockImplementation(features =>
+        features.deviceType === 'pro2' ? releaseWithResources : undefined
+      );
+
+    await expect(method.run()).resolves.toMatchObject({
+      deviceType: 'pro2',
+      resourceArchive: resourceSource,
+      targetsToUpdate: expect.arrayContaining(['resource']),
+      firmwareUpdatePlan: {
+        executor: 'v4',
+        deviceModel: 'pro2',
+        targetsToUpdate: expect.arrayContaining(['resource']),
+      },
+    });
+    expect(getLatestReleaseSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ deviceType: 'pro2' }),
+      EFirmwareType.Universal
+    );
+  });
+
   test.each(['resource', 'boot_resources'] as const)(
     'allows an explicitly forced Protocol V2 resource-only target through %s',
     async forceTarget => {

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();
@@ -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',
+      },
+    });
+  });
 });