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

package/src/__tests__/protocolV2Link.test.ts

@@ -8,7 +8,6 @@ import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
 import ReactNativeBleTransport, {
   BLE_NATIVE_TEARDOWN_TIMEOUT_MS,
-  BLE_SETUP_WEDGED_MESSAGE,
   BLE_WRITE_PACKET_TIMEOUT_MS,
   configureProtocolV2BleTuning,
   getFirmwareUploadWriteRetryType,
@@ -170,13 +169,11 @@ const createHarness = ({
     serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
     isConnected: jest.fn(() => Promise.resolve(true)),
     cancelConnection: jest.fn(() => Promise.resolve()),
-    connect: jest.fn(),
     onDisconnected: jest.fn(callback => {
       disconnectCallback = callback;
       return { remove: jest.fn() };
     }),
   } as any;
-  device.connect.mockResolvedValue(device);
   device.requestMTU = jest.fn(() => Promise.resolve(device));
   device.requestConnectionPriority = jest.fn(() => Promise.resolve(device));
   const bleManager = {
@@ -618,7 +615,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).not.toHaveBeenCalled();
+    expect(device.requestMTU).toHaveBeenCalledWith(247);
     expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
     expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalled();
 
@@ -1082,621 +1079,57 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.release(uuid, true);
   });
 
-  test('does not renegotiate an already usable MTU during acquire', async () => {
+  test('continues with the current MTU when the connected snapshot refresh fails', async () => {
     const { transport, uuid, device } = createHarness();
+    const mtuError = new Error('MTU refresh failed');
+    device.requestMTU.mockRejectedValueOnce(mtuError);
 
     await expect(transport.acquire({ uuid })).resolves.toEqual({
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).not.toHaveBeenCalled();
+    expect(device.requestMTU).toHaveBeenCalledTimes(1);
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(247);
     await transport.release(uuid, true);
   });
 
-  test('requests a low MTU once before protocol probing', async () => {
+  test('refreshes a transient bootloader MTU after notifications are ready', async () => {
     const { transport, uuid, device } = createHarness();
     device.mtu = 23;
-    device.requestMTU.mockImplementationOnce(() => {
-      device.mtu = 247;
-      return Promise.resolve(device);
-    });
+    device.requestMTU
+      .mockResolvedValueOnce(device)
+      .mockResolvedValueOnce(device)
+      .mockImplementationOnce(() => {
+        device.mtu = 247;
+        return Promise.resolve(device);
+      });
 
     await expect(transport.acquire({ uuid })).resolves.toEqual({
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).toHaveBeenCalledTimes(1);
-    expect(device.requestMTU).toHaveBeenCalledWith(
-      247,
-      expect.stringContaining(`${uuid}:mtu:connected:0:`)
-    );
+    expect(device.requestMTU).toHaveBeenCalledTimes(3);
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(247);
     await transport.release(uuid, true);
   });
 
-  test('continues with a low MTU when the single negotiation fails', async () => {
+  test('continues with a low bootloader MTU when the bounded retry fails', async () => {
     const { transport, uuid, device } = createHarness();
     device.mtu = 23;
-    device.requestMTU.mockRejectedValueOnce(new Error('MTU negotiation failed'));
-
-    await expect(transport.acquire({ uuid })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
-    });
-    expect(device.requestMTU).toHaveBeenCalledTimes(1);
-    expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
-    await transport.release(uuid, true);
-  });
-
-  test('bounds a stalled MTU negotiation and continues protocol probing', async () => {
-    const { transport, uuid, device, bleManager } = createHarness();
-    device.mtu = 23;
-    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
-
-    await expect(transport.acquire({ uuid })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
-    });
-    const transactionId = device.requestMTU.mock.calls[0]?.[1];
-    expect(transactionId).toEqual(expect.stringContaining(`${uuid}:mtu:connected:0:`));
-    expect(bleManager.cancelTransaction).toHaveBeenCalledWith(transactionId);
-    expect(device.cancelConnection).toHaveBeenCalled();
-    expect(device.connect).toHaveBeenCalledWith(
-      expect.objectContaining({ timeout: expect.any(Number) })
-    );
-    expect(device.connect.mock.calls.at(-1)?.[0]).not.toHaveProperty('requestMTU');
-    expect(device.requestMTU).toHaveBeenCalledTimes(1);
-    expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
-    await transport.release(uuid, true);
-  }, 10_000);
-
-  test('keeps the iOS link when the MTU-timeout reconnect reports it is still connected', async () => {
-    const { BleError: BleErrorMock, BleErrorCode } = jest.requireMock('react-native-ble-plx');
-    const { transport, uuid, device, bleManager } = createHarness();
-    device.mtu = 23;
-    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
-    device.connect.mockRejectedValueOnce(
-      Object.assign(new BleErrorMock('Device already connected'), {
-        errorCode: BleErrorCode.DeviceAlreadyConnected,
-      })
-    );
+    device.requestMTU
+      .mockResolvedValueOnce(device)
+      .mockResolvedValueOnce(device)
+      .mockRejectedValueOnce(new Error('bootloader MTU retry failed'));
 
     await expect(transport.acquire({ uuid })).resolves.toEqual({
       uuid,
       protocolType: 'V2',
     });
-    expect(device.cancelConnection).toHaveBeenCalledTimes(1);
-    expect(device.connect).toHaveBeenCalledTimes(1);
-    expect(device.requestMTU).toHaveBeenCalledTimes(1);
-    expect(bleManager.destroy).not.toHaveBeenCalled();
+    expect(device.requestMTU).toHaveBeenCalledTimes(3);
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
     await transport.release(uuid, true);
-  }, 10_000);
-
-  test('reconnects after an iOS MTU timeout when cancelling the timed-out link fails', async () => {
-    const { BleError: BleErrorMock, BleErrorCode } = jest.requireMock('react-native-ble-plx');
-    const { transport, uuid, device, bleManager } = createHarness();
-    device.mtu = 23;
-    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
-    device.cancelConnection.mockRejectedValueOnce(
-      Object.assign(new BleErrorMock('Operation was cancelled'), {
-        errorCode: BleErrorCode.OperationCancelled,
-      })
-    );
-
-    await expect(transport.acquire({ uuid })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
-    });
-    expect(device.connect).toHaveBeenCalledTimes(1);
-    expect(device.connect.mock.calls[0]?.[0]).not.toHaveProperty('requestMTU');
-    expect(bleManager.destroy).not.toHaveBeenCalled();
-    await transport.release(uuid, true);
-  }, 10_000);
-
-  test('maps a stale bond from the iOS MTU-timeout reconnect', async () => {
-    const { BleError: BleErrorMock } = jest.requireMock('react-native-ble-plx');
-    const { transport, uuid, device } = createHarness();
-    device.mtu = 23;
-    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
-    device.connect.mockRejectedValueOnce(
-      Object.assign(new BleErrorMock('Peer removed pairing information'), {
-        errorCode: 200,
-        iosErrorCode: 14,
-      })
-    );
-
-    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
-    });
-    await transport.release(uuid, true).catch(() => undefined);
-  }, 10_000);
-
-  test('bounds a hung iOS MTU-timeout teardown and resets the BLE manager without reconnecting', async () => {
-    const { transport, uuid, device, bleManager } = createHarness();
-    device.mtu = 23;
-    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
-    device.cancelConnection.mockImplementationOnce(() => new Promise(() => {}));
-
-    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleTimeoutError,
-      message: expect.stringContaining('BLE MTU cleanup timed out'),
-    });
-    expect(bleManager.destroy).toHaveBeenCalledTimes(1);
-    expect(transport.blePlxManager).toBeUndefined();
-    expect(device.connect).not.toHaveBeenCalled();
-    expect((transport as any).lifecycleOperations.has(uuid)).toBe(false);
-  }, 15_000);
-
-  test('does not reconnect after a hung iOS MTU-timeout teardown when the manager reset is already pending', async () => {
-    const { transport, uuid, device, bleManager } = createHarness();
-    device.mtu = 23;
-    device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
-    device.cancelConnection.mockImplementationOnce(() => new Promise(() => {}));
-    // Another device's reset is still draining, so this teardown timeout cannot swap the manager.
-    jest.spyOn(transport as any, 'resetPlxManager').mockImplementation(() => undefined);
-
-    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleTimeoutError,
-    });
-    expect(transport.blePlxManager).toBe(bleManager);
-    expect(device.connect).not.toHaveBeenCalled();
-  }, 15_000);
-
-  test('does not request MTU again after connect falls back without requestMTU', async () => {
-    const { BleError: BleErrorMock, BleErrorCode } = jest.requireMock('react-native-ble-plx');
-    const { transport, uuid, device } = createHarness();
-    device.mtu = 23;
-    device.isConnected.mockResolvedValueOnce(false).mockResolvedValue(true);
-    device.connect
-      .mockRejectedValueOnce(
-        Object.assign(new BleErrorMock('Operation was cancelled'), {
-          errorCode: BleErrorCode.OperationCancelled,
-        })
-      )
-      .mockResolvedValue(device);
-
-    await expect(transport.acquire({ uuid })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
-    });
-    expect(device.connect).toHaveBeenCalledTimes(2);
-    expect(device.connect.mock.calls[0][0]).toEqual(expect.objectContaining({ requestMTU: 247 }));
-    expect(device.connect.mock.calls[1][0]).not.toHaveProperty('requestMTU');
-    expect(device.requestMTU).not.toHaveBeenCalled();
-    expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
-    await transport.release(uuid, true);
-  });
-
-  test('keeps the iOS connect chain unchanged', async () => {
-    const { transport, uuid, device } = createHarness();
-    device.isConnected.mockResolvedValueOnce(false);
-
-    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
-    });
-    expect(device.connect).toHaveBeenCalledWith({
-      requestMTU: 247,
-      timeout: expect.any(Number),
-      refreshGatt: 'OnConnected',
-    });
-    expect(device.requestMTU).not.toHaveBeenCalled();
-    await transport.release(uuid, true);
-  });
-
-  describe('Android MTU before service discovery', () => {
-    beforeEach(() => {
-      setPlatformOS('android');
-      jest.useFakeTimers({
-        doNotFake: ['setImmediate', 'queueMicrotask', 'nextTick', 'performance'],
-      });
-    });
-
-    afterEach(() => {
-      jest.clearAllTimers();
-      jest.useRealTimers();
-    });
-
-    const advanceUntil = async (condition: () => boolean, budgetMs = 60_000) => {
-      for (let elapsed = 0; !condition(); elapsed += 50) {
-        if (elapsed >= budgetMs) throw new Error(`fake time exhausted after ${budgetMs}ms`);
-        jest.advanceTimersByTime(50);
-        // eslint-disable-next-line no-await-in-loop
-        await new Promise(resolve => {
-          setImmediate(resolve);
-        });
-      }
-    };
-
-    const settle = async <T>(promise: Promise<T>, budgetMs?: number): Promise<T> => {
-      let done = false;
-      promise.then(
-        () => {
-          done = true;
-        },
-        () => {
-          done = true;
-        }
-      );
-      await advanceUntil(() => done, budgetMs);
-      return promise;
-    };
-
-    /**
-     * A device whose LE link is only up between connect() and cancelConnection(), so the
-     * transport has to reconnect after every drop instead of the test flipping the link.
-     */
-    const reconnectingDevice = (device: any) => {
-      const link = { connected: false };
-      device.isConnected.mockImplementation(() => Promise.resolve(link.connected));
-      device.connect = jest.fn(() => {
-        link.connected = true;
-        return Promise.resolve(device);
-      });
-      device.cancelConnection.mockImplementation(() => {
-        link.connected = false;
-        return Promise.resolve();
-      });
-      return link;
-    };
-
-    /** requestMTU resolves a fresh Device snapshot, as react-native-ble-plx does. */
-    const negotiatedSnapshot = (device: any, mtu: number) => {
-      const negotiated = { ...device, mtu };
-      device.requestMTU.mockImplementation(() => Promise.resolve(negotiated));
-      return negotiated;
-    };
-
-    test('negotiates the MTU after a bare connect and before service discovery, adopting the returned device', async () => {
-      const { transport, uuid, device } = createHarness();
-      reconnectingDevice(device);
-      device.mtu = 23;
-      const negotiated = negotiatedSnapshot(device, 247);
-
-      await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
-        uuid,
-        protocolType: 'V2',
-      });
-
-      expect(device.connect).toHaveBeenCalledTimes(1);
-      expect(device.connect).toHaveBeenCalledWith({ timeout: expect.any(Number) });
-      const resolveCharacteristics = (transport as any).resolveCharacteristics as jest.Mock;
-      const [connectOrder] = device.connect.mock.invocationCallOrder;
-      const [mtuOrder] = device.requestMTU.mock.invocationCallOrder;
-      const [discoveryOrder] = resolveCharacteristics.mock.invocationCallOrder;
-      expect(connectOrder).toBeLessThan(mtuOrder);
-      expect(mtuOrder).toBeLessThan(discoveryOrder);
-      const cached = (transport as any).getCachedTransport(uuid);
-      expect(cached.device).toBe(negotiated);
-      expect(cached.mtuSize).toBe(247);
-      await settle(transport.release(uuid, true));
-    });
-
-    test.each([
-      { expectedProtocol: 'V2' as const, label: 'an expected Protocol V2 device' },
-      { expectedProtocol: 'V1' as const, label: 'an expected Protocol V1 device' },
-      { expectedProtocol: undefined, label: 'a device of unknown protocol' },
-    ])('drops a link that stays at the default MTU for $label', async ({ expectedProtocol }) => {
-      const { transport, uuid, device } = createHarness();
-      device.mtu = 23;
-
-      await expect(settle(transport.acquire({ uuid, expectedProtocol }))).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.BleConnectedError,
-      });
-      expect((transport as any).resolveCharacteristics).not.toHaveBeenCalled();
-      expect(device.cancelConnection).toHaveBeenCalled();
-    });
-
-    test.each([
-      ['never completes', () => new Promise(() => {})],
-      ['completes at the default MTU', undefined],
-      ['is rejected', () => Promise.reject(new Error('MTU request failed'))],
-    ])(
-      'a second consecutive MTU failure that %s trips the wedged-link guard',
-      async (_label, requestMTU) => {
-        const { transport, uuid, device, bleManager } = createHarness();
-        device.mtu = 23;
-        if (requestMTU) device.requestMTU.mockImplementation(requestMTU);
-
-        await expect(
-          settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))
-        ).rejects.toMatchObject({
-          errorCode: HardwareErrorCode.BleConnectedError,
-        });
-        await expect(
-          settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))
-        ).rejects.toMatchObject({
-          errorCode: HardwareErrorCode.PollingTimeout,
-          message: expect.stringContaining(BLE_SETUP_WEDGED_MESSAGE),
-        });
-        expect(bleManager.destroy).toHaveBeenCalled();
-      }
-    );
-
-    test('stop() during the link-drop wait releases it promptly', async () => {
-      const { transport, uuid, device } = createHarness();
-      device.mtu = 23;
-      device.requestMTU.mockImplementation(() => new Promise(() => {}));
-
-      const acquiring = transport.acquire({ uuid, expectedProtocol: 'V2' }).catch(error => error);
-      // The link-drop teardown cancels the device connection before the wait starts.
-      await advanceUntil(() => device.cancelConnection.mock.calls.length > 0);
-      await advanceUntil(() => false, 1000).catch(() => undefined);
-      await settle(transport.stop(), 1000);
-      await expect(settle(acquiring, 1000)).resolves.toBeInstanceOf(Error);
-    });
-
-    test.each([
-      {
-        label: 'a missing OneKey service',
-        error: () => ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound),
-      },
-      {
-        label: 'a missing characteristic',
-        error: () => ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotFound),
-      },
-      {
-        label: 'a mis-typed characteristic',
-        error: () =>
-          ERRORS.TypedError('BLECharacteristicNotWritable: write characteristic not writable'),
-      },
-    ])(
-      'marks the endpoint on $label and refreshes the GATT table on the next connect, before the MTU exchange',
-      async ({ error }) => {
-        const { transport, uuid, device } = createHarness();
-        const link = reconnectingDevice(device);
-        device.mtu = 23;
-        negotiatedSnapshot(device, 247);
-        const resolveCharacteristics = (transport as any).resolveCharacteristics as jest.Mock;
-        resolveCharacteristics.mockImplementationOnce(() => Promise.reject(error()));
-
-        await expect(
-          settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))
-        ).rejects.toBeDefined();
-        expect(link.connected).toBe(true);
-
-        await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
-          uuid,
-          protocolType: 'V2',
-        });
-        expect(device.connect).toHaveBeenLastCalledWith({
-          timeout: expect.any(Number),
-          refreshGatt: 'OnConnected',
-        });
-        // The stale table is only refreshed through a connect, so the live link is dropped first.
-        const connectOrders: number[] = device.connect.mock.invocationCallOrder;
-        expect(device.cancelConnection.mock.invocationCallOrder[0]).toBeLessThan(
-          connectOrders[connectOrders.length - 1]
-        );
-        const discoveryOrders = resolveCharacteristics.mock.invocationCallOrder;
-        const mtuOrders: number[] = device.requestMTU.mock.invocationCallOrder;
-        expect(discoveryOrders[discoveryOrders.length - 1]).toBeLessThan(
-          mtuOrders[mtuOrders.length - 1]
-        );
-
-        // The refresh is spent once the table resolved through a refreshed connect.
-        await settle(transport.release(uuid, true));
-        link.connected = false;
-        await settle(transport.acquire({ uuid, expectedProtocol: 'V2' }));
-        expect(device.connect).toHaveBeenLastCalledWith({ timeout: expect.any(Number) });
-        await settle(transport.release(uuid, true));
-      }
-    );
-
-    test('keeps the refresh marker when the refresh connect fell back without refreshGatt', async () => {
-      const { transport, uuid, device } = createHarness();
-      const link = reconnectingDevice(device);
-      device.mtu = 23;
-      negotiatedSnapshot(device, 247);
-      const resolveCharacteristics = (transport as any).resolveCharacteristics as jest.Mock;
-      resolveCharacteristics.mockImplementationOnce(() =>
-        Promise.reject(ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound))
-      );
-      await expect(
-        settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))
-      ).rejects.toBeDefined();
-
-      // The fallback connect carries no refreshGatt.
-      const cancelled = Object.assign(new Error('Operation was cancelled'), { errorCode: 2 });
-      device.connect.mockImplementationOnce(() => Promise.reject(cancelled));
-      await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
-        uuid,
-        protocolType: 'V2',
-      });
-
-      await settle(transport.release(uuid, true));
-      link.connected = false;
-      await settle(transport.acquire({ uuid, expectedProtocol: 'V2' }));
-      expect(device.connect).toHaveBeenLastCalledWith({
-        timeout: expect.any(Number),
-        refreshGatt: 'OnConnected',
-      });
-      await settle(transport.release(uuid, true));
-    });
-
-    test('does not drop a link it has just connected with refreshGatt', async () => {
-      const { transport, uuid, device, bleManager } = createHarness();
-      bleManager.devices.mockResolvedValue([]);
-      const connectToDevice = jest.fn(() => Promise.resolve(device));
-      Object.assign(bleManager, { connectToDevice });
-      (transport as any).androidGattCacheRefreshes.add(uuid);
-
-      await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
-        uuid,
-        protocolType: 'V2',
-      });
-      expect(connectToDevice).toHaveBeenCalledTimes(1);
-      expect(connectToDevice).toHaveBeenCalledWith(uuid, {
-        timeout: expect.any(Number),
-        refreshGatt: 'OnConnected',
-      });
-      expect(device.cancelConnection).not.toHaveBeenCalled();
-      expect(device.connect).not.toHaveBeenCalled();
-      await settle(transport.release(uuid, true));
-    });
-
-    test('still refreshes after a connect-by-id refresh fell back without refreshGatt', async () => {
-      const { transport, uuid, device, bleManager } = createHarness();
-      const link = reconnectingDevice(device);
-      bleManager.devices.mockResolvedValue([]);
-      const cancelled = Object.assign(new Error('Operation was cancelled'), { errorCode: 2 });
-      const connectToDevice = jest
-        .fn()
-        .mockImplementationOnce(() => Promise.reject(cancelled))
-        .mockImplementation(() => {
-          link.connected = true;
-          return Promise.resolve(device);
-        });
-      Object.assign(bleManager, { connectToDevice });
-      (transport as any).androidGattCacheRefreshes.add(uuid);
-
-      await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
-        uuid,
-        protocolType: 'V2',
-      });
-      expect(connectToDevice).toHaveBeenLastCalledWith(uuid, { timeout: expect.any(Number) });
-      expect(device.connect).toHaveBeenLastCalledWith({
-        timeout: expect.any(Number),
-        refreshGatt: 'OnConnected',
-      });
-      expect((transport as any).androidGattCacheRefreshes.has(uuid)).toBe(false);
-      await settle(transport.release(uuid, true));
-    });
-
-    test.each([
-      'Cannot write client characteristic config descriptor',
-      'Cannot find client characteristic config descriptor',
-      'The handle is invalid',
-      'Writing is not permitted',
-    ])('arms a GATT refresh from the notify failure "%s"', async reason => {
-      const harness = createHarness();
-      const { transport, uuid, device } = harness;
-      reconnectingDevice(device);
-      device.mtu = 23;
-      negotiatedSnapshot(device, 247);
-
-      await settle(transport.acquire({ uuid, expectedProtocol: 'V2' }));
-      harness.emitMonitorError(Object.assign(new Error('notify failed'), { reason }));
-
-      await expect(settle(transport.acquire({ uuid, expectedProtocol: 'V2' }))).resolves.toEqual({
-        uuid,
-        protocolType: 'V2',
-      });
-      expect(device.connect).toHaveBeenLastCalledWith({
-        timeout: expect.any(Number),
-        refreshGatt: 'OnConnected',
-      });
-      await settle(transport.release(uuid, true));
-    });
-
-    test('arms a GATT refresh from a notify failure while notifications are being enabled', async () => {
-      const { transport, uuid, device } = createHarness({
-        monitorError: Object.assign(new Error('notify failed'), {
-          reason: 'Cannot write client characteristic config descriptor',
-        }),
-      });
-      const link = reconnectingDevice(device);
-      device.mtu = 23;
-      negotiatedSnapshot(device, 247);
-
-      await settle(transport.acquire({ uuid, expectedProtocol: 'V2' }).catch(error => error));
-      await settle(transport.release(uuid, true));
-      link.connected = false;
-      await settle(transport.acquire({ uuid, expectedProtocol: 'V2' }).catch(error => error));
-      expect(device.connect).toHaveBeenLastCalledWith({
-        timeout: expect.any(Number),
-        refreshGatt: 'OnConnected',
-      });
-      await settle(transport.release(uuid, true));
-    });
-
-    test('keeps the GATT refresh for a firmware-install reconnect', async () => {
-      const { transport, uuid, device } = createHarness();
-      (transport as any).sessionProtocols.set(uuid, 'V2');
-      reconnectingDevice(device);
-
-      await expect(
-        settle(transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true }))
-      ).resolves.toEqual({ uuid, protocolType: 'V2' });
-      expect(device.connect).toHaveBeenCalledWith({
-        timeout: expect.any(Number),
-        refreshGatt: 'OnConnected',
-      });
-      await settle(transport.release(uuid, true));
-    });
-  });
-
-  test('spends one Initialize wake on the detection after a fully silent one', async () => {
-    setPlatformOS('android');
-    const { transport, uuid } = createHarness();
-    const probes = transport as any;
-    jest.spyOn(probes, 'probeProtocolV1').mockResolvedValue(false);
-    jest.spyOn(probes, 'probeProtocolV2').mockResolvedValue(false);
-    const callProtocolV1 = jest.spyOn(probes, 'callProtocolV1').mockResolvedValue({});
-
-    // Nothing has gone silent yet, so the device keeps whatever session it has.
-    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
-    expect(callProtocolV1).not.toHaveBeenCalled();
-
-    // The previous detection answered on no protocol, which is what a sleeping Classic
-    // looks like, so this one wakes on the fresh link before probing.
-    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
-    expect(callProtocolV1).toHaveBeenCalledTimes(1);
-    expect(callProtocolV1.mock.calls[0]?.[1]).toBe('Initialize');
-
-    // Still silent: the wake is not repeated, so a device that is simply away is not
-    // pushed into a fresh wallet session on every poll.
-    callProtocolV1.mockClear();
-    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
-    expect(callProtocolV1).not.toHaveBeenCalled();
   });
 
-  test('does not send the Initialize wake before a V2-first probe', async () => {
-    setPlatformOS('android');
-    const { transport, uuid } = createHarness();
-    const probes = transport as any;
-    jest.spyOn(probes, 'probeProtocolV1').mockResolvedValue(false);
-    jest.spyOn(probes, 'probeProtocolV2').mockResolvedValue(false);
-    const callProtocolV1 = jest.spyOn(probes, 'callProtocolV1').mockResolvedValue({});
-
-    await expect(transport.acquire({ uuid, protocolHint: 'V2' })).rejects.toBeDefined();
-    // Silent now, but the next detection probes V2 first: a late V1 reply would land on
-    // the V2 probe, so no Initialize is sent.
-    await expect(transport.acquire({ uuid, protocolHint: 'V2' })).rejects.toBeDefined();
-    expect(callProtocolV1).not.toHaveBeenCalled();
-  });
-
-  test('does not send the Initialize wake on iOS', async () => {
-    const { transport, uuid } = createHarness();
-    const probes = transport as any;
-    jest.spyOn(probes, 'probeProtocolV1').mockResolvedValue(false);
-    jest.spyOn(probes, 'probeProtocolV2').mockResolvedValue(false);
-    const callProtocolV1 = jest.spyOn(probes, 'callProtocolV1').mockResolvedValue({});
-
-    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
-    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
-    expect(callProtocolV1).not.toHaveBeenCalled();
-  });
-
-  test('an unanswered Initialize wake settles the acquire and frees the lifecycle lock', async () => {
-    setPlatformOS('android');
-    const harness = createHarness();
-    const { transport, uuid } = harness;
-    const probes = transport as any;
-    harness.setShouldRespond(false);
-    jest.spyOn(probes, 'probeProtocolV1').mockResolvedValue(false);
-    jest.spyOn(probes, 'probeProtocolV2').mockResolvedValue(false);
-
-    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
-    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleTimeoutError,
-    });
-    await transport.disconnect(uuid);
-    await transport.stop();
-  }, 10_000);
-
   test('accepts a stable low MTU without the delayed refresh loop', async () => {
     const { transport, uuid, device } = createHarness();
     device.mtu = 185;
@@ -1705,7 +1138,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).not.toHaveBeenCalled();
+    expect(device.requestMTU).toHaveBeenCalledTimes(1);
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(185);
     await transport.release(uuid, true);
   });
@@ -1718,7 +1151,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       uuid,
       protocolType: 'V2',
     });
-    expect(device.requestMTU).toHaveBeenCalledTimes(1);
+    expect(device.requestMTU).toHaveBeenCalledTimes(3);
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBeUndefined();
     expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalled();
     await transport.release(uuid, true);
@@ -1736,7 +1169,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     });
 
     await expect(transport.call(uuid, 'FileWrite', {})).resolves.toBeDefined();
-    expect(device.requestMTU).toHaveBeenCalledTimes(2);
+    expect(device.requestMTU).toHaveBeenCalledTimes(4);
     expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(
       writesBeforeFileWrite + 1
     );
@@ -1753,7 +1186,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await expect(transport.call(uuid, 'FileWrite', {})).rejects.toMatchObject({
       errorCode: HardwareErrorCode.BleConnectedError,
     });
-    expect(device.requestMTU).toHaveBeenCalledTimes(2);
+    expect(device.requestMTU).toHaveBeenCalledTimes(4);
     expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(writesBeforeFileWrite);
     await transport.release(uuid, true);
   });
@@ -2023,17 +1456,9 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
   test('uses Android 517 MTU and high connection priority during Protocol V2 high-volume calls', async () => {
     setPlatformOS('android');
     const { transport, uuid, device } = createHarness();
-    device.mtu = 23;
-    device.requestMTU.mockImplementationOnce(() => {
-      device.mtu = 517;
-      return Promise.resolve(device);
-    });
 
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
-    expect(device.requestMTU).toHaveBeenCalledWith(
-      517,
-      expect.stringContaining(`${uuid}:mtu:connected:0:`)
-    );
+    expect(device.requestMTU).toHaveBeenCalledWith(517);
 
     await transport.call(uuid, 'FileWrite', {});
     await transport.call(uuid, 'FileWrite', {});