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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.0-alpha.56",
+  "version": "1.2.0-alpha.62",
   "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.56",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.56",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.56",
+    "@onekeyfe/hd-core": "1.2.0-alpha.62",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.62",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.62",
     "@onekeyfe/react-native-ble-utils": "^0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "2c472748d67072307c21f8d33bc021cf18fe2ad7"
+  "gitHead": "f38f4fc8bf05aea42a4da5b2bd633544597ad958"
 }

package/src/BleTransport.ts

@@ -33,6 +33,6 @@ export default class BleTransport {
   }
 
   async writeWithRetry(data: string): Promise<void> {
-    await this.writeCharacteristic.writeWithResponse(data);
+    await this.writeCharacteristic.writeWithoutResponse(data);
   }
 }

package/src/__tests__/BleTransport.test.ts

@@ -24,7 +24,7 @@ describe('BleTransport side-effecting writes', () => {
       errorCode: BleErrorCode.DeviceDisconnected,
     });
     const writeCharacteristic = {
-      writeWithResponse: jest.fn(() => Promise.reject(error)),
+      writeWithoutResponse: jest.fn(() => Promise.reject(error)),
     };
     const device = {
       id: 'classic-id',
@@ -35,7 +35,7 @@ describe('BleTransport side-effecting writes', () => {
 
     await expect(transport.writeWithRetry('payload')).rejects.toBe(error);
 
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
     expect(device.connect).not.toHaveBeenCalled();
   });
 });

package/src/__tests__/connectTimeout.test.ts

@@ -0,0 +1,192 @@
+import { EventEmitter } from 'events';
+
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport, {
+  BLE_CONNECT_TIMEOUT_MS,
+  BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD,
+} from '../index';
+
+import messages from '@onekeyfe/hd-transport/messages.json';
+
+jest.mock(
+  'react-native',
+  () => ({
+    Platform: { OS: 'ios', select: (spec: Record<string, unknown>) => spec.ios },
+    PermissionsAndroid: {
+      PERMISSIONS: {},
+      RESULTS: {},
+      request: jest.fn(),
+      requestMultiple: jest.fn(),
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('react-native-ble-plx', () => ({
+  BleATTErrorCode: { InvalidHandle: 1, UnlikelyError: 14 },
+  BleError: Error,
+  BleErrorCode: {
+    DeviceDisconnected: 201,
+    OperationStartFailed: 601,
+    DeviceMTUChangeFailed: 401,
+    OperationCancelled: 2,
+    DeviceAlreadyConnected: 203,
+  },
+  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()),
+  },
+}));
+
+const UUID = 'stalled-connect-device';
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+async function advanceUntil(settled: () => boolean, totalMs: number, stepMs = 250) {
+  for (let elapsed = 0; elapsed < totalMs; elapsed += stepMs) {
+    jest.advanceTimersByTime(stepMs);
+    // eslint-disable-next-line no-await-in-loop
+    await flush();
+    if (settled()) return;
+  }
+  throw new Error(`fake timers exhausted after ${totalMs}ms before the connect settled`);
+}
+
+/** A device whose native connect() never settles — the observed iOS failure mode. */
+function createHarness(connectImpl: () => Promise<unknown>) {
+  const connect = jest.fn(connectImpl);
+  const device = {
+    id: UUID,
+    name: 'OneKey Classic',
+    localName: 'OneKey Classic',
+    serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
+    isConnected: jest.fn(() => Promise.resolve(false)),
+    cancelConnection: jest.fn(() => Promise.resolve()),
+    connect,
+    onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+  };
+  const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
+  const bleManager = {
+    devices: jest.fn(() => Promise.resolve([device])),
+    connectedDevices: jest.fn(() => Promise.resolve([])),
+    connectToDevice: jest.fn(connectImpl),
+    cancelTransaction: jest.fn(() => Promise.resolve()),
+    cancelDeviceConnection: jest.fn(() => Promise.resolve()),
+    onStateChange: jest.fn((listener: (state: string) => void) => {
+      // Dispatch asynchronously: subscribeBleOn wires its own cleanup after
+      // registering, so a synchronous callback would run before it is ready.
+      setImmediate(() => listener('PoweredOn'));
+      return { remove: jest.fn() };
+    }),
+    state: jest.fn(() => Promise.resolve('PoweredOn')),
+    startDeviceScan: jest.fn(),
+    stopDeviceScan: jest.fn(),
+  };
+  (transport as any).blePlxManager = bleManager;
+  transport.init(
+    { debug: jest.fn(), error: jest.fn(), warn: jest.fn() } as any,
+    new EventEmitter()
+  );
+  transport.configure(messages);
+  return { transport, device, bleManager, connect };
+}
+
+describe('BLE connect timeout', () => {
+  beforeAll(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.restoreAllMocks();
+  });
+
+  test('a native connect that never settles is bounded instead of blocking forever', async () => {
+    // iOS applies its own connect timeout on a serial queue; when that queue is busy
+    // the timeout never fires and acquire() blocks until the app-level 60s timeout.
+    const { transport } = createHarness(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+
+    const errors: Array<{ errorCode?: unknown }> = [];
+    let settled = false;
+    transport.acquire({ uuid: UUID }).catch(e => {
+      errors.push(e);
+      settled = true;
+    });
+    await flush();
+
+    await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
+  });
+
+  test('the connect budget leaves generous headroom over a healthy connect', () => {
+    // Healthy connects finish in ~2-3s (the native budget is 3s); this backstop only
+    // fires when the native timeout itself fails to.
+    expect(BLE_CONNECT_TIMEOUT_MS).toBeGreaterThanOrEqual(6000);
+    expect(BLE_CONNECT_TIMEOUT_MS).toBeLessThanOrEqual(12000);
+  });
+
+  test('a stalled connect is abandoned natively so the next attempt is not cancelled by it', async () => {
+    const { transport, bleManager } = createHarness(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+
+    let settled = false;
+    transport.acquire({ uuid: UUID }).catch(() => {
+      settled = true;
+    });
+    await flush();
+    await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+  });
+
+  test('repeated stalled connects recreate the BLE manager', async () => {
+    const { transport, bleManager } = createHarness(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+    const destroy = jest.fn();
+    (bleManager as unknown as { destroy: jest.Mock }).destroy = destroy;
+
+    for (let attempt = 0; attempt < BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD; attempt += 1) {
+      let settled = false;
+      transport.acquire({ uuid: UUID }).catch(() => {
+        settled = true;
+      });
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      // eslint-disable-next-line no-await-in-loop
+      await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
+    }
+
+    expect(destroy).toHaveBeenCalledTimes(1);
+    expect((transport as unknown as { blePlxManager?: unknown }).blePlxManager).toBeUndefined();
+  });
+});

package/src/__tests__/protocolV2Link.test.ts

@@ -3,6 +3,7 @@ import transportPackage, {
   PROTOCOL_V2_CHANNEL_BLE_UART,
   ProtocolV2,
   TRANSPORT_EVENT,
+  bytesToHex,
 } from '@onekeyfe/hd-transport';
 import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
@@ -45,11 +46,6 @@ jest.mock('../subscribeBleOn', () => ({
   subscribeBleOn: jest.fn(() => Promise.resolve()),
 }));
 
-const setPlatformOS = (os: 'ios' | 'android') => {
-  const reactNative: { Platform: { OS: string } } = jest.requireMock('react-native');
-  reactNative.Platform.OS = os;
-};
-
 const { parseConfigure } = transportPackage;
 
 const protocolV1Schema = {
@@ -73,13 +69,11 @@ const protocolV1Schema = {
 
 const protocolV2Schema = {
   nested: {
-    ProtocolInfoRequest: { fields: {} },
     Ping: {
       fields: {
         message: { type: 'string', id: 1 },
       },
     },
-    DeviceInfoGet: { fields: {} },
     FileWrite: { fields: {} },
     Success: {
       fields: {
@@ -88,10 +82,8 @@ const protocolV2Schema = {
     },
     MessageType: {
       values: {
-        MessageType_ProtocolInfoRequest: 60200,
         MessageType_Ping: 60206,
         MessageType_Success: 60207,
-        MessageType_DeviceInfoGet: 60600,
         MessageType_FileWrite: 60805,
       },
     },
@@ -103,13 +95,7 @@ const schemas = {
   protocolV2: parseConfigure(protocolV2Schema),
 };
 
-const createHarness = ({
-  deviceName = 'OneKey Pro 2',
-  isWritableWithResponse = true,
-}: {
-  deviceName?: string;
-  isWritableWithResponse?: boolean;
-} = {}) => {
+const createHarness = () => {
   const uuid = 'rn-pro2-id';
   const sentSeqs: number[] = [];
   let responseSeq = 0;
@@ -148,15 +134,15 @@ const createHarness = ({
   const writeCharacteristic = {
     uuid: '0002',
     deviceID: uuid,
-    isWritableWithResponse,
+    isWritableWithResponse: true,
     isWritableWithoutResponse: true,
     writeWithResponse: jest.fn(handleWrite),
     writeWithoutResponse: jest.fn(handleWrite),
   };
   const device = {
     id: uuid,
-    name: deviceName,
-    localName: deviceName,
+    name: 'OneKey Pro 2',
+    localName: 'OneKey Pro 2',
     serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
     isConnected: jest.fn(() => Promise.resolve(true)),
     cancelConnection: jest.fn(() => Promise.resolve()),
@@ -198,13 +184,7 @@ const createHarness = ({
   };
 };
 
-const createV1Harness = ({
-  respondOnWriteCount = 1,
-  isWritableWithResponse = true,
-}: {
-  respondOnWriteCount?: number | number[];
-  isWritableWithResponse?: boolean;
-} = {}) => {
+const createV1Harness = () => {
   const uuid = 'rn-classic-id';
   const notifySubscriptionRemovers: jest.Mock[] = [];
   const disconnectSubscriptionRemovers: jest.Mock[] = [];
@@ -223,25 +203,20 @@ const createV1Harness = ({
     }),
   };
   let writeCount = 0;
-  const responseWriteCounts = new Set(
-    Array.isArray(respondOnWriteCount) ? respondOnWriteCount : [respondOnWriteCount]
-  );
-  const handleWrite = () => {
-    writeCount += 1;
-    if (responseWriteCounts.has(writeCount)) {
-      notifyCallback?.(null, {
-        value: Buffer.from('3f23230002000000040a026f6b', 'hex').toString('base64'),
-      });
-    }
-    return Promise.resolve();
-  };
   const writeCharacteristic = {
     uuid: '0002',
     deviceID: uuid,
-    isWritableWithResponse,
+    isWritableWithResponse: true,
     isWritableWithoutResponse: true,
-    writeWithResponse: jest.fn(handleWrite),
-    writeWithoutResponse: jest.fn(handleWrite),
+    writeWithoutResponse: jest.fn(() => {
+      writeCount += 1;
+      if (writeCount === 1) {
+        notifyCallback?.(null, {
+          value: Buffer.from('3f23230002000000040a026f6b', 'hex').toString('base64'),
+        });
+      }
+      return Promise.resolve();
+    }),
   };
   const device = {
     id: uuid,
@@ -274,7 +249,6 @@ const createV1Harness = ({
     uuid,
     device,
     bleManager,
-    writeCharacteristic,
     notifySubscriptionRemovers,
     disconnectSubscriptionRemovers,
   };
@@ -328,81 +302,12 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     expect(new ReactNativeBleTransport({}).scanTimeout).toBe(3000);
   });
 
-  test('uses withResponse for consecutive iOS Protocol V1 control commands without releasing', async () => {
-    const { transport, uuid, writeCharacteristic } = createV1Harness({
-      respondOnWriteCount: [1, 2],
-    });
-
-    await expect(transport.acquire({ uuid })).resolves.toEqual({
-      uuid,
-      protocolType: 'V1',
-    });
-    const releaseNative = jest.spyOn(transport as any, 'releaseNative');
-    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
-
-    await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 50 })).resolves.toBeDefined();
-    await expect(transport.call(uuid, 'GetFeatures', {}, { timeoutMs: 50 })).resolves.toBeDefined();
-
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(2);
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
-    expect(releaseNative).not.toHaveBeenCalled();
-    await transport.release(uuid, true);
-  });
-
-  test('falls back to withoutResponse for an iOS Protocol V1 control command when required', async () => {
-    const { transport, uuid, writeCharacteristic } = createV1Harness({
-      isWritableWithResponse: false,
-    });
-
-    await transport.acquire({ uuid });
-    await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 50 })).resolves.toBeDefined();
-
-    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
-    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
-    await transport.release(uuid, true);
-  });
-
-  test('does not resend a failed iOS Protocol V1 control write without response', async () => {
-    const { transport, uuid, writeCharacteristic } = createV1Harness();
-    const writeError = new Error('write with response failed');
-
-    await transport.acquire({ uuid });
-    writeCharacteristic.writeWithResponse.mockRejectedValueOnce(writeError);
-
-    await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 50 })).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleWriteCharacteristicError,
-    });
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
-    await transport.release(uuid, true);
-  });
-
-  test('keeps the first Core command as the first iOS BLE request for a Protocol V2 device', async () => {
-    const { transport, uuid, sentSeqs, writeCharacteristic } = createHarness({
-      deviceName: 'Pro2 6E9E',
-    });
-
-    await expect(transport.acquire({ uuid })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
-    });
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
-
-    await expect(
-      transport.call(uuid, 'Ping', { message: 'first-core-command' })
-    ).resolves.toBeDefined();
-    expect(sentSeqs).toEqual([1]);
-    await transport.release(uuid, true);
-  });
-
   test('reconnects before falling back to Protocol V1 after a fatal V2 probe failure', async () => {
-    setPlatformOS('android');
     const { transport, uuid, device, notifySubscriptionRemovers, disconnectSubscriptionRemovers } =
       createV1Harness();
     const probeProtocolV2 = jest
       .spyOn(transport as any, 'probeProtocolV2')
-      .mockImplementation(async () => {
+      .mockImplementationOnce(async () => {
         await (transport as any).releaseNative(uuid, true);
         return false;
       });
@@ -428,9 +333,8 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   test('cleans the rebuilt transport when Protocol V1 fallback also fails', async () => {
-    setPlatformOS('android');
     const { transport, uuid, device, bleManager, notifySubscriptionRemovers } = createV1Harness();
-    jest.spyOn(transport as any, 'probeProtocolV2').mockImplementation(async () => {
+    jest.spyOn(transport as any, 'probeProtocolV2').mockImplementationOnce(async () => {
       await (transport as any).releaseNative(uuid, true);
       return false;
     });
@@ -449,9 +353,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   test('disconnects and invalidates a Protocol V1 link after a response timeout', async () => {
-    const { transport, uuid, device } = createV1Harness({
-      respondOnWriteCount: Number.POSITIVE_INFINITY,
-    });
+    const { transport, uuid, device } = createV1Harness();
 
     await transport.acquire({ uuid, expectedProtocol: 'V1' });
     await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 5 })).rejects.toMatchObject({
@@ -463,17 +365,17 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   });
 
   afterEach(() => {
-    setPlatformOS('ios');
     resetProtocolV2BleTuning();
   });
 
-  test('starts the Protocol V2 sequence with the first Core call on iOS', async () => {
+  test('keeps the Protocol V2 sequence across probe and the next call', async () => {
     const { transport, uuid, sentSeqs } = createHarness();
 
     await transport.acquire({ uuid });
-    await transport.call(uuid, 'Ping', { message: 'first-core-command' });
+    await transport.call(uuid, 'Ping', { message: 'after-probe' });
 
-    expect(sentSeqs).toEqual([1]);
+    expect(sentSeqs).toEqual([1, 2]);
+    expect(bytesToHex(new Uint8Array([sentSeqs[0], sentSeqs[1]]))).toBe('0102');
     await transport.release(uuid, true);
   });
 
@@ -484,10 +386,8 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     harness.setShouldRespond(false);
 
     const call = transport.call(uuid, 'Ping', { message: 'wait-for-monitor' }, { timeoutMs: 50 });
-    while (sentSeqs.length < 1) {
-      await new Promise(resolve => {
-        setTimeout(resolve, 0);
-      });
+    while (sentSeqs.length < 2) {
+      await Promise.resolve();
     }
     await new Promise(resolve => {
       setTimeout(resolve, 0);
@@ -503,135 +403,30 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     const { transport, uuid, sentSeqs } = createHarness();
 
     await transport.acquire({ uuid });
-    await transport.call(uuid, 'Ping', { message: 'first-generation' });
     await transport.release(uuid, true);
     await transport.acquire({ uuid });
-    await transport.call(uuid, 'Ping', { message: 'second-generation' });
 
     expect(sentSeqs).toEqual([1, 2]);
     await transport.release(uuid, true);
   });
 
-  test('uses withResponse for consecutive iOS Protocol V2 control calls without releasing', async () => {
-    const { transport, uuid, writeCharacteristic } = createHarness();
-
-    await transport.acquire({ uuid });
-    const releaseNative = jest.spyOn(transport as any, 'releaseNative');
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
-    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
-
-    await transport.call(uuid, 'DeviceInfoGet', {});
-    await transport.call(uuid, 'ProtocolInfoRequest', {});
-
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(2);
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
-    expect(releaseNative).not.toHaveBeenCalled();
-
-    await transport.release(uuid, true);
-  });
-
-  test('keeps iOS Protocol V2 high-volume calls on withoutResponse', async () => {
+  test('uses withoutResponse for normal and high-volume calls', async () => {
     const { transport, uuid, writeCharacteristic } = createHarness();
 
     await transport.acquire({ uuid });
-
-    await transport.call(uuid, 'FileWrite', {});
     expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
     expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
-    await transport.release(uuid, true);
-  });
-
-  test('uses withResponse for an iOS Protocol V2 firmware file write when requested', async () => {
-    const { transport, uuid, writeCharacteristic } = createHarness();
-
-    await transport.acquire({ uuid });
 
-    await transport.call(uuid, 'FileWrite', {}, { writeWithResponse: true });
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
-    await transport.release(uuid, true);
-  });
-
-  test('falls back to withoutResponse for an iOS Protocol V2 control call when required', async () => {
-    const { transport, uuid, writeCharacteristic } = createHarness({
-      isWritableWithResponse: false,
-    });
-
-    await transport.acquire({ uuid });
-    await transport.call(uuid, 'ProtocolInfoRequest', {});
+    await transport.call(uuid, 'Ping', { message: 'normal' });
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(2);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
 
+    await transport.call(uuid, 'FileWrite', {});
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(3);
     expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
-    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
     await transport.release(uuid, true);
   });
 
-  test('does not resend a failed iOS Protocol V2 control write without response', async () => {
-    const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
-    const writeError = new Error('write with response failed');
-    const writeWithResponse = jest.fn().mockRejectedValue(writeError);
-    const writeWithoutResponse = jest.fn().mockResolvedValue(undefined);
-    const context = {
-      messageName: 'ProtocolInfoRequest',
-      timeoutMs: 1000,
-      highVolume: false,
-      generation: 1,
-      signal: new AbortController().signal,
-    };
-
-    await expect(
-      transport.writeProtocolV2Packet(
-        {
-          writeCharacteristic: {
-            isWritableWithResponse: true,
-            writeWithResponse,
-            writeWithoutResponse,
-          },
-        },
-        Buffer.from('control').toString('base64'),
-        context,
-        jest.fn()
-      )
-    ).rejects.toBe(writeError);
-    expect(writeWithResponse).toHaveBeenCalledTimes(1);
-    expect(writeWithoutResponse).not.toHaveBeenCalled();
-  });
-
-  test('paces a one-packet Protocol V2 control write on iOS', async () => {
-    const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
-    const writeWithoutResponse = jest.fn().mockResolvedValue(undefined);
-    const bleTransport = {
-      mtuSize: 23,
-      writeCharacteristic: { writeWithoutResponse },
-    };
-    const context = {
-      messageName: 'ProtocolInfoRequest',
-      timeoutMs: 1000,
-      highVolume: false,
-      generation: 1,
-      signal: new AbortController().signal,
-    };
-    configureProtocolV2BleTuning({ iosPacketLength: 20 });
-    const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
-
-    try {
-      const call = transport.writeProtocolV2Frame(
-        bleTransport,
-        new Uint8Array(10),
-        context,
-        jest.fn()
-      );
-
-      await Promise.resolve();
-      expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 5);
-      expect(writeWithoutResponse).not.toHaveBeenCalled();
-
-      await call;
-      expect(writeWithoutResponse).toHaveBeenCalledTimes(1);
-    } finally {
-      setTimeoutSpy.mockRestore();
-    }
-  });
-
   test('rejects an active Protocol V2 reader when disconnect resets the link', async () => {
     const harness = createHarness();
     const { transport, uuid, sentSeqs } = harness;
@@ -639,10 +434,8 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     harness.setShouldRespond(false);
 
     const call = transport.call(uuid, 'Ping', { message: 'disconnect' }, { timeoutMs: 50 });
-    while (sentSeqs.length < 1) {
-      await new Promise(resolve => {
-        setTimeout(resolve, 0);
-      });
+    while (sentSeqs.length < 2) {
+      await Promise.resolve();
     }
 
     const rejection = expect(call).rejects.toThrow('React Native BLE transport disconnected');
@@ -689,6 +482,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     configureProtocolV2BleTuning({ iosPacketLength: 20 });
 
     await transport.writeProtocolV2Frame(
+      'device-uuid',
       bleTransport,
       new Uint8Array(30),
       context,
@@ -720,7 +514,13 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     configureProtocolV2BleTuning({ iosPacketLength: 20 });
 
     await expect(
-      transport.writeProtocolV2Frame(bleTransport, new Uint8Array(30), context, jest.fn())
+      transport.writeProtocolV2Frame(
+        'device-uuid',
+        bleTransport,
+        new Uint8Array(30),
+        context,
+        jest.fn()
+      )
     ).rejects.toMatchObject({ errorCode: 205 });
     expect(writeWithoutResponse).toHaveBeenCalledTimes(1);
   });