@onekeyfe/hd-transport-react-native 1.2.0-alpha.99 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.0-alpha.99",
+  "version": "1.2.0",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,11 +20,11 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.0-alpha.99",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.99",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.99",
+    "@onekeyfe/hd-core": "1.2.0",
+    "@onekeyfe/hd-shared": "1.2.0",
+    "@onekeyfe/hd-transport": "1.2.0",
     "@onekeyfe/react-native-ble-utils": "^0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "8924c0e509f84675a2c33c0062166967f5bcb2d0"
+  "gitHead": "cc51df0a415bead21304ad1d8bc92b5312c91344"
 }

package/src/__tests__/bleStaleBond.test.ts

@@ -0,0 +1,39 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { isNativeBleStaleBondError, toBleStaleBondHardwareError } from '../bleStaleBond';
+
+describe('native BLE stale bond mapping', () => {
+  test.each([
+    [
+      { attErrorCode: 15, reason: 'Encryption is insufficient' },
+      HardwareErrorCode.BleDeviceBondError,
+    ],
+    [
+      { attErrorCode: 5, reason: 'GATT_INSUF_AUTHENTICATION' },
+      HardwareErrorCode.BleDeviceBondError,
+    ],
+    [
+      { iosErrorCode: 14, reason: 'Peer removed pairing information' },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+    [
+      { reason: 'peer removed pairing information' },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+    [
+      { message: 'PEER REMOVED PAIRING INFORMATION' },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+  ])('maps %j to %s', (nativeError, errorCode) => {
+    expect(isNativeBleStaleBondError(nativeError)).toBe(true);
+    expect(toBleStaleBondHardwareError(nativeError)).toMatchObject({ errorCode });
+  });
+
+  test('does not treat the generic ATT unlikely error as a stale bond', () => {
+    expect(isNativeBleStaleBondError({ attErrorCode: 14, reason: 'Unlikely error' })).toBe(false);
+  });
+
+  test('does not treat a generic disconnect as a stale bond', () => {
+    expect(isNativeBleStaleBondError({ reason: 'Device disconnected' })).toBe(false);
+  });
+});

package/src/__tests__/connectTimeout.test.ts

@@ -6,6 +6,7 @@ import ReactNativeBleTransport, {
   BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD,
   BLE_CONNECT_TIMEOUT_MS,
   BLE_GATT_SETUP_TIMEOUT_MS,
+  BLE_SETUP_WEDGED_MESSAGE,
 } from '../index';
 import protocolV1Schema from './protocolV1SchemaFixture';
 
@@ -179,7 +180,7 @@ describe('BLE connect timeout', () => {
     expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
   });
 
-  test('repeated stalled connects recreate the BLE manager', async () => {
+  test('repeated stalled connects recreate the BLE manager and stop with PollingTimeout', async () => {
     const { transport, bleManager } = createHarness(
       () =>
         new Promise(() => {
@@ -188,10 +189,12 @@ describe('BLE connect timeout', () => {
     );
     const destroy = jest.fn();
     (bleManager as unknown as { destroy: jest.Mock }).destroy = destroy;
+    const errors: Array<{ errorCode?: unknown; message?: unknown }> = [];
 
     for (let attempt = 0; attempt < BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD; attempt += 1) {
       let settled = false;
-      transport.acquire({ uuid: UUID }).catch(() => {
+      transport.acquire({ uuid: UUID }).catch(error => {
+        errors.push(error);
         settled = true;
       });
       // eslint-disable-next-line no-await-in-loop
@@ -202,6 +205,11 @@ describe('BLE connect timeout', () => {
 
     expect(destroy).toHaveBeenCalledTimes(1);
     expect((transport as unknown as { blePlxManager?: unknown }).blePlxManager).toBeUndefined();
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
+    expect(errors[1]).toMatchObject({
+      errorCode: HardwareErrorCode.PollingTimeout,
+      message: BLE_SETUP_WEDGED_MESSAGE,
+    });
   });
 
   test('a recreated BLE manager starts with fresh timeout budgets for every device', () => {
@@ -224,12 +232,15 @@ describe('BLE connect timeout', () => {
       errorCode: BleErrorCode.OperationTimedOut,
     });
 
-    for (let attempt = 0; attempt < BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD; attempt += 1) {
-      // eslint-disable-next-line no-await-in-loop
-      await expect(
-        (transport as any).connectWithTimeout(UUID, () => Promise.reject(nativeTimeout))
-      ).rejects.toBe(nativeTimeout);
-    }
+    await expect(
+      (transport as any).connectWithTimeout(UUID, () => Promise.reject(nativeTimeout))
+    ).rejects.toBe(nativeTimeout);
+    await expect(
+      (transport as any).connectWithTimeout(UUID, () => Promise.reject(nativeTimeout))
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.PollingTimeout,
+      message: BLE_SETUP_WEDGED_MESSAGE,
+    });
 
     expect(destroy).toHaveBeenCalledTimes(1);
   });

package/src/__tests__/enumerate.test.ts

@@ -32,20 +32,14 @@ jest.mock('../subscribeBleOn', () => ({
 const ONEKEY_SERVICE_UUID = '00000001-0000-1000-8000-00805f9b34fb';
 
 describe('ReactNativeBleTransport iOS discovery', () => {
-  test('filters a bonded Pro2 Find My peripheral while keeping the wallet peripheral', async () => {
+  test('keeps a bonded Pro2 communication peripheral after Find My changes its name', async () => {
     jest.mocked(getConnectedDeviceIds).mockResolvedValueOnce([
       {
-        id: 'find-my-peripheral',
+        id: 'wallet-peripheral',
         name: 'Pro2 6E9E - Find My',
         localName: null,
         serviceUUIDs: [ONEKEY_SERVICE_UUID],
       },
-      {
-        id: 'wallet-peripheral',
-        name: 'Pro2 6E9E',
-        localName: 'Pro2 6E9E',
-        serviceUUIDs: [ONEKEY_SERVICE_UUID],
-      },
     ] as never);
     const blePlxManager = {
       startDeviceScan: jest.fn(),
@@ -60,7 +54,7 @@ describe('ReactNativeBleTransport iOS discovery', () => {
     expect(devices.map(device => device.id)).toEqual(['wallet-peripheral']);
   });
 
-  test('filters a scanned Pro2 Find My peripheral by name when localName is null', async () => {
+  test('uses services to distinguish a Pro2 communication peripheral from Find My', async () => {
     jest.mocked(getConnectedDeviceIds).mockResolvedValueOnce([]);
     const blePlxManager = {
       startDeviceScan: jest.fn((_serviceUUIDs, _options, listener) => {
@@ -69,12 +63,12 @@ describe('ReactNativeBleTransport iOS discovery', () => {
             id: 'find-my-peripheral',
             name: 'Pro2 6E9E - Find My',
             localName: null,
-            serviceUUIDs: [ONEKEY_SERVICE_UUID],
+            serviceUUIDs: ['0000fffd-0000-1000-8000-00805f9b34fb'],
           });
           listener(null, {
             id: 'wallet-peripheral',
-            name: 'Pro2 6E9E',
-            localName: 'Pro2 6E9E',
+            name: 'Pro2 6E9E - Find My',
+            localName: null,
             serviceUUIDs: [ONEKEY_SERVICE_UUID],
           });
         });
@@ -90,6 +84,30 @@ describe('ReactNativeBleTransport iOS discovery', () => {
     expect(devices.map(device => device.id)).toEqual(['wallet-peripheral']);
   });
 
+  test('keeps a service-filtered Pro2 scan result when ble-plx omits service UUIDs', async () => {
+    jest.mocked(getConnectedDeviceIds).mockResolvedValueOnce([]);
+    const blePlxManager = {
+      startDeviceScan: jest.fn((_serviceUUIDs, _options, listener) => {
+        queueMicrotask(() => {
+          listener(null, {
+            id: 'wallet-peripheral',
+            name: 'Pro2 6E9E - Find My',
+            localName: null,
+            serviceUUIDs: null,
+          });
+        });
+      }),
+      stopDeviceScan: jest.fn(),
+    };
+    const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
+    transport.blePlxManager = blePlxManager as never;
+    transport.init({ debug: jest.fn(), error: jest.fn() }, new EventEmitter());
+
+    const devices = await transport.enumerate();
+
+    expect(devices.map(device => device.id)).toEqual(['wallet-peripheral']);
+  });
+
   test('ignores an unnamed scanned advertisement while keeping the named wallet peripheral', async () => {
     jest.mocked(getConnectedDeviceIds).mockResolvedValueOnce([]);
     const blePlxManager = {

package/src/__tests__/protocolReprobe.test.ts

@@ -61,6 +61,30 @@ const detect = (transport: ReactNativeBleTransport) =>
     Promise.resolve()
   ) as Promise<string>;
 
+describe('iOS expected-protocol detection', () => {
+  test('still probes an expected Protocol V2 so USB-priority can surface', async () => {
+    const { transport, probeV1, probeV2 } = createHarness({ v1: false, v2: true });
+
+    await expect(
+      (transport as any).detectProtocol(UUID, 'V2', undefined, () => Promise.resolve())
+    ).resolves.toBe('V2');
+
+    expect(probeV2).toHaveBeenCalledTimes(1);
+    expect(probeV1).not.toHaveBeenCalled();
+  });
+
+  test('keeps the existing iOS shortcut for an expected Protocol V1', async () => {
+    const { transport, probeV1, probeV2 } = createHarness({ v1: false, v2: false });
+
+    await expect(
+      (transport as any).detectProtocol(UUID, 'V1', undefined, () => Promise.resolve())
+    ).resolves.toBe('V1');
+
+    expect(probeV1).not.toHaveBeenCalled();
+    expect(probeV2).not.toHaveBeenCalled();
+  });
+});
+
 describe('protocol re-probe after a known device goes away', () => {
   test('an unknown device still probes both protocols', async () => {
     const { transport, probeV1, probeV2 } = createHarness({ v1: false, v2: false });

package/src/__tests__/protocolV2Link.test.ts

@@ -7,6 +7,7 @@ import transportPackage, {
 import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
 import ReactNativeBleTransport, {
+  BLE_NATIVE_TEARDOWN_TIMEOUT_MS,
   BLE_WRITE_PACKET_TIMEOUT_MS,
   configureProtocolV2BleTuning,
   getFirmwareUploadWriteRetryType,
@@ -108,9 +109,11 @@ const schemas = {
 const createHarness = ({
   deviceName = 'OneKey Pro 2',
   isWritableWithResponse = true,
+  monitorError,
 }: {
   deviceName?: string;
   isWritableWithResponse?: boolean;
+  monitorError?: (Error & { reason?: string; attErrorCode?: number; iosErrorCode?: number }) | null;
 } = {}) => {
   const uuid = 'rn-pro2-id';
   const sentSeqs: number[] = [];
@@ -129,6 +132,9 @@ const createHarness = ({
     isNotifiable: true,
     monitor: jest.fn(callback => {
       notifyCallback = callback;
+      if (monitorError) {
+        queueMicrotask(() => callback(monitorError, null));
+      }
       return { remove: jest.fn() };
     }),
   };
@@ -174,6 +180,8 @@ const createHarness = ({
     devices: jest.fn(() => Promise.resolve([device])),
     connectedDevices: jest.fn(() => Promise.resolve([])),
     cancelTransaction: jest.fn(() => Promise.resolve()),
+    cancelDeviceConnection: jest.fn(() => Promise.resolve()),
+    destroy: jest.fn(),
   };
   const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
   const emitter = new EventEmitter();
@@ -192,6 +200,7 @@ const createHarness = ({
     logger,
     uuid,
     device,
+    bleManager,
     sentSeqs,
     writeCharacteristic,
     setShouldRespond(value: boolean) {
@@ -401,7 +410,23 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.release(uuid, true);
   });
 
-  test('actively probes Protocol V2 on iOS when only a name-derived hint is available', async () => {
+  test('keeps native stale-bond write mapping out of Protocol V1 calls', async () => {
+    const { transport, uuid, writeCharacteristic } = createV1Harness();
+    const nativeError = Object.assign(new Error('Encryption is insufficient'), {
+      attErrorCode: 15,
+      reason: 'Encryption is insufficient',
+    });
+
+    await transport.acquire({ uuid, expectedProtocol: 'V1' });
+    writeCharacteristic.writeWithResponse.mockRejectedValueOnce(nativeError);
+
+    await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 50 })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleWriteCharacteristicError,
+    });
+    await transport.release(uuid, true);
+  });
+
+  test('detects Protocol V2 on iOS without using the BLE name as a protocol hint', async () => {
     const { transport, uuid, device, sentSeqs, writeCharacteristic } = createHarness({
       deviceName: 'Pro2 6E9E',
     });
@@ -411,15 +436,271 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       protocolType: 'V2',
     });
     expect(device.requestMTU).toHaveBeenCalledWith(247);
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse.mock.calls.length).toBeGreaterThan(1);
 
     await expect(
       transport.call(uuid, 'Ping', { message: 'first-core-command' })
     ).resolves.toBeDefined();
-    expect(sentSeqs).toEqual([1, 2]);
+    expect(sentSeqs.filter(seq => seq > 0)).toEqual([1, 2]);
+    await transport.release(uuid, true);
+  });
+
+  test('physically refreshes an uncached Protocol V2 firmware install link without Ping', async () => {
+    const { transport, uuid, device, bleManager, writeCharacteristic } = createHarness();
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+    (transport as any).sessionProtocols.set(uuid, 'V2');
+    device.connect = jest.fn().mockResolvedValue(device);
+    device.isConnected.mockResolvedValueOnce(false);
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(device.cancelConnection).not.toHaveBeenCalled();
+    expect(device.connect).toHaveBeenCalled();
+    expect(probeProtocolV2).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    expect(transport.getProtocolType(uuid)).toBe('V2');
+    await transport.release(uuid, true);
+  });
+
+  test('refreshes a cached firmware install connection instead of trusting GATT state', async () => {
+    const { transport, uuid, device, bleManager, writeCharacteristic } = createHarness();
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    device.connect = jest.fn().mockResolvedValue(device);
+    device.isConnected.mockResolvedValueOnce(false);
+    writeCharacteristic.writeWithResponse.mockClear();
+    writeCharacteristic.writeWithoutResponse.mockClear();
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(device.cancelConnection).toHaveBeenCalled();
+    expect(device.connect).toHaveBeenCalled();
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
     await transport.release(uuid, true);
   });
 
+  test('rejects no-probe acquire before the BLE endpoint has confirmed a protocol', async () => {
+    const { transport, uuid } = createHarness();
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).rejects.toThrow('previously confirmed protocol');
+
+    expect(transport.getProtocolType(uuid)).toBeUndefined();
+  });
+
+  test('keeps confirmed V2 authorization across a BLE manager reset', async () => {
+    const { transport, uuid, device, bleManager, writeCharacteristic } = createHarness();
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+
+    (transport as any).resetPlxManager();
+    transport.blePlxManager = bleManager as any;
+    device.connect = jest.fn().mockResolvedValue(device);
+    device.isConnected.mockResolvedValueOnce(false);
+    writeCharacteristic.writeWithResponse.mockClear();
+    writeCharacteristic.writeWithoutResponse.mockClear();
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
+  test.each(['ios', 'android'] as const)(
+    'keeps a first expected Protocol V2 probe miss retryable on %s',
+    async platform => {
+      setPlatformOS(platform);
+      const { transport, uuid, device } = createHarness();
+      jest.spyOn(transport as any, 'probeProtocolV2').mockResolvedValue(false);
+
+      await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.RuntimeError,
+      });
+
+      expect(device.cancelConnection).not.toHaveBeenCalled();
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+    }
+  );
+
+  test.each(['ios', 'android'] as const)(
+    'keeps a second expected Protocol V2 probe miss retryable on %s',
+    async platform => {
+      setPlatformOS(platform);
+      const { transport, uuid, device } = createHarness();
+      jest.spyOn(transport as any, 'probeProtocolV2').mockResolvedValue(false);
+
+      await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.RuntimeError,
+      });
+      await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.RuntimeError,
+      });
+
+      expect(device.cancelConnection).not.toHaveBeenCalled();
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+    }
+  );
+
+  test.each([
+    [
+      'Encryption is insufficient',
+      { reason: 'Encryption is insufficient', attErrorCode: 15 },
+      HardwareErrorCode.BleDeviceBondError,
+    ],
+    [
+      'Peer removed pairing information',
+      { reason: 'Peer removed pairing information', iosErrorCode: 14 },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+  ] as const)(
+    'fails Protocol V2 acquire immediately on %s instead of waiting for Ping',
+    async (_label, nativeError, errorCode) => {
+      const { transport, uuid, device } = createHarness({
+        monitorError: Object.assign(new Error(nativeError.reason), nativeError),
+      });
+      const probe = jest.spyOn(transport as any, 'probeProtocolV2');
+
+      await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+        errorCode,
+      });
+
+      expect(probe).not.toHaveBeenCalled();
+      expect(device.cancelConnection).toHaveBeenCalled();
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+    }
+  );
+
+  test.each(['ios', 'android'] as const)(
+    'keeps a confirmed Protocol V2 probe miss retryable on %s without native bond evidence',
+    async platform => {
+      setPlatformOS(platform);
+      const { transport, uuid, device } = createHarness();
+      await transport.acquire({ uuid, expectedProtocol: 'V2' });
+      await transport.release(uuid, true);
+      jest.spyOn(transport as any, 'probeProtocolV2').mockResolvedValue(false);
+
+      await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.RuntimeError,
+      });
+
+      expect(device.cancelConnection).not.toHaveBeenCalled();
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+    }
+  );
+
+  test('waits for an in-flight release before reacquiring the same device', async () => {
+    const { transport, uuid } = createHarness();
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    const releaseGate = createDeferred<void>();
+    const releaseStarted = createDeferred<void>();
+    const { protocolV2Links } = transport as any;
+    const invalidateLink = protocolV2Links.invalidateLink.bind(protocolV2Links);
+    jest
+      .spyOn(protocolV2Links, 'invalidateLink')
+      .mockImplementationOnce(async (...args: unknown[]) => {
+        releaseStarted.resolve();
+        await releaseGate.promise;
+        return invalidateLink(...args);
+      });
+
+    const release = transport.release(uuid, true);
+    await releaseStarted.promise;
+    let reacquired = false;
+    const acquire = transport.acquire({ uuid, expectedProtocol: 'V2' }).then(result => {
+      reacquired = true;
+      return result;
+    });
+
+    await Promise.resolve();
+    expect(reacquired).toBe(false);
+
+    releaseGate.resolve();
+    await release;
+    await expect(acquire).resolves.toEqual({ uuid, protocolType: 'V2' });
+    await expect(transport.call(uuid, 'Ping', { message: 'after-release' })).resolves.toMatchObject(
+      {
+        type: 'Success',
+        message: { message: 'ok' },
+      }
+    );
+  });
+
+  test(
+    'releases the lifecycle queue when native teardown never settles',
+    async () => {
+      const { transport, uuid, device, bleManager } = createHarness();
+      await transport.acquire({ uuid, expectedProtocol: 'V2' });
+      const otherUuid = 'rn-pro2-other-id';
+      const otherDevice = {
+        ...device,
+        id: otherUuid,
+        name: 'OneKey Pro 2 Other',
+        localName: 'OneKey Pro 2 Other',
+      };
+      await (transport as any).installTransportForAcquire(otherUuid, otherDevice);
+      (transport as any).deviceProtocol.set(otherUuid, 'V2');
+      const disconnectEvents: Array<{ connectId: string }> = [];
+      transport.emitter?.on(TRANSPORT_EVENT.DEVICE_DISCONNECT, event => {
+        disconnectEvents.push(event);
+      });
+      const stalledNativeCleanup = createDeferred<void>();
+      bleManager.cancelTransaction
+        .mockImplementationOnce(() => stalledNativeCleanup.promise)
+        .mockResolvedValue(undefined);
+      const resetPlxManager = jest.spyOn(transport as any, 'resetPlxManager');
+      const nextLifecycleOperation = jest.fn().mockResolvedValue('next-operation');
+
+      const release = transport.release(uuid, true);
+      const nextOperation = (transport as any).runLifecycleOperation(uuid, nextLifecycleOperation);
+
+      await expect(release).resolves.toBe(true);
+      await expect(nextOperation).resolves.toBe('next-operation');
+      expect(resetPlxManager).toHaveBeenCalledTimes(1);
+      expect(nextLifecycleOperation).toHaveBeenCalledTimes(1);
+      expect(disconnectEvents).toContainEqual(expect.objectContaining({ connectId: otherUuid }));
+      expect(() => (transport as any).getCachedTransport(otherUuid)).toThrow();
+
+      await (transport as any).installTransportForAcquire(uuid, device);
+      (transport as any).deviceProtocol.set(uuid, 'V2');
+
+      stalledNativeCleanup.resolve();
+      await Promise.resolve();
+      await expect(
+        transport.call(uuid, 'Ping', { message: 'after-stale-cleanup' })
+      ).resolves.toMatchObject({
+        type: 'Success',
+        message: { message: 'ok' },
+      });
+    },
+    BLE_NATIVE_TEARDOWN_TIMEOUT_MS + 5_000
+  );
+
   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
@@ -625,7 +906,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
     await transport.call(uuid, 'Ping', { message: 'first-core-command' });
 
-    expect(sentSeqs).toEqual([1]);
+    expect(sentSeqs).toEqual([1, 2]);
     await transport.release(uuid, true);
   });
 
@@ -660,7 +941,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
     await transport.call(uuid, 'Ping', { message: 'second-generation' });
 
-    expect(sentSeqs).toEqual([1, 2]);
+    expect(sentSeqs).toEqual([1, 2, 3, 4]);
     await transport.release(uuid, true);
   });
 
@@ -670,12 +951,12 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
     const releaseNative = jest.spyOn(transport as any, 'releaseNative');
     expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
-    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
 
     await transport.call(uuid, 'DeviceInfoGet', {});
     await transport.call(uuid, 'ProtocolInfoRequest', {});
 
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(2);
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(3);
     expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
     expect(releaseNative).not.toHaveBeenCalled();
 
@@ -690,7 +971,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.call(uuid, 'FileWrite', {});
     await transport.call(uuid, 'FileWrite', {});
     expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(2);
-    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
     expect(
       logger.debug.mock.calls.filter(
         ([message]) =>
@@ -723,7 +1004,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
 
     await transport.call(uuid, 'FileWrite', {}, { writeWithResponse: true });
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(2);
     expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
     await transport.release(uuid, true);
   });
@@ -737,7 +1018,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.call(uuid, 'ProtocolInfoRequest', {});
 
     expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
-    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(2);
     await transport.release(uuid, true);
   });