@onekeyfe/hd-transport-react-native 1.2.2-alpha.9 → 1.2.2

package/src/__tests__/protocolV2Link.test.ts

@@ -4,10 +4,11 @@ import transportPackage, {
   ProtocolV2,
   TRANSPORT_EVENT,
 } from '@onekeyfe/hd-transport';
-import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
 import ReactNativeBleTransport, {
   BLE_NATIVE_TEARDOWN_TIMEOUT_MS,
+  BLE_SETUP_WEDGED_MESSAGE,
   BLE_WRITE_PACKET_TIMEOUT_MS,
   configureProtocolV2BleTuning,
   getFirmwareUploadWriteRetryType,
@@ -28,7 +29,7 @@ jest.mock('react-native-ble-plx', () => ({
   BleError: class BleError extends Error {},
   BleErrorCode: {
     DeviceAlreadyConnected: 203,
-    DeviceDisconnected: 205,
+    DeviceDisconnected: 201,
     DeviceMTUChangeFailed: 206,
     OperationCancelled: 2,
     CharacteristicNotFound: 404,
@@ -169,11 +170,13 @@ const createHarness = ({
     serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
     isConnected: jest.fn(() => Promise.resolve(true)),
     cancelConnection: jest.fn(() => Promise.resolve()),
+    connect: jest.fn(),
     onDisconnected: jest.fn(callback => {
       disconnectCallback = callback;
       return { remove: jest.fn() };
     }),
   } as any;
+  device.connect.mockResolvedValue(device);
   device.requestMTU = jest.fn(() => Promise.resolve(device));
   device.requestConnectionPriority = jest.fn(() => Promise.resolve(device));
   const bleManager = {
@@ -360,6 +363,186 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     expect(new ReactNativeBleTransport({}).scanTimeout).toBe(3000);
   });
 
+  test.each(['V1', 'V2'] as const)(
+    'waits for Android bonding before connecting the %s GATT link',
+    async protocol => {
+      setPlatformOS('android');
+      const { transport, uuid, device } = protocol === 'V1' ? createV1Harness() : createHarness();
+      const operationOrder: string[] = [];
+      const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+      const bondStateMock = jest.requireMock('../BleManager').onDeviceBondState as jest.Mock;
+      const bonding = createDeferred<void>();
+
+      device.isConnected.mockResolvedValueOnce(false);
+      device.connect = jest.fn(() => {
+        operationOrder.push('connect');
+        return Promise.resolve(device);
+      });
+      pairDeviceMock.mockImplementationOnce(() => {
+        operationOrder.push('bond');
+        return Promise.resolve({ bonded: false, bonding: true });
+      });
+      bondStateMock.mockImplementationOnce(() => bonding.promise);
+
+      const acquiring = transport.acquire({ uuid, expectedProtocol: protocol });
+      await new Promise(resolve => {
+        setImmediate(resolve);
+      });
+      expect(operationOrder).toEqual(['bond']);
+      expect(device.connect).not.toHaveBeenCalled();
+
+      bonding.resolve();
+      await expect(acquiring).resolves.toEqual({
+        uuid,
+        protocolType: protocol,
+      });
+
+      expect(operationOrder).toEqual(['bond', 'connect']);
+      await transport.release(uuid, true);
+    }
+  );
+
+  test('preserves Android connect errors after bonding when both reconnect attempts fail', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device } = createHarness();
+    const BleErrorMock = jest.requireMock('react-native-ble-plx').BleError as new (
+      message: string
+    ) => Error;
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+    const firstError = Object.assign(new BleErrorMock('MTU change failed'), {
+      errorCode: 206,
+      reason: 'MTU change failed',
+    });
+    const fallbackError = Object.assign(new BleErrorMock('GATT connect failed'), {
+      errorCode: 205,
+      reason: 'GATT connect failed',
+    });
+
+    device.isConnected.mockResolvedValueOnce(false);
+    device.connect = jest
+      .fn()
+      .mockRejectedValueOnce(firstError)
+      .mockRejectedValueOnce(fallbackError);
+    pairDeviceMock.mockClear();
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleConnectedError,
+    });
+    expect(device.connect).toHaveBeenCalledTimes(2);
+    expect(pairDeviceMock).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not connect Android GATT when the system cannot start bonding', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device, bleManager } = createHarness();
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+
+    device.connect = jest.fn().mockResolvedValue(device);
+    pairDeviceMock.mockClear();
+    pairDeviceMock.mockResolvedValueOnce({ bonded: false, bonding: false });
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceNotBonded,
+    });
+    expect(device.connect).not.toHaveBeenCalled();
+    expect(bleManager.devices).not.toHaveBeenCalled();
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+  });
+
+  test('checks that Android GATT is connected after bonding and reconnecting', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device, bleManager } = createHarness();
+    device.isConnected.mockResolvedValueOnce(false).mockResolvedValueOnce(false);
+    device.connect = jest.fn().mockResolvedValue(device);
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleConnectedError,
+    });
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(device.cancelConnection).toHaveBeenCalledTimes(1);
+  });
+
+  test.each([
+    [
+      'ios',
+      'OneKey Neo',
+      {
+        iosErrorCode: 14,
+        reason: 'Peer removed pairing information',
+      },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+    [
+      'android',
+      'OneKey Pro 2',
+      {
+        androidErrorCode: 5,
+        reason: 'Connection state changed with status 5',
+      },
+      HardwareErrorCode.BleDeviceBondError,
+    ],
+  ] as const)(
+    'maps a %s %s stale bond during connect before protocol detection',
+    async (platform, deviceName, nativeError, errorCode) => {
+      setPlatformOS(platform);
+      const { transport, uuid, device } = createHarness({ deviceName });
+      const BleErrorMock = jest.requireMock('react-native-ble-plx').BleError as new (
+        message: string
+      ) => Error;
+      const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+      pairDeviceMock.mockClear();
+
+      device.isConnected.mockResolvedValueOnce(false);
+      device.connect = jest
+        .fn()
+        .mockRejectedValue(Object.assign(new BleErrorMock(nativeError.reason), nativeError));
+
+      await expect(transport.acquire({ uuid })).rejects.toMatchObject({ errorCode });
+      expect(pairDeviceMock).toHaveBeenCalledTimes(platform === 'android' ? 1 : 0);
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+    }
+  );
+
+  test('cleans up Android bonding failures without starting GATT', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device, bleManager } = createHarness();
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+
+    pairDeviceMock.mockRejectedValueOnce(new Error('bonding canceled'));
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toThrow(
+      'bonding canceled'
+    );
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(bleManager.devices).not.toHaveBeenCalled();
+    expect(device.isConnected).not.toHaveBeenCalled();
+  });
+
+  test('does not connect after stop while Android bonding is pending', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, bleManager } = createHarness();
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+    const bondStateMock = jest.requireMock('../BleManager').onDeviceBondState as jest.Mock;
+    const bonding = createDeferred<void>();
+    pairDeviceMock.mockResolvedValueOnce({ bonded: false, bonding: true });
+    bondStateMock.mockImplementationOnce(() => bonding.promise);
+
+    const acquiring = transport.acquire({ uuid, expectedProtocol: 'V2' });
+    const rejection = expect(acquiring).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+    await new Promise(resolve => {
+      setImmediate(resolve);
+    });
+    const stopping = transport.stop();
+    bonding.resolve();
+
+    await rejection;
+    await stopping;
+    expect(bleManager.devices).not.toHaveBeenCalled();
+  });
+
   test('uses withResponse for consecutive iOS Protocol V1 control commands without releasing', async () => {
     const { transport, uuid, writeCharacteristic } = createV1Harness({
       respondOnWriteCount: [1, 2],
@@ -435,7 +618,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).toHaveBeenCalledWith(247);
+    expect(device.requestMTU).not.toHaveBeenCalled();
     expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
     expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalled();
 
@@ -534,7 +717,72 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   test.each(['ios', 'android'] as const)(
-    'keeps a first expected Protocol V2 probe miss retryable on %s',
+    'waits for native disconnect after failed protocol detection before reconnecting on %s',
+    async platform => {
+      setPlatformOS(platform);
+      const { transport, uuid, device, bleManager } = createHarness();
+      const probes = transport as unknown as {
+        probeProtocolV1(uuid: string): Promise<boolean>;
+        probeProtocolV2(uuid: string): Promise<boolean>;
+        releaseNative(uuid: string, onclose: boolean): Promise<void>;
+      };
+      jest.spyOn(probes, 'probeProtocolV1').mockResolvedValueOnce(false);
+      const probesFinished = createDeferred<void>();
+      const probeProtocolV2 = jest
+        .spyOn(probes, 'probeProtocolV2')
+        .mockImplementationOnce(async () => {
+          // A link-fatal V2 timeout removes the cached transport before acquire fails.
+          await probes.releaseNative(uuid, true);
+          probesFinished.resolve();
+          return false;
+        });
+      let connected = true;
+      device.isConnected.mockImplementation(() => Promise.resolve(connected));
+      device.connect = jest.fn(() => {
+        connected = true;
+        return Promise.resolve(device);
+      });
+      const disconnectGate = createDeferred<void>();
+      bleManager.cancelDeviceConnection.mockImplementation(async () => {
+        await disconnectGate.promise;
+        connected = false;
+      });
+
+      const acquiring = transport.acquire({ uuid });
+      const failure = expect(acquiring).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleTimeoutError,
+      });
+      const reconnecting = transport.acquire({ uuid, expectedProtocol: 'V2' });
+
+      try {
+        await probesFinished.promise;
+        await new Promise(resolve => {
+          setImmediate(resolve);
+        });
+        expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+        expect(device.connect).not.toHaveBeenCalled();
+        expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+
+        disconnectGate.resolve();
+        await failure;
+        await expect(reconnecting).resolves.toEqual({ uuid, protocolType: 'V2' });
+        expect(device.connect).toHaveBeenCalledTimes(1);
+        await expect(
+          transport.call(uuid, 'Ping', { message: 'after-reconnect' })
+        ).resolves.toMatchObject({
+          type: 'Success',
+          message: { message: 'ok' },
+        });
+      } finally {
+        disconnectGate.resolve();
+        await Promise.allSettled([failure, reconnecting]);
+        await transport.release(uuid, true);
+      }
+    }
+  );
+
+  test.each(['ios', 'android'] as const)(
+    'disconnects after a first expected Protocol V2 probe miss while keeping it retryable on %s',
     async platform => {
       setPlatformOS(platform);
       const { transport, uuid, device } = createHarness();
@@ -544,13 +792,13 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
         errorCode: HardwareErrorCode.RuntimeError,
       });
 
-      expect(device.cancelConnection).not.toHaveBeenCalled();
+      expect(device.cancelConnection).toHaveBeenCalledTimes(1);
       expect(transport.getProtocolType(uuid)).toBeUndefined();
     }
   );
 
   test.each(['ios', 'android'] as const)(
-    'keeps a second expected Protocol V2 probe miss retryable on %s',
+    'disconnects after each expected Protocol V2 probe miss while keeping it retryable on %s',
     async platform => {
       setPlatformOS(platform);
       const { transport, uuid, device } = createHarness();
@@ -563,7 +811,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
         errorCode: HardwareErrorCode.RuntimeError,
       });
 
-      expect(device.cancelConnection).not.toHaveBeenCalled();
+      expect(device.cancelConnection).toHaveBeenCalledTimes(2);
       expect(transport.getProtocolType(uuid)).toBeUndefined();
     }
   );
@@ -598,7 +846,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   );
 
   test.each(['ios', 'android'] as const)(
-    'keeps a confirmed Protocol V2 probe miss retryable on %s without native bond evidence',
+    'disconnects after a confirmed Protocol V2 probe miss on %s without reporting a bond error',
     async platform => {
       setPlatformOS(platform);
       const { transport, uuid, device } = createHarness();
@@ -610,7 +858,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
         errorCode: HardwareErrorCode.RuntimeError,
       });
 
-      expect(device.cancelConnection).not.toHaveBeenCalled();
+      expect(device.cancelConnection).toHaveBeenCalledTimes(1);
       expect(transport.getProtocolType(uuid)).toBeUndefined();
     }
   );
@@ -702,6 +950,118 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     BLE_NATIVE_TEARDOWN_TIMEOUT_MS + 5_000
   );
 
+  test('preserves the unpaired error when iOS disconnects during the first V1 probe', async () => {
+    const { transport, uuid, writeCharacteristic } = createHarness({ deviceName: 'Neo Test' });
+    writeCharacteristic.writeWithResponse.mockRejectedValueOnce({
+      errorCode: 201,
+      iosErrorCode: 7,
+      reason: 'The specified device has disconnected from us.',
+    });
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+
+    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceNotBonded,
+    });
+
+    expect(probeProtocolV2).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(transport.getProtocolType(uuid)).toBeUndefined();
+  });
+
+  test('preserves a native iOS disconnect during an expected Protocol V2 probe', async () => {
+    const { transport, uuid, writeCharacteristic, bleManager } = createHarness({
+      deviceName: 'Neo Test',
+    });
+    const nativeDisconnect = {
+      errorCode: 201,
+      iosErrorCode: 7,
+      reason: 'The specified device has disconnected from us.',
+    };
+    writeCharacteristic.writeWithoutResponse.mockRejectedValueOnce(nativeDisconnect);
+    const probeProtocolV1 = jest.spyOn(transport as any, 'probeProtocolV1');
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+
+    expect(probeProtocolV1).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(transport.getProtocolType(uuid)).toBeUndefined();
+  });
+
+  test('preserves a native iOS disconnect during a V2-first probe without falling back to V1', async () => {
+    const { transport, uuid, writeCharacteristic } = createHarness({ deviceName: 'Neo Test' });
+    writeCharacteristic.writeWithoutResponse.mockRejectedValueOnce({
+      errorCode: 201,
+      iosErrorCode: 7,
+      reason: 'The specified device has disconnected from us.',
+    });
+    const probeProtocolV1 = jest.spyOn(transport as any, 'probeProtocolV1');
+
+    await expect(transport.acquire({ uuid, protocolHint: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+
+    expect(probeProtocolV1).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(transport.getProtocolType(uuid)).toBeUndefined();
+  });
+
+  test.each(['V1', 'V2'] as const)(
+    'preserves terminal BLE failures from the %s probe without trying another protocol',
+    async protocol => {
+      for (const errorCode of [
+        HardwareErrorCode.BleDeviceNotBonded,
+        HardwareErrorCode.BleDeviceBondedCanceled,
+        HardwareErrorCode.BlePeerRemovedPairingInformation,
+        HardwareErrorCode.BleDeviceDisconnected,
+        HardwareErrorCode.BleCharacteristicNotifyError,
+        HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
+        HardwareErrorCode.BleWriteCharacteristicError,
+      ]) {
+        const { transport, uuid } = createHarness();
+        const error = ERRORS.TypedError(errorCode);
+        const call = jest
+          .spyOn(transport as any, protocol === 'V1' ? 'callProtocolV1' : 'callProtocolV2')
+          .mockRejectedValue(error);
+        const otherProbe = jest.spyOn(
+          transport as any,
+          protocol === 'V1' ? 'probeProtocolV2' : 'probeProtocolV1'
+        );
+
+        await expect(transport.acquire({ uuid, protocolHint: protocol })).rejects.toBe(error);
+
+        expect(call).toHaveBeenCalledTimes(1);
+        expect(otherProbe).not.toHaveBeenCalled();
+        expect(transport.getProtocolType(uuid)).toBeUndefined();
+      }
+    }
+  );
+
+  test.each(['V1', 'V2'] as const)(
+    'still falls back after a silent %s probe timeout',
+    async protocol => {
+      const { transport, uuid, device, bleManager } = createHarness();
+      jest
+        .spyOn(transport as any, protocol === 'V1' ? 'callProtocolV1' : 'callProtocolV2')
+        .mockRejectedValue(ERRORS.TypedError(HardwareErrorCode.BleTimeoutError));
+      const otherProbe = jest
+        .spyOn(transport as any, protocol === 'V1' ? 'probeProtocolV2' : 'probeProtocolV1')
+        .mockResolvedValue(true);
+
+      await expect(transport.acquire({ uuid, protocolHint: protocol })).resolves.toEqual({
+        uuid,
+        protocolType: protocol === 'V1' ? 'V2' : 'V1',
+      });
+
+      expect(otherProbe).toHaveBeenCalledTimes(1);
+      expect(bleManager.cancelDeviceConnection).not.toHaveBeenCalled();
+      expect(device.cancelConnection).not.toHaveBeenCalled();
+      await transport.release(uuid, true);
+    }
+  );
+
   test('falls back to the other active probe on iOS when protocol metadata is absent', async () => {
     const { transport, uuid } = createHarness({ deviceName: 'OneKey' });
     const probeProtocolV1 = jest
@@ -722,57 +1082,621 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.release(uuid, true);
   });
 
-  test('continues with the current MTU when the connected snapshot refresh fails', async () => {
+  test('does not renegotiate an already usable MTU during acquire', async () => {
     const { transport, uuid, device } = createHarness();
-    const mtuError = new Error('MTU refresh failed');
-    device.requestMTU.mockRejectedValueOnce(mtuError);
 
     await expect(transport.acquire({ uuid })).resolves.toEqual({
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).toHaveBeenCalledTimes(1);
+    expect(device.requestMTU).not.toHaveBeenCalled();
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(247);
     await transport.release(uuid, true);
   });
 
-  test('refreshes a transient bootloader MTU after notifications are ready', async () => {
+  test('requests a low MTU once before protocol probing', async () => {
     const { transport, uuid, device } = createHarness();
     device.mtu = 23;
-    device.requestMTU
-      .mockResolvedValueOnce(device)
-      .mockResolvedValueOnce(device)
-      .mockImplementationOnce(() => {
-        device.mtu = 247;
-        return Promise.resolve(device);
-      });
+    device.requestMTU.mockImplementationOnce(() => {
+      device.mtu = 247;
+      return Promise.resolve(device);
+    });
 
     await expect(transport.acquire({ uuid })).resolves.toEqual({
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).toHaveBeenCalledTimes(3);
+    expect(device.requestMTU).toHaveBeenCalledTimes(1);
+    expect(device.requestMTU).toHaveBeenCalledWith(
+      247,
+      expect.stringContaining(`${uuid}:mtu:connected:0:`)
+    );
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(247);
     await transport.release(uuid, true);
   });
 
-  test('continues with a low bootloader MTU when the bounded retry fails', async () => {
+  test('continues with a low MTU when the single negotiation fails', async () => {
     const { transport, uuid, device } = createHarness();
     device.mtu = 23;
-    device.requestMTU
-      .mockResolvedValueOnce(device)
-      .mockResolvedValueOnce(device)
-      .mockRejectedValueOnce(new Error('bootloader MTU retry failed'));
+    device.requestMTU.mockRejectedValueOnce(new Error('MTU negotiation failed'));
 
     await expect(transport.acquire({ uuid })).resolves.toEqual({
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).toHaveBeenCalledTimes(3);
+    expect(device.requestMTU).toHaveBeenCalledTimes(1);
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
     await transport.release(uuid, true);
   });
 
+  test('bounds a stalled MTU negotiation and continues protocol probing', async () => {
+    const { transport, uuid, device, bleManager } = createHarness();
+    device.mtu = 23;
+    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
+
+    await expect(transport.acquire({ uuid })).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+    const transactionId = device.requestMTU.mock.calls[0]?.[1];
+    expect(transactionId).toEqual(expect.stringContaining(`${uuid}:mtu:connected:0:`));
+    expect(bleManager.cancelTransaction).toHaveBeenCalledWith(transactionId);
+    expect(device.cancelConnection).toHaveBeenCalled();
+    expect(device.connect).toHaveBeenCalledWith(
+      expect.objectContaining({ timeout: expect.any(Number) })
+    );
+    expect(device.connect.mock.calls.at(-1)?.[0]).not.toHaveProperty('requestMTU');
+    expect(device.requestMTU).toHaveBeenCalledTimes(1);
+    expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
+    await transport.release(uuid, true);
+  }, 10_000);
+
+  test('keeps the iOS link when the MTU-timeout reconnect reports it is still connected', async () => {
+    const { BleError: BleErrorMock, BleErrorCode } = jest.requireMock('react-native-ble-plx');
+    const { transport, uuid, device, bleManager } = createHarness();
+    device.mtu = 23;
+    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
+    device.connect.mockRejectedValueOnce(
+      Object.assign(new BleErrorMock('Device already connected'), {
+        errorCode: BleErrorCode.DeviceAlreadyConnected,
+      })
+    );
+
+    await expect(transport.acquire({ uuid })).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+    expect(device.cancelConnection).toHaveBeenCalledTimes(1);
+    expect(device.connect).toHaveBeenCalledTimes(1);
+    expect(device.requestMTU).toHaveBeenCalledTimes(1);
+    expect(bleManager.destroy).not.toHaveBeenCalled();
+    expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
+    await transport.release(uuid, true);
+  }, 10_000);
+
+  test('reconnects after an iOS MTU timeout when cancelling the timed-out link fails', async () => {
+    const { BleError: BleErrorMock, BleErrorCode } = jest.requireMock('react-native-ble-plx');
+    const { transport, uuid, device, bleManager } = createHarness();
+    device.mtu = 23;
+    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
+    device.cancelConnection.mockRejectedValueOnce(
+      Object.assign(new BleErrorMock('Operation was cancelled'), {
+        errorCode: BleErrorCode.OperationCancelled,
+      })
+    );
+
+    await expect(transport.acquire({ uuid })).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+    expect(device.connect).toHaveBeenCalledTimes(1);
+    expect(device.connect.mock.calls[0]?.[0]).not.toHaveProperty('requestMTU');
+    expect(bleManager.destroy).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  }, 10_000);
+
+  test('maps a stale bond from the iOS MTU-timeout reconnect', async () => {
+    const { BleError: BleErrorMock } = jest.requireMock('react-native-ble-plx');
+    const { transport, uuid, device } = createHarness();
+    device.mtu = 23;
+    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
+    device.connect.mockRejectedValueOnce(
+      Object.assign(new BleErrorMock('Peer removed pairing information'), {
+        errorCode: 200,
+        iosErrorCode: 14,
+      })
+    );
+
+    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
+    });
+    await transport.release(uuid, true).catch(() => undefined);
+  }, 10_000);
+
+  test('bounds a hung iOS MTU-timeout teardown and resets the BLE manager without reconnecting', async () => {
+    const { transport, uuid, device, bleManager } = createHarness();
+    device.mtu = 23;
+    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
+    device.cancelConnection.mockImplementationOnce(() => new Promise(() => {}));
+
+    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleTimeoutError,
+      message: expect.stringContaining('BLE MTU cleanup timed out'),
+    });
+    expect(bleManager.destroy).toHaveBeenCalledTimes(1);
+    expect(transport.blePlxManager).toBeUndefined();
+    expect(device.connect).not.toHaveBeenCalled();
+    expect((transport as any).lifecycleOperations.has(uuid)).toBe(false);
+  }, 15_000);
+
+  test('does not reconnect after a hung iOS MTU-timeout teardown when the manager reset is already pending', async () => {
+    const { transport, uuid, device, bleManager } = createHarness();
+    device.mtu = 23;
+    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
+    device.cancelConnection.mockImplementationOnce(() => new Promise(() => {}));
+    // Another device's reset is still draining, so this teardown timeout cannot swap the manager.
+    jest.spyOn(transport as any, 'resetPlxManager').mockImplementation(() => undefined);
+
+    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleTimeoutError,
+    });
+    expect(transport.blePlxManager).toBe(bleManager);
+    expect(device.connect).not.toHaveBeenCalled();
+  }, 15_000);
+
+  test('does not request MTU again after connect falls back without requestMTU', async () => {
+    const { BleError: BleErrorMock, BleErrorCode } = jest.requireMock('react-native-ble-plx');
+    const { transport, uuid, device } = createHarness();
+    device.mtu = 23;
+    device.isConnected.mockResolvedValueOnce(false).mockResolvedValue(true);
+    device.connect
+      .mockRejectedValueOnce(
+        Object.assign(new BleErrorMock('Operation was cancelled'), {
+          errorCode: BleErrorCode.OperationCancelled,
+        })
+      )
+      .mockResolvedValue(device);
+
+    await expect(transport.acquire({ uuid })).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+    expect(device.connect).toHaveBeenCalledTimes(2);
+    expect(device.connect.mock.calls[0][0]).toEqual(expect.objectContaining({ requestMTU: 247 }));
+    expect(device.connect.mock.calls[1][0]).not.toHaveProperty('requestMTU');
+    expect(device.requestMTU).not.toHaveBeenCalled();
+    expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
+    await transport.release(uuid, true);
+  });
+
+  test('keeps the iOS connect chain unchanged', async () => {
+    const { transport, uuid, device } = createHarness();
+    device.isConnected.mockResolvedValueOnce(false);
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+    expect(device.connect).toHaveBeenCalledWith({
+      requestMTU: 247,
+      timeout: expect.any(Number),
+      refreshGatt: 'OnConnected',
+    });
+    expect(device.requestMTU).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
+  describe('Android MTU before service discovery', () => {
+    beforeEach(() => {
+      setPlatformOS('android');
+      jest.useFakeTimers({
+        doNotFake: ['setImmediate', 'queueMicrotask', 'nextTick', 'performance'],
+      });
+    });
+
+    afterEach(() => {
+      jest.clearAllTimers();
+      jest.useRealTimers();
+    });
+
+    const advanceUntil = async (condition: () => boolean, budgetMs = 60_000) => {
+      for (let elapsed = 0; !condition(); elapsed += 50) {
+        if (elapsed >= budgetMs) throw new Error(`fake time exhausted after ${budgetMs}ms`);
+        jest.advanceTimersByTime(50);
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise(resolve => {
+          setImmediate(resolve);
+        });
+      }
+    };
+
+    const settle = async <T>(promise: Promise<T>, budgetMs?: number): Promise<T> => {
+      let done = false;
+      promise.then(
+        () => {
+          done = true;
+        },
+        () => {
+          done = true;
+        }
+      );
+      await advanceUntil(() => done, budgetMs);
+      return promise;
+    };
+
+    /**
+     * A device whose LE link is only up between connect() and cancelConnection(), so the
+     * transport has to reconnect after every drop instead of the test flipping the link.
+     */
+    const reconnectingDevice = (device: any) => {
+      const link = { connected: false };
+      device.isConnected.mockImplementation(() => Promise.resolve(link.connected));
+      device.connect = jest.fn(() => {
+        link.connected = true;
+        return Promise.resolve(device);
+      });
+      device.cancelConnection.mockImplementation(() => {
+        link.connected = false;
+        return Promise.resolve();
+      });
+      return link;
+    };
+
+    /** requestMTU resolves a fresh Device snapshot, as react-native-ble-plx does. */
+    const negotiatedSnapshot = (device: any, mtu: number) => {
+      const negotiated = { ...device, mtu };
+      device.requestMTU.mockImplementation(() => Promise.resolve(negotiated));
+      return negotiated;
+    };
+
+    test('negotiates the MTU after a bare connect and before service discovery, adopting the returned device', async () => {
+      const { transport, uuid, device } = createHarness();
+      reconnectingDevice(device);
+      device.mtu = 23;
+      const negotiated = negotiatedSnapshot(device, 247);
+
+      await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
+        uuid,
+        protocolType: 'V2',
+      });
+
+      expect(device.connect).toHaveBeenCalledTimes(1);
+      expect(device.connect).toHaveBeenCalledWith({ timeout: expect.any(Number) });
+      const resolveCharacteristics = (transport as any).resolveCharacteristics as jest.Mock;
+      const [connectOrder] = device.connect.mock.invocationCallOrder;
+      const [mtuOrder] = device.requestMTU.mock.invocationCallOrder;
+      const [discoveryOrder] = resolveCharacteristics.mock.invocationCallOrder;
+      expect(connectOrder).toBeLessThan(mtuOrder);
+      expect(mtuOrder).toBeLessThan(discoveryOrder);
+      const cached = (transport as any).getCachedTransport(uuid);
+      expect(cached.device).toBe(negotiated);
+      expect(cached.mtuSize).toBe(247);
+      await settle(transport.release(uuid, true));
+    });
+
+    test.each([
+      { expectedProtocol: 'V2' as const, label: 'an expected Protocol V2 device' },
+      { expectedProtocol: 'V1' as const, label: 'an expected Protocol V1 device' },
+      { expectedProtocol: undefined, label: 'a device of unknown protocol' },
+    ])('drops a link that stays at the default MTU for $label', async ({ expectedProtocol }) => {
+      const { transport, uuid, device } = createHarness();
+      device.mtu = 23;
+
+      await expect(settle(transport.acquire({ uuid, expectedProtocol }))).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleConnectedError,
+      });
+      expect((transport as any).resolveCharacteristics).not.toHaveBeenCalled();
+      expect(device.cancelConnection).toHaveBeenCalled();
+    });
+
+    test.each([
+      ['never completes', () => new Promise(() => {})],
+      ['completes at the default MTU', undefined],
+      ['is rejected', () => Promise.reject(new Error('MTU request failed'))],
+    ])(
+      'a second consecutive MTU failure that %s trips the wedged-link guard',
+      async (_label, requestMTU) => {
+        const { transport, uuid, device, bleManager } = createHarness();
+        device.mtu = 23;
+        if (requestMTU) device.requestMTU.mockImplementation(requestMTU);
+
+        await expect(
+          settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))
+        ).rejects.toMatchObject({
+          errorCode: HardwareErrorCode.BleConnectedError,
+        });
+        await expect(
+          settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))
+        ).rejects.toMatchObject({
+          errorCode: HardwareErrorCode.PollingTimeout,
+          message: expect.stringContaining(BLE_SETUP_WEDGED_MESSAGE),
+        });
+        expect(bleManager.destroy).toHaveBeenCalled();
+      }
+    );
+
+    test('stop() during the link-drop wait releases it promptly', async () => {
+      const { transport, uuid, device } = createHarness();
+      device.mtu = 23;
+      device.requestMTU.mockImplementation(() => new Promise(() => {}));
+
+      const acquiring = transport.acquire({ uuid, expectedProtocol: 'V2' }).catch(error => error);
+      // The link-drop teardown cancels the device connection before the wait starts.
+      await advanceUntil(() => device.cancelConnection.mock.calls.length > 0);
+      await advanceUntil(() => false, 1000).catch(() => undefined);
+      await settle(transport.stop(), 1000);
+      await expect(settle(acquiring, 1000)).resolves.toBeInstanceOf(Error);
+    });
+
+    test.each([
+      {
+        label: 'a missing OneKey service',
+        error: () => ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound),
+      },
+      {
+        label: 'a missing characteristic',
+        error: () => ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotFound),
+      },
+      {
+        label: 'a mis-typed characteristic',
+        error: () =>
+          ERRORS.TypedError('BLECharacteristicNotWritable: write characteristic not writable'),
+      },
+    ])(
+      'marks the endpoint on $label and refreshes the GATT table on the next connect, before the MTU exchange',
+      async ({ error }) => {
+        const { transport, uuid, device } = createHarness();
+        const link = reconnectingDevice(device);
+        device.mtu = 23;
+        negotiatedSnapshot(device, 247);
+        const resolveCharacteristics = (transport as any).resolveCharacteristics as jest.Mock;
+        resolveCharacteristics.mockImplementationOnce(() => Promise.reject(error()));
+
+        await expect(
+          settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))
+        ).rejects.toBeDefined();
+        expect(link.connected).toBe(true);
+
+        await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
+          uuid,
+          protocolType: 'V2',
+        });
+        expect(device.connect).toHaveBeenLastCalledWith({
+          timeout: expect.any(Number),
+          refreshGatt: 'OnConnected',
+        });
+        // The stale table is only refreshed through a connect, so the live link is dropped first.
+        const connectOrders: number[] = device.connect.mock.invocationCallOrder;
+        expect(device.cancelConnection.mock.invocationCallOrder[0]).toBeLessThan(
+          connectOrders[connectOrders.length - 1]
+        );
+        const discoveryOrders = resolveCharacteristics.mock.invocationCallOrder;
+        const mtuOrders: number[] = device.requestMTU.mock.invocationCallOrder;
+        expect(discoveryOrders[discoveryOrders.length - 1]).toBeLessThan(
+          mtuOrders[mtuOrders.length - 1]
+        );
+
+        // The refresh is spent once the table resolved through a refreshed connect.
+        await settle(transport.release(uuid, true));
+        link.connected = false;
+        await settle(transport.acquire({ uuid, expectedProtocol: 'V2' }));
+        expect(device.connect).toHaveBeenLastCalledWith({ timeout: expect.any(Number) });
+        await settle(transport.release(uuid, true));
+      }
+    );
+
+    test('keeps the refresh marker when the refresh connect fell back without refreshGatt', async () => {
+      const { transport, uuid, device } = createHarness();
+      const link = reconnectingDevice(device);
+      device.mtu = 23;
+      negotiatedSnapshot(device, 247);
+      const resolveCharacteristics = (transport as any).resolveCharacteristics as jest.Mock;
+      resolveCharacteristics.mockImplementationOnce(() =>
+        Promise.reject(ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound))
+      );
+      await expect(
+        settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))
+      ).rejects.toBeDefined();
+
+      // The fallback connect carries no refreshGatt.
+      const cancelled = Object.assign(new Error('Operation was cancelled'), { errorCode: 2 });
+      device.connect.mockImplementationOnce(() => Promise.reject(cancelled));
+      await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
+        uuid,
+        protocolType: 'V2',
+      });
+
+      await settle(transport.release(uuid, true));
+      link.connected = false;
+      await settle(transport.acquire({ uuid, expectedProtocol: 'V2' }));
+      expect(device.connect).toHaveBeenLastCalledWith({
+        timeout: expect.any(Number),
+        refreshGatt: 'OnConnected',
+      });
+      await settle(transport.release(uuid, true));
+    });
+
+    test('does not drop a link it has just connected with refreshGatt', async () => {
+      const { transport, uuid, device, bleManager } = createHarness();
+      bleManager.devices.mockResolvedValue([]);
+      const connectToDevice = jest.fn(() => Promise.resolve(device));
+      Object.assign(bleManager, { connectToDevice });
+      (transport as any).androidGattCacheRefreshes.add(uuid);
+
+      await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
+        uuid,
+        protocolType: 'V2',
+      });
+      expect(connectToDevice).toHaveBeenCalledTimes(1);
+      expect(connectToDevice).toHaveBeenCalledWith(uuid, {
+        timeout: expect.any(Number),
+        refreshGatt: 'OnConnected',
+      });
+      expect(device.cancelConnection).not.toHaveBeenCalled();
+      expect(device.connect).not.toHaveBeenCalled();
+      await settle(transport.release(uuid, true));
+    });
+
+    test('still refreshes after a connect-by-id refresh fell back without refreshGatt', async () => {
+      const { transport, uuid, device, bleManager } = createHarness();
+      const link = reconnectingDevice(device);
+      bleManager.devices.mockResolvedValue([]);
+      const cancelled = Object.assign(new Error('Operation was cancelled'), { errorCode: 2 });
+      const connectToDevice = jest
+        .fn()
+        .mockImplementationOnce(() => Promise.reject(cancelled))
+        .mockImplementation(() => {
+          link.connected = true;
+          return Promise.resolve(device);
+        });
+      Object.assign(bleManager, { connectToDevice });
+      (transport as any).androidGattCacheRefreshes.add(uuid);
+
+      await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
+        uuid,
+        protocolType: 'V2',
+      });
+      expect(connectToDevice).toHaveBeenLastCalledWith(uuid, { timeout: expect.any(Number) });
+      expect(device.connect).toHaveBeenLastCalledWith({
+        timeout: expect.any(Number),
+        refreshGatt: 'OnConnected',
+      });
+      expect((transport as any).androidGattCacheRefreshes.has(uuid)).toBe(false);
+      await settle(transport.release(uuid, true));
+    });
+
+    test.each([
+      'Cannot write client characteristic config descriptor',
+      'Cannot find client characteristic config descriptor',
+      'The handle is invalid',
+      'Writing is not permitted',
+    ])('arms a GATT refresh from the notify failure "%s"', async reason => {
+      const harness = createHarness();
+      const { transport, uuid, device } = harness;
+      reconnectingDevice(device);
+      device.mtu = 23;
+      negotiatedSnapshot(device, 247);
+
+      await settle(transport.acquire({ uuid, expectedProtocol: 'V2' }));
+      harness.emitMonitorError(Object.assign(new Error('notify failed'), { reason }));
+
+      await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
+        uuid,
+        protocolType: 'V2',
+      });
+      expect(device.connect).toHaveBeenLastCalledWith({
+        timeout: expect.any(Number),
+        refreshGatt: 'OnConnected',
+      });
+      await settle(transport.release(uuid, true));
+    });
+
+    test('arms a GATT refresh from a notify failure while notifications are being enabled', async () => {
+      const { transport, uuid, device } = createHarness({
+        monitorError: Object.assign(new Error('notify failed'), {
+          reason: 'Cannot write client characteristic config descriptor',
+        }),
+      });
+      const link = reconnectingDevice(device);
+      device.mtu = 23;
+      negotiatedSnapshot(device, 247);
+
+      await settle(transport.acquire({ uuid, expectedProtocol: 'V2' }).catch(error => error));
+      await settle(transport.release(uuid, true));
+      link.connected = false;
+      await settle(transport.acquire({ uuid, expectedProtocol: 'V2' }).catch(error => error));
+      expect(device.connect).toHaveBeenLastCalledWith({
+        timeout: expect.any(Number),
+        refreshGatt: 'OnConnected',
+      });
+      await settle(transport.release(uuid, true));
+    });
+
+    test('keeps the GATT refresh for a firmware-install reconnect', async () => {
+      const { transport, uuid, device } = createHarness();
+      (transport as any).sessionProtocols.set(uuid, 'V2');
+      reconnectingDevice(device);
+
+      await expect(
+        settle(transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true }))
+      ).resolves.toEqual({ uuid, protocolType: 'V2' });
+      expect(device.connect).toHaveBeenCalledWith({
+        timeout: expect.any(Number),
+        refreshGatt: 'OnConnected',
+      });
+      await settle(transport.release(uuid, true));
+    });
+  });
+
+  test('spends one Initialize wake on the detection after a fully silent one', async () => {
+    setPlatformOS('android');
+    const { transport, uuid } = createHarness();
+    const probes = transport as any;
+    jest.spyOn(probes, 'probeProtocolV1').mockResolvedValue(false);
+    jest.spyOn(probes, 'probeProtocolV2').mockResolvedValue(false);
+    const callProtocolV1 = jest.spyOn(probes, 'callProtocolV1').mockResolvedValue({});
+
+    // Nothing has gone silent yet, so the device keeps whatever session it has.
+    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
+    expect(callProtocolV1).not.toHaveBeenCalled();
+
+    // The previous detection answered on no protocol, which is what a sleeping Classic
+    // looks like, so this one wakes on the fresh link before probing.
+    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
+    expect(callProtocolV1).toHaveBeenCalledTimes(1);
+    expect(callProtocolV1.mock.calls[0]?.[1]).toBe('Initialize');
+
+    // Still silent: the wake is not repeated, so a device that is simply away is not
+    // pushed into a fresh wallet session on every poll.
+    callProtocolV1.mockClear();
+    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
+    expect(callProtocolV1).not.toHaveBeenCalled();
+  });
+
+  test('does not send the Initialize wake before a V2-first probe', async () => {
+    setPlatformOS('android');
+    const { transport, uuid } = createHarness();
+    const probes = transport as any;
+    jest.spyOn(probes, 'probeProtocolV1').mockResolvedValue(false);
+    jest.spyOn(probes, 'probeProtocolV2').mockResolvedValue(false);
+    const callProtocolV1 = jest.spyOn(probes, 'callProtocolV1').mockResolvedValue({});
+
+    await expect(transport.acquire({ uuid, protocolHint: 'V2' })).rejects.toBeDefined();
+    // Silent now, but the next detection probes V2 first: a late V1 reply would land on
+    // the V2 probe, so no Initialize is sent.
+    await expect(transport.acquire({ uuid, protocolHint: 'V2' })).rejects.toBeDefined();
+    expect(callProtocolV1).not.toHaveBeenCalled();
+  });
+
+  test('does not send the Initialize wake on iOS', async () => {
+    const { transport, uuid } = createHarness();
+    const probes = transport as any;
+    jest.spyOn(probes, 'probeProtocolV1').mockResolvedValue(false);
+    jest.spyOn(probes, 'probeProtocolV2').mockResolvedValue(false);
+    const callProtocolV1 = jest.spyOn(probes, 'callProtocolV1').mockResolvedValue({});
+
+    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
+    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
+    expect(callProtocolV1).not.toHaveBeenCalled();
+  });
+
+  test('an unanswered Initialize wake settles the acquire and frees the lifecycle lock', async () => {
+    setPlatformOS('android');
+    const harness = createHarness();
+    const { transport, uuid } = harness;
+    const probes = transport as any;
+    harness.setShouldRespond(false);
+    jest.spyOn(probes, 'probeProtocolV1').mockResolvedValue(false);
+    jest.spyOn(probes, 'probeProtocolV2').mockResolvedValue(false);
+
+    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
+    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleTimeoutError,
+    });
+    await transport.disconnect(uuid);
+    await transport.stop();
+  }, 10_000);
+
   test('accepts a stable low MTU without the delayed refresh loop', async () => {
     const { transport, uuid, device } = createHarness();
     device.mtu = 185;
@@ -781,7 +1705,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).toHaveBeenCalledTimes(1);
+    expect(device.requestMTU).not.toHaveBeenCalled();
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(185);
     await transport.release(uuid, true);
   });
@@ -794,7 +1718,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).toHaveBeenCalledTimes(3);
+    expect(device.requestMTU).toHaveBeenCalledTimes(1);
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBeUndefined();
     expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalled();
     await transport.release(uuid, true);
@@ -812,7 +1736,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     });
 
     await expect(transport.call(uuid, 'FileWrite', {})).resolves.toBeDefined();
-    expect(device.requestMTU).toHaveBeenCalledTimes(4);
+    expect(device.requestMTU).toHaveBeenCalledTimes(2);
     expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(
       writesBeforeFileWrite + 1
     );
@@ -829,7 +1753,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await expect(transport.call(uuid, 'FileWrite', {})).rejects.toMatchObject({
       errorCode: HardwareErrorCode.BleConnectedError,
     });
-    expect(device.requestMTU).toHaveBeenCalledTimes(4);
+    expect(device.requestMTU).toHaveBeenCalledTimes(2);
     expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(writesBeforeFileWrite);
     await transport.release(uuid, true);
   });
@@ -883,6 +1807,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     expect(notifySubscriptionRemovers[0]).toHaveBeenCalledTimes(1);
     expect(notifySubscriptionRemovers[1]).toHaveBeenCalledTimes(1);
     expect(bleManager.cancelTransaction).toHaveBeenCalled();
+    expect(device.cancelConnection).toHaveBeenCalledTimes(1);
     expect(transport.getProtocolType(uuid)).toBeUndefined();
   });
 
@@ -937,6 +1862,115 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     });
   });
 
+  test.each(['ios', 'android'] as const)(
+    'disconnects after an active V2 timeout and reconnects even if a listener fails on %s',
+    async platform => {
+      setPlatformOS(platform);
+      const harness = createHarness();
+      const { transport, uuid, device, bleManager, sentSeqs, emitter } = harness;
+      const disconnected = jest.fn(() => {
+        throw new Error('Disconnect listener failed');
+      });
+      emitter.on(TRANSPORT_EVENT.DEVICE_DISCONNECT, disconnected);
+      let connected = true;
+      device.isConnected.mockImplementation(() => Promise.resolve(connected));
+      device.connect = jest.fn(() => {
+        connected = true;
+        return Promise.resolve(device);
+      });
+      bleManager.cancelDeviceConnection.mockImplementation(() => {
+        connected = false;
+        return Promise.resolve();
+      });
+
+      await transport.acquire({ uuid, expectedProtocol: 'V2' });
+      harness.setShouldRespond(false);
+      await expect(transport.call(uuid, 'Ping', {}, { timeoutMs: 10 })).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleTimeoutError,
+      });
+
+      expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+      expect(connected).toBe(false);
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+      expect(disconnected).toHaveBeenCalledTimes(1);
+      expect(disconnected).toHaveBeenCalledWith({
+        id: uuid,
+        connectId: uuid,
+        name: device.name,
+      });
+
+      harness.setShouldRespond(true);
+      await transport.acquire({ uuid, expectedProtocol: 'V2' });
+      await expect(transport.call(uuid, 'Ping', {})).resolves.toMatchObject({ type: 'Success' });
+      expect(device.connect).toHaveBeenCalledTimes(1);
+      expect(sentSeqs).toEqual([1, 2, 3, 4]);
+      await transport.release(uuid, true);
+    }
+  );
+
+  test('does not disconnect an active Protocol V2 call when a queued call times out', async () => {
+    const harness = createHarness();
+    const { transport, uuid, bleManager } = harness;
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    harness.setShouldRespond(false);
+    const active = transport.call(uuid, 'Ping', {}, { timeoutMs: 1000 }).catch(error => error);
+    await new Promise(resolve => {
+      setImmediate(resolve);
+    });
+
+    try {
+      await expect(transport.call(uuid, 'Ping', {}, { timeoutMs: 10 })).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleTimeoutError,
+      });
+      expect(bleManager.cancelDeviceConnection).not.toHaveBeenCalled();
+      expect(transport.getProtocolType(uuid)).toBe('V2');
+    } finally {
+      await transport.disconnect(uuid);
+      await active;
+    }
+  });
+
+  test('does not disconnect a newer acquire when V2 timeout cleanup waits for the lifecycle lock', async () => {
+    const harness = createHarness();
+    const { transport, uuid, bleManager } = harness;
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    const lifecycle = transport as unknown as {
+      runLifecycleOperation(id: string, operation: () => Promise<void>): Promise<void>;
+      releaseNative(id: string, onclose: boolean): Promise<boolean>;
+    };
+    const gate = createDeferred<void>();
+    const holding = lifecycle.runLifecycleOperation(uuid, () => gate.promise);
+    const reacquiring = transport.acquire({ uuid, expectedProtocol: 'V2' });
+    const invalidated = createDeferred<void>();
+    const releaseNative = lifecycle.releaseNative.bind(lifecycle);
+    jest.spyOn(lifecycle, 'releaseNative').mockImplementationOnce(async (id, onclose) => {
+      const result = await releaseNative(id, onclose);
+      invalidated.resolve();
+      return result;
+    });
+    harness.setShouldRespond(false);
+    const failure = expect(
+      transport.call(uuid, 'Ping', {}, { timeoutMs: 10 })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleTimeoutError,
+    });
+
+    try {
+      await invalidated.promise;
+      harness.setShouldRespond(true);
+      gate.resolve();
+      await holding;
+      await reacquiring;
+      await failure;
+      expect(bleManager.cancelDeviceConnection).not.toHaveBeenCalled();
+      await expect(transport.call(uuid, 'Ping', {})).resolves.toMatchObject({ type: 'Success' });
+    } finally {
+      gate.resolve();
+      await Promise.allSettled([holding, reacquiring, failure]);
+      await transport.release(uuid, true);
+    }
+  });
+
   test('retains the sequence cursor when a new monitor generation is acquired', async () => {
     const { transport, uuid, sentSeqs } = createHarness();
 
@@ -989,9 +2023,17 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   test('uses Android 517 MTU and high connection priority during Protocol V2 high-volume calls', async () => {
     setPlatformOS('android');
     const { transport, uuid, device } = createHarness();
+    device.mtu = 23;
+    device.requestMTU.mockImplementationOnce(() => {
+      device.mtu = 517;
+      return Promise.resolve(device);
+    });
 
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
-    expect(device.requestMTU).toHaveBeenCalledWith(517);
+    expect(device.requestMTU).toHaveBeenCalledWith(
+      517,
+      expect.stringContaining(`${uuid}:mtu:connected:0:`)
+    );
 
     await transport.call(uuid, 'FileWrite', {});
     await transport.call(uuid, 'FileWrite', {});