@onekeyfe/hd-transport-react-native 1.2.2-alpha.100 → 1.2.2-alpha.102

package/src/__tests__/bleStaleBond.test.ts

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

package/src/__tests__/bleStrategy.test.ts

@@ -90,7 +90,7 @@ describe('React Native BLE strategy', () => {
     ).toBe(182);
   });
 
-  test('uses withoutResponse for a high-volume write unless explicitly overridden', () => {
+  test('uses withoutResponse by default unless explicitly overridden', () => {
     const characteristic = {
       isWritableWithResponse: true,
       isWritableWithoutResponse: true,
@@ -99,8 +99,7 @@ describe('React Native BLE strategy', () => {
     expect(
       shouldWriteProtocolV2WithResponse({
         platform: 'ios',
-        highThroughput: true,
-        requestedWithResponse: false,
+        highThroughput: false,
         characteristic,
       })
     ).toBe(false);

package/src/__tests__/protocolV2Link.test.ts

@@ -109,9 +109,11 @@ const schemas = {
 const createHarness = ({
   deviceName = 'OneKey Pro 2',
   isWritableWithResponse = true,
+  monitorError,
 }: {
   deviceName?: string;
   isWritableWithResponse?: boolean;
+  monitorError?: (Error & { reason?: string; attErrorCode?: number; iosErrorCode?: number }) | null;
 } = {}) => {
   const uuid = 'rn-pro2-id';
   const sentSeqs: number[] = [];
@@ -130,6 +132,9 @@ const createHarness = ({
     isNotifiable: true,
     monitor: jest.fn(callback => {
       notifyCallback = callback;
+      if (monitorError) {
+        queueMicrotask(() => callback(monitorError, null));
+      }
       return { remove: jest.fn() };
     }),
   };
@@ -355,6 +360,134 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     expect(new ReactNativeBleTransport({}).scanTimeout).toBe(3000);
   });
 
+  test('connects the Android GATT link before starting system bonding', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device } = createHarness();
+    const operationOrder: string[] = [];
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+
+    device.isConnected.mockResolvedValueOnce(false);
+    device.connect = jest.fn(() => {
+      operationOrder.push('connect');
+      return Promise.resolve(device);
+    });
+    pairDeviceMock.mockImplementationOnce(() => {
+      operationOrder.push('bond');
+      return Promise.resolve({ bonded: true, bonding: false });
+    });
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(operationOrder).toEqual(['connect', 'bond']);
+    await transport.release(uuid, true);
+  });
+
+  test('does not start Android bonding when both reconnect attempts fail', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device } = createHarness();
+    const BleErrorMock = jest.requireMock('react-native-ble-plx').BleError as new (
+      message: string
+    ) => Error;
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+    const firstError = Object.assign(new BleErrorMock('MTU change failed'), {
+      errorCode: 206,
+      reason: 'MTU change failed',
+    });
+    const fallbackError = Object.assign(new BleErrorMock('GATT connect failed'), {
+      errorCode: 205,
+      reason: 'GATT connect failed',
+    });
+
+    device.isConnected.mockResolvedValueOnce(false);
+    device.connect = jest
+      .fn()
+      .mockRejectedValueOnce(firstError)
+      .mockRejectedValueOnce(fallbackError);
+    pairDeviceMock.mockClear();
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleConnectedError,
+    });
+    expect(device.connect).toHaveBeenCalledTimes(2);
+    expect(pairDeviceMock).not.toHaveBeenCalled();
+  });
+
+  test('checks that the Android GATT link is connected before bonding', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device, bleManager } = createHarness();
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+
+    device.isConnected.mockResolvedValueOnce(false).mockResolvedValueOnce(false);
+    device.connect = jest.fn().mockResolvedValue(device);
+    pairDeviceMock.mockClear();
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleConnectedError,
+    });
+    expect(pairDeviceMock).not.toHaveBeenCalled();
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(device.cancelConnection).toHaveBeenCalledTimes(1);
+  });
+
+  test.each([
+    [
+      'ios',
+      'OneKey Neo',
+      {
+        iosErrorCode: 14,
+        reason: 'Peer removed pairing information',
+      },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+    [
+      'android',
+      'OneKey Pro 2',
+      {
+        androidErrorCode: 5,
+        reason: 'Connection state changed with status 5',
+      },
+      HardwareErrorCode.BleDeviceBondError,
+    ],
+  ] as const)(
+    'maps a %s %s stale bond during connect before protocol detection',
+    async (platform, deviceName, nativeError, errorCode) => {
+      setPlatformOS(platform);
+      const { transport, uuid, device } = createHarness({ deviceName });
+      const BleErrorMock = jest.requireMock('react-native-ble-plx').BleError as new (
+        message: string
+      ) => Error;
+      const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+      pairDeviceMock.mockClear();
+
+      device.isConnected.mockResolvedValueOnce(false);
+      device.connect = jest
+        .fn()
+        .mockRejectedValue(Object.assign(new BleErrorMock(nativeError.reason), nativeError));
+
+      await expect(transport.acquire({ uuid })).rejects.toMatchObject({ errorCode });
+      expect(pairDeviceMock).not.toHaveBeenCalled();
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+    }
+  );
+
+  test('closes the Android GATT link when system bonding fails', async () => {
+    setPlatformOS('android');
+    const { transport, uuid, device, bleManager } = createHarness();
+    const pairDeviceMock = jest.requireMock('../BleManager').pairDevice as jest.Mock;
+
+    pairDeviceMock.mockRejectedValueOnce(new Error('bonding canceled'));
+
+    await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toThrow(
+      'bonding canceled'
+    );
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(device.cancelConnection).toHaveBeenCalledTimes(1);
+  });
+
   test('uses withResponse for consecutive iOS Protocol V1 control commands without releasing', async () => {
     const { transport, uuid, writeCharacteristic } = createV1Harness({
       respondOnWriteCount: [1, 2],
@@ -405,6 +538,22 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.release(uuid, true);
   });
 
+  test('keeps native stale-bond write mapping out of Protocol V1 calls', async () => {
+    const { transport, uuid, writeCharacteristic } = createV1Harness();
+    const nativeError = Object.assign(new Error('Encryption is insufficient'), {
+      attErrorCode: 15,
+      reason: 'Encryption is insufficient',
+    });
+
+    await transport.acquire({ uuid, expectedProtocol: 'V1' });
+    writeCharacteristic.writeWithResponse.mockRejectedValueOnce(nativeError);
+
+    await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 50 })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleWriteCharacteristicError,
+    });
+    await transport.release(uuid, true);
+  });
+
   test('detects Protocol V2 on iOS without using the BLE name as a protocol hint', async () => {
     const { transport, uuid, device, sentSeqs, writeCharacteristic } = createHarness({
       deviceName: 'Pro2 6E9E',
@@ -415,7 +564,8 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       protocolType: 'V2',
     });
     expect(device.requestMTU).toHaveBeenCalledWith(247);
-    expect(writeCharacteristic.writeWithResponse.mock.calls.length).toBeGreaterThan(1);
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalled();
 
     await expect(
       transport.call(uuid, 'Ping', { message: 'first-core-command' })
@@ -424,6 +574,93 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.release(uuid, true);
   });
 
+  test('physically refreshes an uncached Protocol V2 firmware install link without Ping', async () => {
+    const { transport, uuid, device, bleManager, writeCharacteristic } = createHarness();
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+    (transport as any).sessionProtocols.set(uuid, 'V2');
+    device.connect = jest.fn().mockResolvedValue(device);
+    device.isConnected.mockResolvedValueOnce(false);
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(device.cancelConnection).not.toHaveBeenCalled();
+    expect(device.connect).toHaveBeenCalled();
+    expect(probeProtocolV2).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    expect(transport.getProtocolType(uuid)).toBe('V2');
+    await transport.release(uuid, true);
+  });
+
+  test('refreshes a cached firmware install connection instead of trusting GATT state', async () => {
+    const { transport, uuid, device, bleManager, writeCharacteristic } = createHarness();
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    device.connect = jest.fn().mockResolvedValue(device);
+    device.isConnected.mockResolvedValueOnce(false);
+    writeCharacteristic.writeWithResponse.mockClear();
+    writeCharacteristic.writeWithoutResponse.mockClear();
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(device.cancelConnection).toHaveBeenCalled();
+    expect(device.connect).toHaveBeenCalled();
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
+  test('rejects no-probe acquire before the BLE endpoint has confirmed a protocol', async () => {
+    const { transport, uuid } = createHarness();
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).rejects.toThrow('previously confirmed protocol');
+
+    expect(transport.getProtocolType(uuid)).toBeUndefined();
+  });
+
+  test('keeps confirmed V2 authorization across a BLE manager reset', async () => {
+    const { transport, uuid, device, bleManager, writeCharacteristic } = createHarness();
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+
+    (transport as any).resetPlxManager();
+    transport.blePlxManager = bleManager as any;
+    device.connect = jest.fn().mockResolvedValue(device);
+    device.isConnected.mockResolvedValueOnce(false);
+    writeCharacteristic.writeWithResponse.mockClear();
+    writeCharacteristic.writeWithoutResponse.mockClear();
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
   test.each(['ios', 'android'] as const)(
     'keeps a first expected Protocol V2 probe miss retryable on %s',
     async platform => {
@@ -459,8 +696,37 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     }
   );
 
+  test.each([
+    [
+      'Encryption is insufficient',
+      { reason: 'Encryption is insufficient', attErrorCode: 15 },
+      HardwareErrorCode.BleDeviceBondError,
+    ],
+    [
+      'Peer removed pairing information',
+      { reason: 'Peer removed pairing information', iosErrorCode: 14 },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+  ] as const)(
+    'fails Protocol V2 acquire immediately on %s instead of waiting for Ping',
+    async (_label, nativeError, errorCode) => {
+      const { transport, uuid, device } = createHarness({
+        monitorError: Object.assign(new Error(nativeError.reason), nativeError),
+      });
+      const probe = jest.spyOn(transport as any, 'probeProtocolV2');
+
+      await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+        errorCode,
+      });
+
+      expect(probe).not.toHaveBeenCalled();
+      expect(device.cancelConnection).toHaveBeenCalled();
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+    }
+  );
+
   test.each(['ios', 'android'] as const)(
-    'reports a stale bond on %s when a previously confirmed Protocol V2 device stops responding',
+    'keeps a confirmed Protocol V2 probe miss retryable on %s without native bond evidence',
     async platform => {
       setPlatformOS(platform);
       const { transport, uuid, device } = createHarness();
@@ -469,10 +735,10 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       jest.spyOn(transport as any, 'probeProtocolV2').mockResolvedValue(false);
 
       await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.BleDeviceBondError,
+        errorCode: HardwareErrorCode.RuntimeError,
       });
 
-      expect(device.cancelConnection).toHaveBeenCalled();
+      expect(device.cancelConnection).not.toHaveBeenCalled();
       expect(transport.getProtocolType(uuid)).toBeUndefined();
     }
   );
@@ -658,7 +924,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     });
     expect(device.requestMTU).toHaveBeenCalledTimes(3);
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBeUndefined();
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalled();
     await transport.release(uuid, true);
   });
 
@@ -667,6 +933,7 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     device.mtu = undefined;
 
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    const writesBeforeFileWrite = writeCharacteristic.writeWithoutResponse.mock.calls.length;
     device.requestMTU.mockImplementationOnce(() => {
       device.mtu = 247;
       return Promise.resolve(device);
@@ -674,7 +941,9 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
 
     await expect(transport.call(uuid, 'FileWrite', {})).resolves.toBeDefined();
     expect(device.requestMTU).toHaveBeenCalledTimes(4);
-    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(
+      writesBeforeFileWrite + 1
+    );
     await transport.release(uuid, true);
   });
 
@@ -683,12 +952,13 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     device.mtu = undefined;
 
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    const writesBeforeFileWrite = writeCharacteristic.writeWithoutResponse.mock.calls.length;
 
     await expect(transport.call(uuid, 'FileWrite', {})).rejects.toMatchObject({
       errorCode: HardwareErrorCode.BleConnectedError,
     });
     expect(device.requestMTU).toHaveBeenCalledTimes(4);
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(writesBeforeFileWrite);
     await transport.release(uuid, true);
   });
 
@@ -808,19 +1078,19 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.release(uuid, true);
   });
 
-  test('uses withResponse for consecutive iOS Protocol V2 control calls without releasing', async () => {
+  test('uses withoutResponse for consecutive iOS Protocol V2 control calls without releasing', async () => {
     const { transport, uuid, writeCharacteristic } = createHarness();
 
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
     const releaseNative = jest.spyOn(transport as any, 'releaseNative');
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
 
     await transport.call(uuid, 'DeviceInfoGet', {});
     await transport.call(uuid, 'ProtocolInfoRequest', {});
 
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(3);
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(3);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
     expect(releaseNative).not.toHaveBeenCalled();
 
     await transport.release(uuid, true);
@@ -833,8 +1103,8 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
 
     await transport.call(uuid, 'FileWrite', {});
     await transport.call(uuid, 'FileWrite', {});
-    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(2);
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(3);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
     expect(
       logger.debug.mock.calls.filter(
         ([message]) =>
@@ -867,8 +1137,8 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.acquire({ uuid, expectedProtocol: 'V2' });
 
     await transport.call(uuid, 'FileWrite', {}, { writeWithResponse: true });
-    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(2);
-    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
     await transport.release(uuid, true);
   });
 

package/src/bleStaleBond.ts

@@ -0,0 +1,64 @@
+import {
+  ERRORS,
+  HardwareErrorCode,
+  isBleStaleBondErrorText,
+  isBleStaleBondHardwareError,
+} from '@onekeyfe/hd-shared';
+
+export { isBleStaleBondHardwareError };
+
+const ATT_INSUFFICIENT_AUTHENTICATION = 5;
+const ATT_INSUFFICIENT_ENCRYPTION = 15;
+const IOS_PEER_REMOVED_PAIRING_INFORMATION = 14;
+
+type NativeBleErrorFields = {
+  attErrorCode?: unknown;
+  androidErrorCode?: unknown;
+  iosErrorCode?: unknown;
+  reason?: unknown;
+  message?: unknown;
+};
+
+const nativeErrorText = (error: NativeBleErrorFields) =>
+  [error.reason, error.message]
+    .filter((value): value is string => typeof value === 'string')
+    .join(' ');
+
+export const isNativeBleStaleBondError = (error: unknown): boolean => {
+  if (!error || typeof error !== 'object') {
+    return typeof error === 'string' ? isBleStaleBondErrorText(error) : false;
+  }
+
+  const nativeError = error as NativeBleErrorFields;
+  if (
+    nativeError.attErrorCode === ATT_INSUFFICIENT_AUTHENTICATION ||
+    nativeError.attErrorCode === ATT_INSUFFICIENT_ENCRYPTION ||
+    nativeError.androidErrorCode === ATT_INSUFFICIENT_AUTHENTICATION ||
+    nativeError.androidErrorCode === ATT_INSUFFICIENT_ENCRYPTION ||
+    nativeError.iosErrorCode === IOS_PEER_REMOVED_PAIRING_INFORMATION
+  ) {
+    return true;
+  }
+
+  return isBleStaleBondErrorText(nativeErrorText(nativeError));
+};
+
+export const toBleStaleBondHardwareError = (error: unknown) => {
+  if (isBleStaleBondHardwareError(error)) {
+    return error as Error;
+  }
+
+  const nativeError = (error ?? {}) as NativeBleErrorFields;
+  const text = nativeErrorText(nativeError);
+  const normalizedText = text.toLowerCase();
+  const peerRemoved =
+    nativeError.iosErrorCode === IOS_PEER_REMOVED_PAIRING_INFORMATION ||
+    normalizedText.includes('peer removed pairing information');
+
+  return ERRORS.TypedError(
+    peerRemoved
+      ? HardwareErrorCode.BlePeerRemovedPairingInformation
+      : HardwareErrorCode.BleDeviceBondError,
+    text || undefined
+  );
+};

package/src/bleStrategy.ts

@@ -34,8 +34,6 @@ export function shouldRefreshNegotiatedMtu(mtu?: number | null) {
 }
 
 export function shouldWriteProtocolV2WithResponse({
-  platform,
-  highThroughput,
   requestedWithResponse,
   characteristic,
 }: {
@@ -46,5 +44,5 @@ export function shouldWriteProtocolV2WithResponse({
 }) {
   if (!characteristic.isWritableWithResponse) return false;
   if (!characteristic.isWritableWithoutResponse) return true;
-  return requestedWithResponse === true || (platform === 'ios' && !highThroughput);
+  return requestedWithResponse === true;
 }