@onekeyfe/hd-transport-react-native 1.2.3-alpha.1 → 1.2.3-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.3-alpha.1",
+  "version": "1.2.3-alpha.10",
   "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.3-alpha.1",
-    "@onekeyfe/hd-shared": "1.2.3-alpha.1",
-    "@onekeyfe/hd-transport": "1.2.3-alpha.1",
-    "@onekeyfe/react-native-ble-utils": "^0.1.6",
+    "@onekeyfe/hd-core": "1.2.3-alpha.10",
+    "@onekeyfe/hd-shared": "1.2.3-alpha.10",
+    "@onekeyfe/hd-transport": "1.2.3-alpha.10",
+    "@onekeyfe/react-native-ble-utils": "0.1.9",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "fd4221863c00240fc4870fc50f8c517d97426de2"
+  "gitHead": "2295285a846281941c21955684281446f587d993"
 }

package/src/BleManager.ts

@@ -1,12 +1,26 @@
 import BleUtils from '@onekeyfe/react-native-ble-utils';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
+import { onBleKeyMissing, startBleKeyMissingTracking } from './bleKeyMissing';
 import { bleLogger } from './logger';
 
 import type { Peripheral } from '@onekeyfe/react-native-ble-utils';
 
 const Logger = bleLogger;
 
+// Android BluetoothDevice.EXTRA_UNBOND_REASON values.
+const bondFailureReasons: Record<number, string> = {
+  1: 'authentication_failed',
+  2: 'rejected',
+  3: 'canceled',
+  4: 'device_unreachable',
+  5: 'discovery_in_progress',
+  6: 'timeout',
+  7: 'repeated_attempts',
+  8: 'remote_canceled',
+  9: 'removed',
+};
+
 /**
  * get the device basic info of connected devices
  * @param serviceUuids
@@ -19,20 +33,104 @@ export const getBondedDevices = () => BleUtils.getBondedPeripherals();
 
 export const pairDevice = (macAddress: string) => BleUtils.pairDevice(macAddress);
 
-export const onDeviceBondState = (bleMacAddress: string): Promise<Peripheral | undefined> =>
+/**
+ * Android replaces a bond as BONDING -> NONE, then NONE -> BONDING within milliseconds.
+ * The window covers slow broadcast delivery before the first half counts as a failure.
+ */
+export const SYSTEM_BONDING_RESTART_WINDOW_MS = 1500;
+
+export type DeviceBondStateOptions = {
+  /**
+   * The system, not this transport, started the bonding in progress. Android 16+ re-pairs
+   * by itself after it detects a lost bond, and a successful re-pair replaces the old bond
+   * instead of going straight to BONDED.
+   */
+  systemInitiated?: boolean;
+};
+
+const createBondFailureError = (bondState: Peripheral['bondState']) => {
+  const nativeReason =
+    'reason' in bondState && typeof bondState.reason === 'number' ? bondState.reason : undefined;
+  const reason =
+    nativeReason === undefined ? 'unknown' : bondFailureReasons[nativeReason] ?? 'unknown';
+  const params = {
+    phase: 'bond',
+    reason,
+    ...(nativeReason === undefined ? {} : { nativeReason }),
+  };
+  if (reason === 'timeout') {
+    // Connection timeouts are retried by Core; pairing requires a new user attempt.
+    return ERRORS.TypedError(
+      HardwareErrorCode.BleDeviceNotBonded,
+      'Bluetooth pairing timed out',
+      params
+    );
+  }
+  if (reason === 'canceled') {
+    return ERRORS.TypedError(
+      HardwareErrorCode.BleDeviceBondedCanceled,
+      'Bluetooth pairing canceled',
+      params
+    );
+  }
+  return ERRORS.TypedError(
+    HardwareErrorCode.BleDeviceNotBonded,
+    'Bluetooth pairing failed',
+    params
+  );
+};
+
+export const onDeviceBondState = (
+  bleMacAddress: string,
+  signal?: AbortSignal,
+  options?: DeviceBondStateOptions
+): Promise<Peripheral | undefined> =>
   new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected));
+      return;
+    }
+    let pendingFailure: ReturnType<typeof setTimeout> | undefined;
     const cleanup = () => {
       if (timeout) {
         clearTimeout(timeout);
       }
+      if (pendingFailure) clearTimeout(pendingFailure);
       if (cleanupListener) cleanupListener();
+      cleanupKeyMissing?.();
+      signal?.removeEventListener('abort', onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected));
     };
 
+    signal?.addEventListener('abort', onAbort, { once: true });
+
     const timeout = setTimeout(() => {
       cleanup();
-      reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded'));
+      reject(
+        ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', {
+          phase: 'bond',
+          reason: 'timeout',
+        })
+      );
     }, 60 * 1000);
 
+    // A failed system re-pair restores the old bond, so it also ends in BONDED. Key
+    // missing is what tells it apart from a bond that now works.
+    const cleanupKeyMissing = startBleKeyMissingTracking()
+      ? onBleKeyMissing(bleMacAddress, () => {
+          cleanup();
+          reject(
+            ERRORS.TypedError(HardwareErrorCode.BleBondInvalid, undefined, {
+              phase: 'bond',
+              reason: 'key_missing',
+            })
+          );
+        })
+      : undefined;
+
     const cleanupListener = BleUtils.onDeviceBondState(peripheral => {
       if (peripheral.id?.toLowerCase() !== bleMacAddress.toLowerCase()) {
         return;
@@ -40,14 +138,24 @@ export const onDeviceBondState = (bleMacAddress: string): Promise<Peripheral | u
       const { bondState } = peripheral;
 
       const hasBonded = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_BONDED';
-      const hasCanceled = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_NONE';
+      const hasFailed = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_NONE';
+      const hasRestarted = bondState.preState === 'BOND_NONE' && bondState.state === 'BOND_BONDING';
       Logger.debug('onDeviceBondState bondState:', bondState);
       if (hasBonded) {
         cleanup();
         resolve(peripheral);
-      } else if (hasCanceled) {
+      } else if (hasRestarted && pendingFailure) {
+        clearTimeout(pendingFailure);
+        pendingFailure = undefined;
+      } else if (hasFailed && options?.systemInitiated) {
+        if (pendingFailure) clearTimeout(pendingFailure);
+        pendingFailure = setTimeout(() => {
+          cleanup();
+          reject(createBondFailureError(bondState));
+        }, SYSTEM_BONDING_RESTART_WINDOW_MS);
+      } else if (hasFailed) {
         cleanup();
-        reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceBondedCanceled, 'bonding canceled'));
+        reject(createBondFailureError(bondState));
       }
     });
   });

package/src/__tests__/androidEncryption.test.ts

@@ -0,0 +1,482 @@
+import EventEmitter from 'events';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport, {
+  ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS,
+  ANDROID_KEY_MISSING_GRACE_MS,
+  ANDROID_SYSTEM_REPAIR_TIMEOUT_MS,
+} from '../index';
+import {
+  HCI_PIN_OR_KEY_MISSING,
+  stopBleEncryptionTracking,
+  waitForAndroidLinkEncryption,
+} from '../bleEncryption';
+import { stopBleKeyMissingTracking } from '../bleKeyMissing';
+import protocolV1Schema from './protocolV1SchemaFixture';
+
+type EncryptionEvent = { id: string; status: number; enabled: boolean };
+
+let mockSupported = true;
+let mockPairResult: { bonded: boolean; bonding: boolean; initiated?: boolean } = {
+  bonded: true,
+  bonding: false,
+  initiated: false,
+};
+let mockEmitEncryption: ((event: EncryptionEvent) => void) | undefined;
+let mockEmitAclDisconnected: ((event: { id: string }) => void) | undefined;
+let mockEmitKeyMissing: ((event: { id: string }) => void) | undefined;
+let mockEmitBondState: ((peripheral: unknown) => void) | undefined;
+
+jest.mock(
+  'react-native',
+  () => ({
+    Platform: { OS: 'android', select: (spec: Record<string, unknown>) => spec.android },
+    PermissionsAndroid: {
+      PERMISSIONS: {},
+      RESULTS: {},
+      request: jest.fn(),
+      requestMultiple: jest.fn(),
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('react-native-ble-plx', () => ({
+  BleATTErrorCode: { InvalidHandle: 1 },
+  BleError: Error,
+  BleErrorCode: { DeviceDisconnected: 201, OperationStartFailed: 601 },
+  BleManager: jest.fn(),
+  ScanMode: { LowLatency: 2 },
+}));
+
+jest.mock('@onekeyfe/react-native-ble-utils', () => ({
+  __esModule: true,
+  default: {
+    getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
+    getBondedPeripherals: jest.fn(() => Promise.resolve([])),
+    pairDevice: jest.fn(() => Promise.resolve(mockPairResult)),
+    supportsDeviceKeyMissing: jest.fn(() => mockSupported),
+    onDeviceKeyMissing: jest.fn((callback: (event: { id: string }) => void) => {
+      mockEmitKeyMissing = callback;
+      return () => {
+        mockEmitKeyMissing = undefined;
+      };
+    }),
+    supportsDeviceEncryptionChange: jest.fn(() => mockSupported),
+    onDeviceEncryptionChange: jest.fn((callback: (event: EncryptionEvent) => void) => {
+      mockEmitEncryption = callback;
+      return () => {
+        mockEmitEncryption = undefined;
+      };
+    }),
+    onDeviceAclDisconnected: jest.fn((callback: (event: { id: string }) => void) => {
+      mockEmitAclDisconnected = callback;
+      return () => {
+        mockEmitAclDisconnected = undefined;
+      };
+    }),
+    onDeviceBondState: jest.fn((callback: (peripheral: unknown) => void) => {
+      mockEmitBondState = callback;
+      return () => {
+        mockEmitBondState = undefined;
+      };
+    }),
+  },
+}));
+
+const UUID = 'CC:06:1C:FD:48:E9';
+const OTHER_UUID = 'E9:B9:F4:DD:DE:CD';
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+const advance = async (ms: number) => {
+  jest.advanceTimersByTime(ms);
+  await flush();
+};
+
+const encrypted = (id = UUID) => mockEmitEncryption?.({ id, status: 0, enabled: true });
+const keyMissing = (id = UUID) =>
+  mockEmitEncryption?.({ id, status: HCI_PIN_OR_KEY_MISSING, enabled: false });
+
+const settle = <T>(promise: Promise<T>) => {
+  const outcome: { value?: T; error?: { errorCode?: unknown }; done: boolean } = { done: false };
+  promise.then(
+    value => {
+      outcome.value = value;
+      outcome.done = true;
+    },
+    error => {
+      outcome.error = error;
+      outcome.done = true;
+    }
+  );
+  return outcome;
+};
+
+const waitFor = ({
+  linkStartedAt = Date.now(),
+  signal,
+}: { linkStartedAt?: number; signal?: AbortSignal } = {}) =>
+  settle(
+    waitForAndroidLinkEncryption({
+      deviceId: UUID,
+      linkStartedAt,
+      resultTimeoutMs: ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS,
+      repairTimeoutMs: ANDROID_SYSTEM_REPAIR_TIMEOUT_MS,
+      keyMissingGraceMs: ANDROID_KEY_MISSING_GRACE_MS,
+      signal,
+    })
+  );
+
+describe('Android link encryption', () => {
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+    mockSupported = true;
+    mockPairResult = { bonded: true, bonding: false, initiated: false };
+  });
+
+  afterEach(() => {
+    stopBleEncryptionTracking();
+    stopBleKeyMissingTracking();
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  describe('first result of a new link', () => {
+    test('resolves when the stored bond encrypts the link', async () => {
+      const outcome = waitFor();
+      await flush();
+      expect(outcome.done).toBe(false);
+
+      encrypted();
+      await flush();
+
+      expect(outcome.value).toBe('encrypted');
+    });
+
+    test('uses a result that arrived before the wait started', async () => {
+      const linkStartedAt = Date.now();
+      waitFor({ linkStartedAt });
+      await flush();
+      encrypted();
+      await flush();
+
+      const outcome = waitFor({ linkStartedAt });
+      await flush();
+
+      expect(outcome.value).toBe('encrypted');
+    });
+
+    test('proceeds as before when no result arrives in time', async () => {
+      const outcome = waitFor();
+      await advance(ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS - 1);
+      expect(outcome.done).toBe(false);
+
+      await advance(1);
+
+      expect(outcome.value).toBe('unresolved');
+    });
+
+    test('does not wait when the platform cannot report the result', async () => {
+      mockSupported = false;
+      const outcome = waitFor();
+      await flush();
+
+      expect(outcome.value).toBe('unresolved');
+    });
+
+    test('proceeds when encryption fails for a reason other than a lost bond', async () => {
+      const outcome = waitFor();
+      await flush();
+      mockEmitEncryption?.({ id: UUID, status: 0x08, enabled: false });
+      await flush();
+
+      expect(outcome.value).toBe('unresolved');
+    });
+
+    test('proceeds when the link drops before any result', async () => {
+      const outcome = waitFor();
+      await flush();
+      mockEmitAclDisconnected?.({ id: UUID });
+      await flush();
+
+      expect(outcome.value).toBe('unresolved');
+    });
+
+    test('ignores results for another device', async () => {
+      const outcome = waitFor();
+      await flush();
+      encrypted(OTHER_UUID);
+      await flush();
+      expect(outcome.done).toBe(false);
+
+      encrypted(UUID.toLowerCase());
+      await flush();
+
+      expect(outcome.value).toBe('encrypted');
+    });
+  });
+
+  describe('reused link', () => {
+    test('does not wait on a link that is still up and was encrypted earlier', async () => {
+      waitFor();
+      await flush();
+      encrypted();
+      await advance(1000);
+
+      const outcome = waitFor();
+      await flush();
+
+      expect(outcome.value).toBe('already-encrypted');
+    });
+
+    test('waits again once the earlier link has dropped', async () => {
+      waitFor();
+      await flush();
+      encrypted();
+      await advance(1000);
+      mockEmitAclDisconnected?.({ id: UUID });
+      await advance(1000);
+
+      const outcome = waitFor();
+      await flush();
+      expect(outcome.done).toBe(false);
+
+      keyMissing();
+      await flush();
+
+      expect(outcome.done).toBe(false);
+    });
+  });
+
+  describe('lost bond', () => {
+    test('holds until the system re-pairs on the same link', async () => {
+      const outcome = waitFor();
+      await flush();
+      keyMissing();
+      await advance(10_000);
+      expect(outcome.done).toBe(false);
+
+      encrypted();
+      await flush();
+
+      expect(outcome.value).toBe('re-paired');
+    });
+
+    test('reports an invalid bond when the system says re-pairing failed', async () => {
+      const outcome = waitFor();
+      await flush();
+      keyMissing();
+      await advance(5000);
+      mockEmitKeyMissing?.({ id: UUID });
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+    });
+
+    test('reports an invalid bond when the drop is followed by key missing', async () => {
+      const outcome = waitFor();
+      await flush();
+      keyMissing();
+      await advance(5000);
+      mockEmitAclDisconnected?.({ id: UUID });
+      await advance(ANDROID_KEY_MISSING_GRACE_MS - 100);
+      mockEmitKeyMissing?.({ id: UUID });
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+    });
+
+    test('reports a disconnect when the link drops without key missing', async () => {
+      const outcome = waitFor();
+      await flush();
+      keyMissing();
+      await advance(5000);
+      mockEmitAclDisconnected?.({ id: UUID });
+      await advance(ANDROID_KEY_MISSING_GRACE_MS);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceDisconnected);
+    });
+
+    test('gives up when re-pairing never finishes', async () => {
+      const outcome = waitFor();
+      await flush();
+      keyMissing();
+      await advance(ANDROID_SYSTEM_REPAIR_TIMEOUT_MS);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('stops waiting when the transport is stopped', async () => {
+      const controller = new AbortController();
+      const outcome = waitFor({ signal: controller.signal });
+      await flush();
+      keyMissing();
+      await flush();
+
+      controller.abort();
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceDisconnected);
+      expect(jest.getTimerCount()).toBe(0);
+    });
+  });
+
+  describe('acquire', () => {
+    function createHarness() {
+      const monitor = jest.fn(() => ({ remove: jest.fn() }));
+      const writeCharacteristic = {
+        uuid: '00000002-0000-1000-8000-00805f9b34fb',
+        isWritableWithoutResponse: true,
+        writeWithoutResponse: jest.fn(() => Promise.resolve()),
+      };
+      const notifyCharacteristic = {
+        uuid: '00000003-0000-1000-8000-00805f9b34fb',
+        isNotifiable: true,
+        monitor,
+      };
+      const device = {
+        id: UUID,
+        name: 'Pro 2 48E9',
+        localName: 'Pro 2 48E9',
+        mtu: 247,
+        serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
+        isConnected: jest.fn(() => Promise.resolve(true)),
+        cancelConnection: jest.fn(() => Promise.resolve()),
+        discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
+        characteristicsForService: jest.fn(() =>
+          Promise.resolve([writeCharacteristic, notifyCharacteristic])
+        ),
+        services: jest.fn(() => Promise.resolve([])),
+        onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+      };
+      const transport = new ReactNativeBleTransport({});
+      (transport as any).blePlxManager = {
+        devices: jest.fn(() => Promise.resolve([device])),
+        connectedDevices: jest.fn(() => Promise.resolve([])),
+        cancelTransaction: jest.fn(() => Promise.resolve()),
+        cancelDeviceConnection: jest.fn(() => Promise.resolve()),
+        onDeviceDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+        onStateChange: jest.fn((listener: (state: string) => void) => {
+          setImmediate(() => listener('PoweredOn'));
+          return { remove: jest.fn() };
+        }),
+        state: jest.fn(() => Promise.resolve('PoweredOn')),
+      };
+      transport.init(
+        { debug: jest.fn(), error: jest.fn(), warn: jest.fn() } as any,
+        new EventEmitter()
+      );
+      transport.configure(protocolV1Schema);
+      return { transport, monitor, device };
+    }
+
+    /** Drives acquire up to the point where it waits for the link's encryption result. */
+    async function reachGate(device: { characteristicsForService: jest.Mock }) {
+      for (let i = 0; i < 100 && device.characteristicsForService.mock.calls.length === 0; i += 1) {
+        // eslint-disable-next-line no-await-in-loop
+        await advance(10);
+      }
+      expect(device.characteristicsForService).toHaveBeenCalled();
+      await advance(10);
+    }
+
+    async function runUntil(done: () => boolean, maxMs = 2000) {
+      for (let elapsed = 0; elapsed < maxMs && !done(); elapsed += 50) {
+        // eslint-disable-next-line no-await-in-loop
+        await advance(50);
+      }
+    }
+
+    test('subscribes to notifications only after a bonded link is encrypted', async () => {
+      const { transport, monitor, device } = createHarness();
+      const outcome = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      await reachGate(device);
+      await advance(ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS / 2);
+      expect(monitor).not.toHaveBeenCalled();
+
+      encrypted();
+      await runUntil(() => outcome.done);
+
+      expect(outcome.error).toBeUndefined();
+      expect(outcome.value).toEqual({ uuid: UUID, protocolType: 'V1' });
+      expect(monitor).toHaveBeenCalledTimes(1);
+      await transport.release(UUID, true);
+    });
+
+    test('keeps GATT idle while the system re-pairs a lost bond', async () => {
+      const { transport, monitor, device } = createHarness();
+      const outcome = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      await reachGate(device);
+      keyMissing();
+      await advance(8000);
+      expect(monitor).not.toHaveBeenCalled();
+      expect(outcome.done).toBe(false);
+
+      encrypted();
+      await runUntil(() => outcome.done);
+
+      expect(outcome.value).toEqual({ uuid: UUID, protocolType: 'V1' });
+      expect(monitor).toHaveBeenCalledTimes(1);
+      await transport.release(UUID, true);
+    });
+
+    test('fails as an invalid bond when the system re-pairing fails', async () => {
+      const { transport, monitor, device } = createHarness();
+      const outcome = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      await reachGate(device);
+      keyMissing();
+      await advance(5000);
+      mockEmitKeyMissing?.({ id: UUID });
+      await runUntil(() => outcome.done);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+      expect(monitor).not.toHaveBeenCalled();
+    });
+
+    test('does not wait for a bond created by this acquire', async () => {
+      mockPairResult = { bonded: false, bonding: true, initiated: true };
+      const { transport, monitor } = createHarness();
+      const outcome = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      for (let i = 0; i < 100 && !mockEmitBondState; i += 1) {
+        // eslint-disable-next-line no-await-in-loop
+        await advance(10);
+      }
+      mockEmitBondState?.({
+        id: UUID,
+        advertising: {},
+        bondState: { preState: 'BOND_BONDING', state: 'BOND_BONDED' },
+      });
+      await runUntil(() => outcome.done);
+
+      expect(outcome.value).toEqual({ uuid: UUID, protocolType: 'V1' });
+      expect(monitor).toHaveBeenCalledTimes(1);
+      await transport.release(UUID, true);
+    });
+
+    test('reuses a link that notifications already worked on without waiting', async () => {
+      const { transport, monitor, device } = createHarness();
+      // No result arrives: the link was already up before tracking could observe it.
+      const first = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      await reachGate(device);
+      await advance(ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS - 100);
+      expect(monitor).not.toHaveBeenCalled();
+      await runUntil(() => first.done);
+      expect(first.value).toEqual({ uuid: UUID, protocolType: 'V1' });
+      await transport.release(UUID, true);
+      monitor.mockClear();
+      device.characteristicsForService.mockClear();
+
+      const second = settle(transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }));
+      await reachGate(device);
+
+      expect(monitor).toHaveBeenCalledTimes(1);
+      await runUntil(() => second.done);
+      expect(second.value).toEqual({ uuid: UUID, protocolType: 'V1' });
+      await transport.release(UUID, true);
+    });
+  });
+});