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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.0-alpha.75",
+  "version": "1.2.0-alpha.76",
   "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.75",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.75",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.75",
+    "@onekeyfe/hd-core": "1.2.0-alpha.76",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.76",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.76",
     "@onekeyfe/react-native-ble-utils": "^0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "a9b3ab1cb53f87121ababb2b0ce45789be8fe5ad"
+  "gitHead": "9c85b3757bef3483d84ead72974af4718ca019d0"
 }

package/src/BleTransport.ts

@@ -1,5 +1,3 @@
-import { Platform } from 'react-native';
-
 import type { Characteristic, Device, Subscription } from 'react-native-ble-plx';
 
 export default class BleTransport {
@@ -34,11 +32,16 @@ export default class BleTransport {
     this.notifyCharacteristic = notifyCharacteristic;
   }
 
+  /**
+   * Bulk-transfer write (Protocol V1 FirmwareUpload / EmmcFileWrite only).
+   *
+   * Must stay writeWithoutResponse on every platform. writeWithResponse serialises
+   * each packet into its own connection-interval round trip, which on iOS turned a
+   * 1.7MB firmware upload (~13.5k packets) into a >10 minute transfer that never
+   * finished before the app-level timeout. Protocol V2 and ordinary V1 control
+   * messages pick their write type separately and are unaffected by this method.
+   */
   async writeWithRetry(data: string): Promise<void> {
-    if (Platform.OS === 'ios' && this.writeCharacteristic.isWritableWithResponse) {
-      await this.writeCharacteristic.writeWithResponse(data);
-      return;
-    }
     await this.writeCharacteristic.writeWithoutResponse(data);
   }
 }

package/src/__tests__/BleTransport.test.ts

@@ -38,8 +38,8 @@ describe('BleTransport side-effecting writes', () => {
     });
     const writeCharacteristic = {
       isWritableWithResponse: true,
-      writeWithResponse: jest.fn(() => Promise.reject(error)),
-      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.reject(error)),
     };
     const device = {
       id: 'classic-id',
@@ -50,10 +50,31 @@ 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();
   });
 
+  test('keeps iOS bulk transfer on writeWithoutResponse even when the characteristic supports responses', async () => {
+    // writeWithResponse serialises every packet into its own connection-interval
+    // round trip. On a ~1.7MB firmware (~13.5k packets) that stalled the upload past
+    // the 600s app-level timeout, so bulk transfer must never opt into it.
+    const writeCharacteristic = {
+      isWritableWithResponse: true,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(
+      { id: 'classic-id' } as any,
+      writeCharacteristic as any,
+      {} as any
+    );
+
+    await transport.writeWithRetry('payload');
+
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledWith('payload');
+  });
+
   test('keeps Android Protocol V1 writes on writeWithoutResponse', async () => {
     Platform.OS = 'android';
     const writeCharacteristic = {

package/src/__tests__/connectTimeout.test.ts

@@ -0,0 +1,280 @@
+import { EventEmitter } from 'events';
+import { BleErrorCode } from 'react-native-ble-plx';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport, {
+  BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD,
+  BLE_CONNECT_TIMEOUT_MS,
+  BLE_GATT_SETUP_TIMEOUT_MS,
+} from '../index';
+import protocolV1Schema from './protocolV1SchemaFixture';
+
+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,
+    OperationTimedOut: 3,
+    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 writeCharacteristic = {
+    uuid: '00000002-0000-1000-8000-00805f9b34fb',
+    isWritableWithResponse: true,
+  };
+  const notifyCharacteristic = {
+    uuid: '00000003-0000-1000-8000-00805f9b34fb',
+    isNotifiable: true,
+  };
+  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,
+    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({ 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(protocolV1Schema);
+  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();
+  });
+
+  test('native connect timeouts contribute to the same manager reset budget', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const destroy = jest.fn();
+    (bleManager as unknown as { destroy: jest.Mock }).destroy = destroy;
+    const nativeTimeout = Object.assign(new Error('Operation timed out'), {
+      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);
+    }
+
+    expect(destroy).toHaveBeenCalledTimes(1);
+  });
+
+  test('GATT discovery is bounded and abandons the native connection', async () => {
+    const { transport, device, bleManager } = createHarness(() => Promise.resolve());
+    device.discoverAllServicesAndCharacteristics.mockImplementation(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+
+    const errors: Array<{ errorCode?: unknown }> = [];
+    let settled = false;
+    (transport as any).resolveCharacteristicsWithTimeout(UUID, device).catch((error: unknown) => {
+      errors.push(error as { errorCode?: unknown });
+      settled = true;
+    });
+    await flush();
+    await advanceUntil(() => settled, BLE_GATT_SETUP_TIMEOUT_MS + 5000);
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+  });
+
+  test('a successful GATT retry clears the timeout budget before an abandoned call settles', async () => {
+    const { transport, device, bleManager } = createHarness(() => Promise.resolve());
+    let resolveAbandonedDiscovery: (() => void) | undefined;
+    device.discoverAllServicesAndCharacteristics
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>(resolve => {
+            resolveAbandonedDiscovery = resolve;
+          })
+      )
+      .mockResolvedValueOnce(undefined);
+
+    let firstSettled = false;
+    (transport as any).resolveCharacteristicsWithTimeout(UUID, device).catch(() => {
+      firstSettled = true;
+    });
+    await flush();
+    await advanceUntil(() => firstSettled, BLE_GATT_SETUP_TIMEOUT_MS + 5000);
+
+    await expect(
+      (transport as any).resolveCharacteristicsWithTimeout(UUID, device)
+    ).resolves.toMatchObject({
+      writeCharacteristic: expect.any(Object),
+      notifyCharacteristic: expect.any(Object),
+    });
+
+    resolveAbandonedDiscovery?.();
+    await flush();
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledTimes(1);
+    expect((transport as any).connectionSetupTimeoutCounts.has(UUID)).toBe(false);
+  });
+});

package/src/__tests__/protocolReprobe.test.ts

@@ -0,0 +1,132 @@
+import ReactNativeBleTransport, { PROTOCOL_REPROBE_FALLBACK_ATTEMPTS } from '../index';
+import protocolV1Schema from './protocolV1SchemaFixture';
+
+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 },
+  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 = 'reprobe-device';
+
+/** Drive detectProtocol with stubbed probes so we can observe which are attempted. */
+function createHarness({ v1, v2 }: { v1: boolean; v2: boolean }) {
+  const transport = new ReactNativeBleTransport({});
+  transport.configure(protocolV1Schema);
+  const probeV1 = jest.fn(() => {
+    if (v1) {
+      (transport as any).deviceProtocol.set(UUID, 'V1');
+    }
+    return Promise.resolve(v1);
+  });
+  const probeV2 = jest.fn(() => {
+    if (v2) {
+      (transport as any).deviceProtocol.set(UUID, 'V2');
+    }
+    return Promise.resolve(v2);
+  });
+  (transport as any).probeProtocolV1 = probeV1;
+  (transport as any).probeProtocolV2 = probeV2;
+  (transport as any).resetProbeStateAfterProtocolProbe = jest.fn(() => Promise.resolve());
+  return { transport, probeV1, probeV2 };
+}
+
+const detect = (transport: ReactNativeBleTransport) =>
+  (transport as any).detectProtocol(UUID, undefined, undefined, () =>
+    Promise.resolve()
+  ) as Promise<string>;
+
+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 });
+
+    await expect(detect(transport)).rejects.toBeDefined();
+
+    expect(probeV1).toHaveBeenCalledTimes(1);
+    expect(probeV2).toHaveBeenCalledTimes(1);
+  });
+
+  test('a device already known to speak V1 does not pay the V2 probe while it is away', async () => {
+    const known = createHarness({ v1: true, v2: false });
+    // First detection confirms V1 (this is the session that just talked to the device).
+    await expect(detect(known.transport)).resolves.toBe('V1');
+
+    // The device now reboots after a firmware install: V1 stops answering.
+    (known.transport as any).deviceProtocol.delete(UUID);
+    const probeV1 = jest.fn(() => Promise.resolve(false));
+    const probeV2 = jest.fn(() => Promise.resolve(false));
+    (known.transport as any).probeProtocolV1 = probeV1;
+    (known.transport as any).probeProtocolV2 = probeV2;
+
+    await expect(detect(known.transport)).rejects.toBeDefined();
+
+    expect(probeV1).toHaveBeenCalledTimes(1);
+    // The 10s Protocol V2 ping is pure waste for a device we just spoke V1 to.
+    expect(probeV2).not.toHaveBeenCalled();
+  });
+
+  test('after repeated failures it re-probes every protocol again', async () => {
+    const known = createHarness({ v1: true, v2: false });
+    await expect(detect(known.transport)).resolves.toBe('V1');
+
+    (known.transport as any).deviceProtocol.delete(UUID);
+    const probeV1 = jest.fn(() => Promise.resolve(false));
+    const probeV2 = jest.fn(() => Promise.resolve(false));
+    (known.transport as any).probeProtocolV1 = probeV1;
+    (known.transport as any).probeProtocolV2 = probeV2;
+
+    for (let attempt = 0; attempt < PROTOCOL_REPROBE_FALLBACK_ATTEMPTS; attempt += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      await expect(detect(known.transport)).rejects.toBeDefined();
+    }
+    expect(probeV2).not.toHaveBeenCalled();
+
+    // The device may genuinely have changed protocol, so the shortcut must expire.
+    await expect(detect(known.transport)).rejects.toBeDefined();
+    expect(probeV2).toHaveBeenCalled();
+  });
+
+  test('a successful detection clears the failure streak', async () => {
+    const known = createHarness({ v1: true, v2: false });
+    await expect(detect(known.transport)).resolves.toBe('V1');
+    (known.transport as any).deviceProtocol.delete(UUID);
+
+    const failingV1 = jest.fn(() => Promise.resolve(false));
+    (known.transport as any).probeProtocolV1 = failingV1;
+    await expect(detect(known.transport)).rejects.toBeDefined();
+
+    // Device comes back.
+    (known.transport as any).probeProtocolV1 = jest.fn(() => {
+      (known.transport as any).deviceProtocol.set(UUID, 'V1');
+      return Promise.resolve(true);
+    });
+    await expect(detect(known.transport)).resolves.toBe('V1');
+
+    expect((known.transport as any).protocolReprobeFailures.get(UUID)).toBeUndefined();
+  });
+});

package/src/__tests__/protocolV1SchemaFixture.ts

@@ -0,0 +1,39 @@
+const protocolV1Schema = {
+  nested: {
+    Initialize: {
+      fields: {
+        session_id: { type: 'bytes', id: 1 },
+        derive_cardano: { type: 'bool', id: 3 },
+      },
+    },
+    GetFeatures: { fields: {} },
+    Success: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    Ping: {
+      fields: {
+        message: { type: 'string', id: 1 },
+        button_protection: { type: 'bool', id: 2 },
+      },
+    },
+    FirmwareUpload: {
+      fields: {
+        payload: { rule: 'required', type: 'bytes', id: 1 },
+        hash: { type: 'bytes', id: 2 },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Initialize: 0,
+        MessageType_Ping: 1,
+        MessageType_Success: 2,
+        MessageType_FirmwareUpload: 7,
+        MessageType_GetFeatures: 55,
+      },
+    },
+  },
+};
+
+export default protocolV1Schema;

package/src/__tests__/protocolV2Link.test.ts

@@ -7,6 +7,7 @@ import transportPackage, {
 import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
 import ReactNativeBleTransport, {
+  BLE_WRITE_PACKET_TIMEOUT_MS,
   configureProtocolV2BleTuning,
   getFirmwareUploadWriteRetryType,
   resetProtocolV2BleTuning,
@@ -755,6 +756,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
 
     await expect(
       transport.writeProtocolV2Packet(
+        'test-device',
         {
           writeCharacteristic: {
             isWritableWithResponse: true,
@@ -789,9 +791,19 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
 
     try {
-      await transport.writeProtocolV2Frame(bleTransport, new Uint8Array(10), context, jest.fn());
+      const call = transport.writeProtocolV2Frame(
+        'test-device',
+        bleTransport,
+        new Uint8Array(10),
+        context,
+        jest.fn()
+      );
 
-      expect(setTimeoutSpy).not.toHaveBeenCalled();
+      await call;
+      // The only scheduled timer is the per-packet BLE write watchdog: no pacing delay.
+      expect(setTimeoutSpy.mock.calls.map(([, timeout]) => timeout)).toEqual([
+        BLE_WRITE_PACKET_TIMEOUT_MS,
+      ]);
       expect(writeWithoutResponse).toHaveBeenCalledTimes(1);
     } finally {
       setTimeoutSpy.mockRestore();
@@ -855,6 +867,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     configureProtocolV2BleTuning({ iosPacketLength: 20 });
 
     await transport.writeProtocolV2Frame(
+      'device-uuid',
       bleTransport,
       new Uint8Array(30),
       context,
@@ -886,7 +899,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);
   });
@@ -908,10 +927,21 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
 
     try {
-      await transport.writeProtocolV2Frame(bleTransport, new Uint8Array(600), context, jest.fn());
+      await transport.writeProtocolV2Frame(
+        'test-device',
+        bleTransport,
+        new Uint8Array(600),
+        context,
+        jest.fn()
+      );
 
       expect(writeWithoutResponse).toHaveBeenCalledTimes(3);
-      expect(setTimeoutSpy).not.toHaveBeenCalled();
+      // One BLE write watchdog per packet and nothing else: no burst or flush pauses.
+      expect(setTimeoutSpy.mock.calls.map(([, timeout]) => timeout)).toEqual([
+        BLE_WRITE_PACKET_TIMEOUT_MS,
+        BLE_WRITE_PACKET_TIMEOUT_MS,
+        BLE_WRITE_PACKET_TIMEOUT_MS,
+      ]);
     } finally {
       setTimeoutSpy.mockRestore();
     }