@onekeyfe/hd-transport-react-native 1.2.0-alpha.68 → 1.2.0-alpha.69

package/src/index.ts

@@ -5,6 +5,7 @@ import {
   BleError,
   BleErrorCode,
   BleManager as BlePlxManager,
+  ConnectionPriority,
   ScanMode,
 } from 'react-native-ble-plx';
 import ByteBuffer from 'bytebuffer';
@@ -32,11 +33,17 @@ import {
 } from '@onekeyfe/hd-shared';
 
 import { getConnectedDeviceIds, onDeviceBondState, pairDevice } from './BleManager';
-import { hasWritableCapability, resolveProtocolV2PacketCapacity } from './bleStrategy';
+import {
+  hasWritableCapability,
+  resolveProtocolV2PacketCapacity,
+  shouldWriteProtocolV2WithResponse,
+} from './bleStrategy';
 import { subscribeBleOn } from './subscribeBleOn';
 import {
   ANDROID_PACKET_LENGTH,
+  ANDROID_PROTOCOL_V2_PACKET_LENGTH,
   IOS_PACKET_LENGTH,
+  IOS_PROTOCOL_V2_PACKET_LENGTH,
   getBluetoothServiceUuids,
   getInfosForServiceUuid,
   isSameBleUuid,
@@ -61,7 +68,6 @@ const FIRMWARE_UPLOAD_WRITE_BURST_SIZE = Platform.OS === 'ios' ? 4 : 5;
 const FIRMWARE_UPLOAD_WRITE_PAUSE_MS = Platform.OS === 'ios' ? 8 : 10;
 const FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS = Platform.OS === 'ios' ? 24 : 30;
 const FIRMWARE_UPLOAD_WRITE_MAX_RETRIES = 8;
-const IOS_PROTOCOL_V2_CONTROL_WRITE_DELAY_MS = 5;
 const ANDROID_FIRMWARE_UPLOAD_PACKET_LENGTH = 192;
 const FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY =
   Platform.OS === 'ios' ? IOS_PACKET_LENGTH : ANDROID_FIRMWARE_UPLOAD_PACKET_LENGTH;
@@ -135,22 +141,6 @@ const resolveFirmwareUploadRetryDelay = (attempt: number, baseDelayMs = 200, max
   Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
 const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
 const PROTOCOL_V2_PROBE_TIMEOUT_MS = 10_000;
-/**
- * Per-packet write budget. iOS only resolves writeWithoutResponse once CoreBluetooth
- * reports the peripheral ready again; a peripheral wedged by its own firmware reboot
- * stops reporting ready while staying connected, so the write promise never settles.
- * Response timeouts cannot cover that — they are armed after the writes complete —
- * and an unbounded write leaves the whole transport unusable until the process dies.
- * A healthy packet completes in milliseconds, so this only fires on a dead link.
- */
-export const BLE_WRITE_PACKET_TIMEOUT_MS = 10_000;
-const WEDGED_WRITE_MESSAGE = 'BLE write timeout after';
-const isWedgedWriteError = (error: unknown): boolean =>
-  (error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleWriteCharacteristicError &&
-  typeof (error as { message?: unknown })?.message === 'string' &&
-  (error as { message: string }).message.startsWith(WEDGED_WRITE_MESSAGE);
-/** Consecutive wedged writes on one device before the BLE manager itself is recreated. */
-export const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
 const IOS_NOTIFY_READY_DELAY_MS = 150;
 const ANDROID_NOTIFY_READY_DELAY_MS = 300;
@@ -162,8 +152,8 @@ export type ProtocolV2BleTuning = {
 type ResolvedProtocolV2BleTuning = Required<ProtocolV2BleTuning>;
 
 const DEFAULT_PROTOCOL_V2_BLE_TUNING: ResolvedProtocolV2BleTuning = {
-  iosPacketLength: IOS_PACKET_LENGTH,
-  androidPacketLength: ANDROID_PACKET_LENGTH,
+  iosPacketLength: IOS_PROTOCOL_V2_PACKET_LENGTH,
+  androidPacketLength: ANDROID_PROTOCOL_V2_PACKET_LENGTH,
 };
 
 let protocolV2BleTuning: ResolvedProtocolV2BleTuning = { ...DEFAULT_PROTOCOL_V2_BLE_TUNING };
@@ -205,54 +195,21 @@ function getDeviceDisplayName(device?: Device | null) {
   return device?.name || device?.localName || null;
 }
 
-const ANDROID_REQUEST_MTU = 256;
+const IOS_REQUEST_MTU = 247;
+const ANDROID_REQUEST_MTU = 517;
+const BLE_MTU_REFRESH_THRESHOLD = 247;
+const BLE_MTU_REFRESH_RETRY_DELAY_MS = 200;
+const ANDROID_HIGH_PRIORITY_IDLE_MS = 1000;
 
-const BLE_NATIVE_CONNECT_TIMEOUT_MS = 3000;
+const getRequestedBleMtu = () =>
+  Platform.OS === 'android' ? ANDROID_REQUEST_MTU : IOS_REQUEST_MTU;
 
 const connectOptions: Record<string, unknown> = {
-  requestMTU: ANDROID_REQUEST_MTU,
-  timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
+  requestMTU: getRequestedBleMtu(),
+  timeout: 3000,
   refreshGatt: 'OnConnected',
 };
 
-/** Fallback connect options: drops requestMTU (the thing being worked around) but keeps the native budget. */
-const fallbackConnectOptions: Record<string, unknown> = {
-  timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
-};
-
-/**
- * JS backstop for connect. The native adapter applies its own 3s budget, but it
- * schedules that timeout on its serial queue, so a busy queue (e.g. right after a
- * firmware install tears the link down) can leave the promise unsettled — observed
- * blocking a reconnect for 61s until the app-level timeout. Healthy connects finish
- * inside the native budget, so this only fires when the native timeout did not.
- */
-export const BLE_CONNECT_TIMEOUT_MS = BLE_NATIVE_CONNECT_TIMEOUT_MS * 2 + 2000;
-/**
- * Service discovery and characteristic resolution run after connect() succeeds, but
- * CoreBluetooth schedules them on the same serial queue. If that queue is wedged by a
- * device reboot, these calls can remain pending forever unless they have their own
- * budget.
- */
-export const BLE_GATT_SETUP_TIMEOUT_MS = 10_000;
-/**
- * How many times a known device may fail its own protocol before we probe the others
- * again. Reconnect polling during a device reboot repeats this every few seconds, and
- * probing Protocol V2 costs a 10s Ping timeout, so paying it on every attempt for a
- * device we just spoke V1 to dominates the wait. A firmware update can legitimately
- * change a device's protocol, so the shortcut has to expire rather than stick.
- */
-export const PROTOCOL_REPROBE_FALLBACK_ATTEMPTS = 3;
-/** BLE setup timeouts since the last successful setup before the manager is recreated. */
-export const BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
-const CONNECT_TIMEOUT_MESSAGE = 'BLE connect timeout after';
-const isConnectTimeoutError = (error: unknown): boolean =>
-  (error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleConnectedError &&
-  typeof (error as { message?: unknown })?.message === 'string' &&
-  (error as { message: string }).message.startsWith(CONNECT_TIMEOUT_MESSAGE);
-const isNativeOperationTimeoutError = (error: unknown): boolean =>
-  (error as { errorCode?: unknown })?.errorCode === BleErrorCode.OperationTimedOut;
-
 export type IOneKeyDevice = OneKeyDeviceInfoBase & Device;
 
 const tryToGetConfiguration = (device: Device) => {
@@ -264,23 +221,32 @@ const tryToGetConfiguration = (device: Device) => {
   return infos;
 };
 
-const requestAndroidMtu = async (device: Device) => {
-  if (Platform.OS !== 'android') return device;
+const requestNegotiatedMtu = async (
+  device: Device,
+  stage: 'connected' | 'servicesAndNotifyReady',
+  attempt: number
+) => {
+  if (Platform.OS !== 'ios' && Platform.OS !== 'android') return device;
 
   try {
-    const mtuDevice = await device.requestMTU(ANDROID_REQUEST_MTU);
-    Log?.debug('[ReactNativeBleTransport] MTU configured', {
-      deviceId: device.id,
-      requested: ANDROID_REQUEST_MTU,
-      actual: mtuDevice.mtu,
-    });
+    // iOS ignores the requested value but react-native-ble-plx returns a fresh
+    // Device snapshot whose MTU is derived from CoreBluetooth's maximum write length.
+    const mtuDevice = await device.requestMTU(getRequestedBleMtu());
     return mtuDevice;
   } catch (error) {
-    Log?.debug('[ReactNativeBleTransport] Android MTU request failed:', error);
+    Log?.debug('[ReactNativeBleTransport] MTU refresh failed, continuing with current value', {
+      platform: Platform.OS,
+      stage,
+      attempt,
+      actual: device.mtu,
+      error: error instanceof Error ? error.message : String(error),
+    });
     return device;
   }
 };
 
+const resolveNegotiatedMtu = (device: Device) => requestNegotiatedMtu(device, 'connected', 0);
+
 type IOBleErrorRemap = Error | BleError | null | undefined;
 
 function remapError(error: IOBleErrorRemap) {
@@ -341,28 +307,8 @@ export default class ReactNativeBleTransport {
   /** Per-device protocol type detected by active wire-level probe after connect. */
   private deviceProtocol: Map<string, ProtocolType> = new Map();
 
-  /**
-   * Protocol a probe is currently trying, before the device has confirmed it. Calls
-   * must route with it, but acquire() must not treat it as a detected protocol: a
-   * probe that never answers would otherwise leave the reuse fast path handing out a
-   * transport that was never validated.
-   */
-  private probingProtocols: Map<string, ProtocolType> = new Map();
-
-  /** Consecutive write timeouts per device; reset by any write that completes. */
-  private writeTimeoutCounts: Map<string, number> = new Map();
-
-  /** BLE setup timeouts per device since the last complete characteristic resolution. */
-  private connectionSetupTimeoutCounts: Map<string, number> = new Map();
-
   private deviceProtocolHints: Map<string, ProtocolType> = new Map();
 
-  /** Protocol this device actually answered on, kept across reconnects of one session. */
-  private sessionProtocols: Map<string, ProtocolType> = new Map();
-
-  /** Consecutive detections that failed while trusting sessionProtocols. */
-  private protocolReprobeFailures: Map<string, number> = new Map();
-
   private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
 
   private protocolV2FrameQueues: Map<string, Uint8Array[]> = new Map();
@@ -394,6 +340,12 @@ export default class ReactNativeBleTransport {
 
   private disconnectEventTokens: Map<string, number> = new Map();
 
+  private protocolV2HighVolumeLogSignatures: Map<string, Set<string>> = new Map();
+
+  private androidHighPriorityDevices: Set<string> = new Set();
+
+  private androidPriorityResetTimers: Map<string, ReturnType<typeof setTimeout>> = new Map();
+
   private nextMonitorToken = 1;
 
   constructor(options: TransportOptions) {
@@ -580,21 +532,22 @@ export default class ReactNativeBleTransport {
       const isConnected = await device.isConnected().catch(() => false);
       if (!isConnected) {
         try {
-          device = await this.connectWithTimeout(uuid, () => device.connect(connectOptions));
+          device = await device.connect(connectOptions);
         } catch (e) {
           if (
             e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
             e.errorCode === BleErrorCode.OperationCancelled
           ) {
-            device = await this.connectWithTimeout(uuid, () => device.connect());
+            device = await device.connect();
           } else if (e.errorCode !== BleErrorCode.DeviceAlreadyConnected) {
             throw e;
           }
         }
       }
 
-      const { writeCharacteristic, notifyCharacteristic } =
-        await this.resolveCharacteristicsWithTimeout(uuid, device);
+      const { writeCharacteristic, notifyCharacteristic } = await this.resolveCharacteristics(
+        device
+      );
 
       transport.device = device;
       transport.writeCharacteristic = writeCharacteristic;
@@ -773,11 +726,9 @@ export default class ReactNativeBleTransport {
     characteristics?: ResolvedBleCharacteristics
   ) {
     const { writeCharacteristic, notifyCharacteristic } =
-      characteristics ?? (await this.resolveCharacteristicsWithTimeout(uuid, device));
+      characteristics ?? (await this.resolveCharacteristics(device));
     const transport = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
-    if (Platform.OS === 'android') {
-      transport.mtuSize = typeof device.mtu === 'number' ? device.mtu : transport.mtuSize;
-    }
+    transport.mtuSize = typeof device.mtu === 'number' ? device.mtu : undefined;
     const monitorToken = this.nextMonitorToken;
     this.nextMonitorToken += 1;
     const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
@@ -791,6 +742,7 @@ export default class ReactNativeBleTransport {
       notifyTransactionId
     );
     transportCache[uuid] = transport;
+    this.protocolV2HighVolumeLogSignatures.set(uuid, new Set());
     this.protocolV2Assemblers.set(
       uuid,
       new ProtocolV2FrameAssembler(PROTOCOL_V2_BLE_FRAME_MAX_BYTES)
@@ -804,6 +756,40 @@ export default class ReactNativeBleTransport {
       await delay(ANDROID_NOTIFY_READY_DELAY_MS);
     }
 
+    const initialMtu = transport.mtuSize;
+    let refreshAttempts = 0;
+    if (
+      (Platform.OS === 'ios' || Platform.OS === 'android') &&
+      (typeof transport.mtuSize !== 'number' || transport.mtuSize < BLE_MTU_REFRESH_THRESHOLD)
+    ) {
+      refreshAttempts += 1;
+      let refreshedDevice = await requestNegotiatedMtu(
+        transport.device,
+        'servicesAndNotifyReady',
+        1
+      );
+      transport.device = refreshedDevice;
+      transport.mtuSize =
+        typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport.mtuSize;
+
+      if (typeof transport.mtuSize !== 'number' || transport.mtuSize < BLE_MTU_REFRESH_THRESHOLD) {
+        await delay(BLE_MTU_REFRESH_RETRY_DELAY_MS);
+        refreshAttempts += 1;
+        refreshedDevice = await requestNegotiatedMtu(transport.device, 'servicesAndNotifyReady', 2);
+        transport.device = refreshedDevice;
+        transport.mtuSize =
+          typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport.mtuSize;
+      }
+    }
+
+    Log?.debug('[ReactNativeBleTransport] BLE MTU ready', {
+      platform: Platform.OS,
+      requested: getRequestedBleMtu(),
+      initial: initialMtu,
+      actual: transport.mtuSize,
+      refreshAttempts,
+    });
+
     return transport;
   }
 
@@ -877,22 +863,15 @@ export default class ReactNativeBleTransport {
     if (!device) {
       Log?.debug('try to connect to device: ', uuid);
       try {
-        device = await this.connectWithTimeout(uuid, () =>
-          blePlxManager.connectToDevice(uuid, connectOptions)
-        );
+        device = await blePlxManager.connectToDevice(uuid, connectOptions);
       } catch (e) {
         Log?.debug('try to connect to device has error: ', e);
-        if (isConnectTimeoutError(e)) {
-          throw e;
-        }
         if (
           e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
           e.errorCode === BleErrorCode.OperationCancelled
         ) {
           Log?.debug('first try to reconnect without params');
-          device = await this.connectWithTimeout(uuid, () =>
-            blePlxManager.connectToDevice(uuid, fallbackConnectOptions)
-          );
+          device = await blePlxManager.connectToDevice(uuid);
         } else if (e.errorCode === BleErrorCode.DeviceAlreadyConnected) {
           Log?.debug('device already connected');
           throw ERRORS.TypedError(HardwareErrorCode.BleAlreadyConnected);
@@ -908,36 +887,26 @@ export default class ReactNativeBleTransport {
 
     if (!(await device.isConnected())) {
       Log?.debug('not connected, try to connect to device: ', uuid);
-      const disconnectedDevice = device;
 
       try {
-        device = await this.connectWithTimeout(uuid, () =>
-          disconnectedDevice.connect(connectOptions)
-        );
+        device = await device.connect(connectOptions);
       } catch (e) {
         Log?.debug('not connected, try to connect to device has error: ', e);
-        if (isConnectTimeoutError(e)) {
-          throw e;
-        }
         if (
           e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
           e.errorCode === BleErrorCode.OperationCancelled
         ) {
           Log?.debug('second try to reconnect without params');
           try {
-            device = await this.connectWithTimeout(uuid, () =>
-              disconnectedDevice.connect(fallbackConnectOptions)
-            );
+            device = await device.connect();
           } catch (e) {
             Log?.debug('last try to reconnect error: ', e);
             // last try to reconnect device if this issue exists
             // https://github.com/dotintent/react-native-ble-plx/issues/426
             if (e.errorCode === BleErrorCode.OperationCancelled) {
               Log?.debug('last try to reconnect');
-              await disconnectedDevice.cancelConnection();
-              device = await this.connectWithTimeout(uuid, () =>
-                disconnectedDevice.connect(fallbackConnectOptions)
-              );
+              await device.cancelConnection();
+              device = await device.connect();
             }
           }
         } else {
@@ -946,10 +915,11 @@ export default class ReactNativeBleTransport {
       }
     }
 
-    device = await requestAndroidMtu(device);
+    device = await resolveNegotiatedMtu(device);
     const acquiredDevice = device;
-    const { writeCharacteristic, notifyCharacteristic } =
-      await this.resolveCharacteristicsWithTimeout(uuid, acquiredDevice);
+    const { writeCharacteristic, notifyCharacteristic } = await this.resolveCharacteristics(
+      acquiredDevice
+    );
 
     const protocolHint = expectedProtocol
       ? undefined
@@ -981,7 +951,7 @@ export default class ReactNativeBleTransport {
       if (!currentTransport) {
         throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
       }
-      this.attachDisconnectSubscription(currentTransport, acquiredDevice, uuid);
+      this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
       return { uuid, protocolType };
     } catch (error) {
       await this.release(uuid, true);
@@ -1013,7 +983,7 @@ export default class ReactNativeBleTransport {
           Log?.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
           return;
         }
-        if (this.getActiveProtocol(uuid) === 'V2') {
+        if (this.deviceProtocol.get(uuid) === 'V2') {
           let errorCode:
             | typeof HardwareErrorCode.BleDeviceBondError
             | typeof HardwareErrorCode.BleCharacteristicNotifyError
@@ -1083,7 +1053,7 @@ export default class ReactNativeBleTransport {
 
       try {
         const data = Buffer.from(c.value as string, 'base64');
-        const protocol = this.getActiveProtocol(uuid);
+        const protocol = this.deviceProtocol.get(uuid);
         if (!protocol) {
           Log?.debug('monitor data ignored before protocol detection: ', uuid);
           return;
@@ -1117,7 +1087,7 @@ export default class ReactNativeBleTransport {
       } catch (error) {
         Log?.debug('monitor data error: ', error);
         const notifyError = ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
-        if (this.getActiveProtocol(uuid) === 'V2') {
+        if (this.deviceProtocol.get(uuid) === 'V2') {
           this.rejectProtocolV2Frames(uuid, notifyError);
         } else if (this.runPromiseDeviceId === uuid) {
           this.runPromise?.reject(notifyError);
@@ -1151,6 +1121,8 @@ export default class ReactNativeBleTransport {
       return Promise.resolve(true);
     }
 
+    await this.restoreAndroidConnectionPriority(uuid, transport);
+
     if (transport) {
       if (this.monitorTokens.get(uuid) === transport.monitorToken) {
         this.monitorTokens.delete(uuid);
@@ -1180,8 +1152,9 @@ export default class ReactNativeBleTransport {
       delete transportCache[uuid];
     }
 
+    this.protocolV2HighVolumeLogSignatures.delete(uuid);
+
     this.deviceProtocol.delete(uuid);
-    this.probingProtocols.delete(uuid);
     // Preserve a name-derived hint across disconnects so reconnect can probe V2 first.
     this.protocolV2Assemblers.get(uuid)?.reset();
     this.protocolV2Assemblers.delete(uuid);
@@ -1248,25 +1221,8 @@ export default class ReactNativeBleTransport {
     const transport = this.getCachedTransport(uuid);
     const runPromise = createDeferred<string>();
     runPromise.promise.catch(() => undefined);
-    const supersededRunPromise = this.runPromise;
-    if (supersededRunPromise) {
-      // Only forceRun calls (Initialize/Cancel) reach here with a pending call. Settle
-      // the superseded deferred now so its response race resolves and its finally block
-      // clears its timeout timer; an orphaned timer would otherwise fire much later and
-      // tear down the shared connection while another call is using it.
-      supersededRunPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise));
-    }
     this.runPromise = runPromise;
     this.runPromiseDeviceId = uuid;
-    // A superseded call's late write failure must not clear the successor's ownership;
-    // only the call that still owns the slot may release it.
-    const releaseOwnershipIfCurrent = () => {
-      if (this.runPromise === runPromise) {
-        this.runPromise = null;
-        this.runPromiseDeviceId = null;
-      }
-    };
-    const isCurrentOwner = () => this.runPromise === runPromise;
     const messages = this._messages;
     const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
     let timeout: ReturnType<typeof setTimeout> | undefined;
@@ -1292,9 +1248,6 @@ export default class ReactNativeBleTransport {
             chunk = ByteBuffer.allocate(packetCapacity);
           } catch (e) {
             onError(e);
-            if (isWedgedWriteError(e)) {
-              throw e;
-            }
             throw ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
           }
         }
@@ -1326,9 +1279,6 @@ export default class ReactNativeBleTransport {
             }
           } catch (e) {
             onError(e);
-            if (isWedgedWriteError(e)) {
-              throw e;
-            }
             throw ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
           }
         }
@@ -1342,15 +1292,9 @@ export default class ReactNativeBleTransport {
     if (name === 'EmmcFileWrite') {
       await writeChunkedData(
         buffers,
-        data =>
-          this.writeBlePacket(
-            uuid,
-            data,
-            payload => transport.writeWithRetry(payload),
-            isCurrentOwner
-          ),
+        data => transport.writeWithRetry(data),
         e => {
-          releaseOwnershipIfCurrent();
+          this.runPromise = null;
           Log?.error('writeCharacteristic write error: ', e);
         }
       );
@@ -1371,12 +1315,7 @@ export default class ReactNativeBleTransport {
           // eslint-disable-next-line no-constant-condition
           while (true) {
             try {
-              await this.writeBlePacket(
-                uuid,
-                data,
-                payload => transport.writeWithRetry(payload),
-                isCurrentOwner
-              );
+              await transport.writeWithRetry(data);
               return;
             } catch (error) {
               const retryType = getFirmwareUploadWriteRetryType(error);
@@ -1395,7 +1334,7 @@ export default class ReactNativeBleTransport {
           }
         },
         e => {
-          releaseOwnershipIfCurrent();
+          this.runPromise = null;
           Log?.error('writeCharacteristic write error: ', e);
         }
       );
@@ -1406,21 +1345,14 @@ export default class ReactNativeBleTransport {
         try {
           const shouldUseWriteWithResponse =
             Platform.OS === 'ios' && transport.writeCharacteristic.isWritableWithResponse;
-          await this.writeBlePacket(
-            uuid,
-            outData,
-            payload =>
-              shouldUseWriteWithResponse
-                ? transport.writeCharacteristic.writeWithResponse(payload)
-                : transport.writeCharacteristic.writeWithoutResponse(payload),
-            isCurrentOwner
-          );
+          if (shouldUseWriteWithResponse) {
+            await transport.writeCharacteristic.writeWithResponse(outData);
+          } else {
+            await transport.writeCharacteristic.writeWithoutResponse(outData);
+          }
         } catch (e) {
           Log?.debug('writeCharacteristic write error: ', e);
-          releaseOwnershipIfCurrent();
-          if (isWedgedWriteError(e)) {
-            throw e;
-          }
+          this.runPromise = null;
           if (e.errorCode === BleErrorCode.DeviceDisconnected) {
             throw ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded);
           } else if (e.errorCode === BleErrorCode.OperationStartFailed) {
@@ -1463,13 +1395,8 @@ export default class ReactNativeBleTransport {
       }
       const isProbeTimeout =
         name === 'GetFeatures' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS;
-      // A call that has been superseded (forceRun) or cleaned up no longer owns the
-      // transport; its late timeout must not tear down the connection the current
-      // call is actively using.
-      const isStaleCall = this.runPromise !== runPromise;
       if (
         !isProbeTimeout &&
-        !isStaleCall &&
         (e as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleTimeoutError
       ) {
         await this.disconnect(uuid);
@@ -1549,10 +1476,7 @@ export default class ReactNativeBleTransport {
       delete transportCache[session];
     }
     this.deviceProtocol.delete(session);
-    this.probingProtocols.delete(session);
     this.deviceProtocolHints.delete(session);
-    this.sessionProtocols.delete(session);
-    this.protocolReprobeFailures.delete(session);
     this.protocolV2Assemblers.delete(session);
     this.resetProtocolV2Frames(session);
 
@@ -1578,113 +1502,6 @@ export default class ReactNativeBleTransport {
     this.runPromiseDeviceId = null;
   }
 
-  /** Run a native connect under the JS backstop budget. */
-  private async connectWithTimeout<T>(uuid: string, connect: () => Promise<T>): Promise<T> {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    let timedOut = false;
-    const pending = connect();
-    // The abandoned attempt keeps running; swallow its late outcome so it cannot
-    // surface as an unhandled rejection after we have already given up on it.
-    pending.catch(() => undefined);
-    try {
-      const result = await Promise.race([
-        pending,
-        new Promise<never>((_, reject) => {
-          timer = setTimeout(() => {
-            timedOut = true;
-            reject(
-              ERRORS.TypedError(
-                HardwareErrorCode.BleConnectedError,
-                `BLE connect timeout after ${BLE_CONNECT_TIMEOUT_MS}ms for ${uuid}`
-              )
-            );
-          }, BLE_CONNECT_TIMEOUT_MS);
-        }),
-      ]);
-      return result;
-    } catch (error) {
-      if (timedOut || isNativeOperationTimeoutError(error)) {
-        this.abandonStalledConnection(uuid, timedOut ? 'connect-backstop' : 'connect-native');
-      }
-      throw error;
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
-
-  /** Resolve the complete GATT shape under a budget so acquire() always settles. */
-  private async resolveCharacteristicsWithTimeout(
-    uuid: string,
-    device: Device
-  ): Promise<ResolvedBleCharacteristics> {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    let timedOut = false;
-    const pending = this.resolveCharacteristics(device);
-    pending.catch(() => undefined);
-    try {
-      const result = await Promise.race([
-        pending,
-        new Promise<never>((_, reject) => {
-          timer = setTimeout(() => {
-            timedOut = true;
-            reject(
-              ERRORS.TypedError(
-                HardwareErrorCode.BleConnectedError,
-                `BLE GATT setup timeout after ${BLE_GATT_SETUP_TIMEOUT_MS}ms for ${uuid}`
-              )
-            );
-          }, BLE_GATT_SETUP_TIMEOUT_MS);
-        }),
-      ]);
-      this.connectionSetupTimeoutCounts.delete(uuid);
-      return result;
-    } catch (error) {
-      if (timedOut || isNativeOperationTimeoutError(error)) {
-        this.abandonStalledConnection(uuid, timedOut ? 'gatt-backstop' : 'gatt-native');
-      }
-      throw error;
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
-
-  /**
-   * Give up on a BLE setup operation the native layer did not settle. The abandoned
-   * operation still owns native connection/GATT state that can poison the next attempt,
-   * so it is cleared here without awaiting the same queue that stopped responding.
-   */
-  private abandonStalledConnection(
-    uuid: string,
-    stage: 'connect-backstop' | 'connect-native' | 'gatt-backstop' | 'gatt-native'
-  ) {
-    const timeouts = (this.connectionSetupTimeoutCounts.get(uuid) ?? 0) + 1;
-    this.connectionSetupTimeoutCounts.set(uuid, timeouts);
-    Log?.error('[ReactNativeBleTransport] BLE setup timed out:', uuid, {
-      stage,
-      setupTimeoutsSinceSuccess: timeouts,
-    });
-
-    this.blePlxManager?.cancelDeviceConnection(uuid).catch(() => {
-      // Rejects with "Operation was cancelled" while merely connecting — expected.
-    });
-    const stalled = transportCache[uuid];
-    if (stalled) {
-      delete transportCache[uuid];
-    }
-    this.deviceProtocol.delete(uuid);
-    this.probingProtocols.delete(uuid);
-    this.protocolV2Assemblers.delete(uuid);
-    this.resetProtocolV2Frames(uuid);
-
-    if (timeouts >= BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD) {
-      // BleManager.destroy() force-rejects every promise the native queue abandoned —
-      // the only JS-reachable way to settle them — and drops all cached peripherals.
-      Log?.error('[ReactNativeBleTransport] BLE setup wedged repeatedly, resetting BLE manager');
-      this.resetPlxManager();
-      this.connectionSetupTimeoutCounts.delete(uuid);
-    }
-  }
-
   private getCachedTransport(uuid: string) {
     const transport = transportCache[uuid];
     if (!transport) {
@@ -1693,107 +1510,6 @@ export default class ReactNativeBleTransport {
     return transport;
   }
 
-  /**
-   * Write one packet under a bounded budget. A write that never settles means the
-   * peripheral is wedged even though the GATT link still reports connected, so the
-   * link is torn down: releasing JS state alone would leave the poisoned peripheral
-   * cached and every later call would hang on it again.
-   */
-  private async writeBlePacket(
-    uuid: string,
-    data: string,
-    write: (payload: string) => Promise<unknown>,
-    isCurrentOwner?: () => boolean
-  ) {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    let timedOut = false;
-    try {
-      await Promise.race([
-        write(data),
-        new Promise<never>((_, reject) => {
-          timer = setTimeout(() => {
-            timedOut = true;
-            reject(
-              ERRORS.TypedError(
-                HardwareErrorCode.BleWriteCharacteristicError,
-                `BLE write timeout after ${BLE_WRITE_PACKET_TIMEOUT_MS}ms`
-              )
-            );
-          }, BLE_WRITE_PACKET_TIMEOUT_MS);
-        }),
-      ]);
-      this.writeTimeoutCounts.delete(uuid);
-    } catch (error) {
-      if (timedOut) {
-        // A superseded call's late write must not tear down the link the current
-        // call is using; only the owner of the transport may declare it dead.
-        if (isCurrentOwner && !isCurrentOwner()) {
-          Log?.debug('[ReactNativeBleTransport] stale BLE write timed out, link kept:', uuid);
-        } else {
-          this.tearDownWedgedLink(uuid);
-        }
-      }
-      throw error;
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
-
-  /**
-   * Drop a link whose writes stopped completing. The JS state is purged synchronously
-   * so the next acquire() cannot reuse the dead transport, while the native teardown is
-   * intentionally NOT awaited: it talks to the very layer that just stopped settling
-   * promises, so awaiting it could hang exactly like the write it is recovering from.
-   */
-  private tearDownWedgedLink(uuid: string) {
-    const timeouts = (this.writeTimeoutCounts.get(uuid) ?? 0) + 1;
-    this.writeTimeoutCounts.set(uuid, timeouts);
-    Log?.error('[ReactNativeBleTransport] BLE write timed out, tearing down link:', uuid, {
-      consecutiveWriteTimeouts: timeouts,
-    });
-
-    const wedged = transportCache[uuid];
-    this.disconnect(uuid).catch(error => {
-      Log?.debug('[ReactNativeBleTransport] wedged link teardown failed (ignored):', error);
-    });
-    if (wedged && transportCache[uuid] === wedged) {
-      delete transportCache[uuid];
-    }
-    this.deviceProtocol.delete(uuid);
-    this.probingProtocols.delete(uuid);
-    this.protocolV2Assemblers.delete(uuid);
-    this.resetProtocolV2Frames(uuid);
-
-    if (timeouts >= BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD) {
-      // Reconnecting reuses the same native peripheral object. When it stays wedged
-      // across attempts the poison lives in the BLE manager itself, and only a fresh
-      // manager drops every cached peripheral — the JS equivalent of restarting the app.
-      Log?.error('[ReactNativeBleTransport] BLE writes wedged repeatedly, resetting BLE manager');
-      this.resetPlxManager();
-      this.writeTimeoutCounts.delete(uuid);
-    }
-  }
-
-  private resetPlxManager() {
-    const manager = this.blePlxManager;
-    this.blePlxManager = undefined;
-    // Every cached transport belongs to the destroyed manager's peripherals.
-    Object.keys(transportCache).forEach(key => {
-      delete transportCache[key];
-    });
-    this.deviceProtocol.clear();
-    this.probingProtocols.clear();
-    this.sessionProtocols.clear();
-    this.protocolReprobeFailures.clear();
-    this.monitorTokens.clear();
-    this.protocolV2Assemblers.clear();
-    try {
-      manager?.destroy();
-    } catch (error) {
-      Log?.debug('[ReactNativeBleTransport] BLE manager destroy failed (ignored):', error);
-    }
-  }
-
   private createProtocolMismatchError(expected: ProtocolType) {
     return ERRORS.TypedError(
       HardwareErrorCode.RuntimeError,
@@ -1809,19 +1525,11 @@ export default class ReactNativeBleTransport {
   }
 
   private clearProbeProtocol(uuid: string, protocol: ProtocolType) {
-    if (this.probingProtocols.get(uuid) === protocol) {
-      this.probingProtocols.delete(uuid);
-    }
     if (this.deviceProtocol.get(uuid) === protocol) {
       this.deviceProtocol.delete(uuid);
     }
   }
 
-  /** Protocol to route a call with: confirmed if known, otherwise the one being probed. */
-  private getActiveProtocol(uuid: string): ProtocolType | undefined {
-    return this.deviceProtocol.get(uuid) ?? this.probingProtocols.get(uuid);
-  }
-
   private async detectProtocol(
     uuid: string,
     expectedProtocol?: ProtocolType,
@@ -1841,7 +1549,6 @@ export default class ReactNativeBleTransport {
     if (expectedProtocol === 'V1') {
       if (await this.probeProtocolV1(uuid)) {
         this.deviceProtocol.set(uuid, 'V1');
-        this.sessionProtocols.set(uuid, 'V1');
         Log?.debug('[ReactNativeBleTransport] protocol detected', {
           deviceId: uuid,
           protocol: 'V1',
@@ -1855,7 +1562,6 @@ export default class ReactNativeBleTransport {
     if (expectedProtocol === 'V2') {
       if (await this.probeProtocolV2(uuid)) {
         this.deviceProtocol.set(uuid, 'V2');
-        this.sessionProtocols.set(uuid, 'V2');
         Log?.debug('[ReactNativeBleTransport] protocol detected', {
           deviceId: uuid,
           protocol: 'V2',
@@ -1868,18 +1574,8 @@ export default class ReactNativeBleTransport {
 
     // Protocol must be actively probed after connection. Name, PID, and descriptors only
     // influence probe order; a V2 hint probes V2 first and falls back to V1.
-    const sessionProtocol = this.sessionProtocols.get(uuid);
-    const reprobeFailures = this.protocolReprobeFailures.get(uuid) ?? 0;
-    const fullProbeOrder: ProtocolType[] =
+    const probeOrder: ProtocolType[] =
       protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
-    // A device that already answered on a protocol in this session keeps answering on
-    // it; while it is rebooting nothing answers at all, so probing the other protocol
-    // only adds its timeout to every poll.
-    const trustSessionProtocol =
-      sessionProtocol !== undefined &&
-      !protocolHint &&
-      reprobeFailures < PROTOCOL_REPROBE_FALLBACK_ATTEMPTS;
-    const probeOrder: ProtocolType[] = trustSessionProtocol ? [sessionProtocol] : fullProbeOrder;
 
     for (let i = 0; i < probeOrder.length; i += 1) {
       const protocol = probeOrder[i];
@@ -1897,8 +1593,6 @@ export default class ReactNativeBleTransport {
         protocol === 'V1' ? await this.probeProtocolV1(uuid) : await this.probeProtocolV2(uuid);
       if (detected) {
         this.deviceProtocol.set(uuid, protocol);
-        this.sessionProtocols.set(uuid, protocol);
-        this.protocolReprobeFailures.delete(uuid);
         Log?.debug('[ReactNativeBleTransport] protocol detected', {
           deviceId: uuid,
           protocol,
@@ -1908,16 +1602,7 @@ export default class ReactNativeBleTransport {
       }
     }
 
-    if (trustSessionProtocol) {
-      // Still silent on its own protocol: count it, and let the streak expire the
-      // shortcut so a device that genuinely switched protocols is found again.
-      this.protocolReprobeFailures.set(uuid, reprobeFailures + 1);
-    } else {
-      this.protocolReprobeFailures.delete(uuid);
-    }
-
     this.deviceProtocol.delete(uuid);
-    this.probingProtocols.delete(uuid);
     throw this.createProtocolDetectionError();
   }
 
@@ -1979,20 +1664,14 @@ export default class ReactNativeBleTransport {
     }
 
     try {
-      this.probingProtocols.set(uuid, 'V1');
+      this.deviceProtocol.set(uuid, 'V1');
       // GetFeatures identifies Protocol V1 without resetting an existing wallet
       // session before Core has a chance to restore a hidden wallet.
       await this.callProtocolV1(uuid, 'GetFeatures', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
-      this.probingProtocols.delete(uuid);
       return true;
     } catch (error) {
       this.clearProbeProtocol(uuid, 'V1');
       Log?.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe failed:', error);
-      // A wedged write already dropped the link, so probing another protocol on it
-      // would only fail against a torn-down transport: surface the real cause.
-      if (isWedgedWriteError(error)) {
-        throw error;
-      }
       return false;
     }
   }
@@ -2002,7 +1681,7 @@ export default class ReactNativeBleTransport {
       return false;
     }
 
-    this.probingProtocols.set(uuid, 'V2');
+    this.deviceProtocol.set(uuid, 'V2');
     this.protocolV2Assemblers.get(uuid)?.reset();
     const detected = await probeProtocolV2Helper({
       call: (name: string, data: Record<string, unknown>, options?: TransportCallOptions) =>
@@ -2017,8 +1696,6 @@ export default class ReactNativeBleTransport {
     });
     if (!detected) {
       this.clearProbeProtocol(uuid, 'V2');
-    } else {
-      this.probingProtocols.delete(uuid);
     }
     return detected;
   }
@@ -2100,15 +1777,17 @@ export default class ReactNativeBleTransport {
   }
 
   private async writeProtocolV2Packet(
-    uuid: string,
     transport: BleTransport,
     base64: string,
     context: ProtocolV2CallContext,
     assertCurrentGeneration: () => void
   ) {
-    const shouldUseWriteWithResponse =
-      transport.writeCharacteristic.isWritableWithResponse &&
-      (context.writeWithResponse === true || (Platform.OS === 'ios' && !context.highVolume));
+    const shouldUseWriteWithResponse = shouldWriteProtocolV2WithResponse({
+      platform: Platform.OS,
+      highVolume: context.highVolume,
+      requestedWithResponse: context.writeWithResponse,
+      characteristic: transport.writeCharacteristic,
+    });
     let attempt = 0;
     for (;;) {
       assertCurrentGeneration();
@@ -2116,24 +1795,11 @@ export default class ReactNativeBleTransport {
         throw new Error(`Protocol V2 BLE write aborted for ${context.messageName}`);
       }
       try {
-        await this.writeBlePacket(
-          uuid,
-          base64,
-          payload =>
-            shouldUseWriteWithResponse
-              ? transport.writeCharacteristic.writeWithResponse(payload)
-              : transport.writeCharacteristic.writeWithoutResponse(payload),
-          // Same rule as Protocol V1: a write from a superseded generation must not
-          // tear down the link that the current generation is using.
-          () => {
-            try {
-              assertCurrentGeneration();
-              return !context.signal.aborted;
-            } catch {
-              return false;
-            }
-          }
-        );
+        if (shouldUseWriteWithResponse) {
+          await transport.writeCharacteristic.writeWithResponse(base64);
+        } else {
+          await transport.writeCharacteristic.writeWithoutResponse(base64);
+        }
         assertCurrentGeneration();
         return;
       } catch (error) {
@@ -2156,7 +1822,6 @@ export default class ReactNativeBleTransport {
   }
 
   private async writeProtocolV2Frame(
-    uuid: string,
     transport: BleTransport,
     frame: Uint8Array,
     context: ProtocolV2CallContext,
@@ -2167,28 +1832,17 @@ export default class ReactNativeBleTransport {
       platform: Platform.OS,
       iosPacketLength: tuning.iosPacketLength,
       androidPacketLength: tuning.androidPacketLength,
-      mtu: Platform.OS === 'android' ? transport.mtuSize : undefined,
+      mtu: transport.mtuSize,
     });
-    // Match Desktop BLE pacing so Pro2 firmware can finish the previous response
-    // before the next single-packet control command is written.
-    const initialDelayMs =
-      Platform.OS === 'ios' && !context.highVolume && frame.length <= packetCapacity
-        ? IOS_PROTOCOL_V2_CONTROL_WRITE_DELAY_MS
-        : 0;
     await writeProtocolV2BleFrame({
       frame,
       packetCapacity,
       assertActive: assertCurrentGeneration,
       signal: context.signal,
       abortMessage: `Protocol V2 BLE write aborted for ${context.messageName}`,
-      initialDelayMs,
-      burstSize: FIRMWARE_UPLOAD_WRITE_BURST_SIZE,
-      burstPauseMs: FIRMWARE_UPLOAD_WRITE_PAUSE_MS,
-      flushDelayMs: FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS,
       wait: delay,
       writePacket: packet =>
         this.writeProtocolV2Packet(
-          uuid,
           transport,
           Buffer.from(packet).toString('base64'),
           context,
@@ -2212,11 +1866,39 @@ export default class ReactNativeBleTransport {
 
     if (highVolumeWrite) {
       const tuning = getProtocolV2BleTuning();
-      Log?.debug('[ReactNativeBleTransport] Protocol V2 high-volume write configured', {
-        name,
-        writeMode: options?.writeWithResponse ? 'withResponse' : 'withoutResponse',
-        packetCapacity: Platform.OS === 'ios' ? tuning.iosPacketLength : tuning.androidPacketLength,
+      const currentTransport = this.getCachedTransport(uuid);
+      const writeWithResponse = shouldWriteProtocolV2WithResponse({
+        platform: Platform.OS,
+        highVolume: true,
+        requestedWithResponse: options?.writeWithResponse,
+        characteristic: currentTransport.writeCharacteristic,
+      });
+      const packetCapacity = resolveProtocolV2PacketCapacity({
+        platform: Platform.OS,
+        iosPacketLength: tuning.iosPacketLength,
+        androidPacketLength: tuning.androidPacketLength,
+        mtu: currentTransport.mtuSize,
       });
+      const writeMode = writeWithResponse ? 'withResponse' : 'withoutResponse';
+      const logSignature = `${name}:${writeMode}:${String(
+        currentTransport.mtuSize
+      )}:${packetCapacity}`;
+      const loggedSignatures =
+        this.protocolV2HighVolumeLogSignatures.get(uuid) ?? new Set<string>();
+      if (!loggedSignatures.has(logSignature)) {
+        loggedSignatures.add(logSignature);
+        this.protocolV2HighVolumeLogSignatures.set(uuid, loggedSignatures);
+        Log?.debug('[ReactNativeBleTransport] Protocol V2 high-volume write configured', {
+          name,
+          writeMode,
+          reportedMtu: currentTransport.mtuSize,
+          packetCapacity,
+        });
+      }
+    }
+
+    if (highVolumeWrite) {
+      await this.enableAndroidHighConnectionPriority(uuid);
     }
 
     try {
@@ -2230,6 +1912,73 @@ export default class ReactNativeBleTransport {
     } catch (e) {
       Log?.error('[ReactNativeBleTransport] Protocol V2 call error:', e);
       throw e;
+    } finally {
+      if (highVolumeWrite) {
+        this.scheduleAndroidBalancedConnectionPriority(uuid);
+      }
+    }
+  }
+
+  private clearAndroidPriorityResetTimer(uuid: string) {
+    const timerId = this.androidPriorityResetTimers.get(uuid);
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+      this.androidPriorityResetTimers.delete(uuid);
+    }
+  }
+
+  private async enableAndroidHighConnectionPriority(uuid: string) {
+    if (Platform.OS !== 'android') return;
+
+    this.clearAndroidPriorityResetTimer(uuid);
+    if (this.androidHighPriorityDevices.has(uuid)) return;
+
+    const transport = transportCache[uuid];
+    if (!transport) return;
+
+    try {
+      transport.device = await transport.device.requestConnectionPriority(ConnectionPriority.High);
+      this.androidHighPriorityDevices.add(uuid);
+      Log?.debug('[ReactNativeBleTransport] Android BLE connection priority changed', {
+        priority: 'high',
+      });
+    } catch (error) {
+      Log?.debug('[ReactNativeBleTransport] Android BLE high priority request failed', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  private scheduleAndroidBalancedConnectionPriority(uuid: string) {
+    if (Platform.OS !== 'android' || !this.androidHighPriorityDevices.has(uuid)) return;
+
+    this.clearAndroidPriorityResetTimer(uuid);
+    const timerId = setTimeout(() => {
+      this.androidPriorityResetTimers.delete(uuid);
+      this.restoreAndroidConnectionPriority(uuid, transportCache[uuid]).catch(error =>
+        Log?.debug('[ReactNativeBleTransport] Android BLE priority restore failed', error)
+      );
+    }, ANDROID_HIGH_PRIORITY_IDLE_MS);
+    this.androidPriorityResetTimers.set(uuid, timerId);
+  }
+
+  private async restoreAndroidConnectionPriority(uuid: string, transport?: BleTransport) {
+    this.clearAndroidPriorityResetTimer(uuid);
+    if (Platform.OS !== 'android' || !this.androidHighPriorityDevices.delete(uuid) || !transport) {
+      return;
+    }
+
+    try {
+      transport.device = await transport.device.requestConnectionPriority(
+        ConnectionPriority.Balanced
+      );
+      Log?.debug('[ReactNativeBleTransport] Android BLE connection priority changed', {
+        priority: 'balanced',
+      });
+    } catch (error) {
+      Log?.debug('[ReactNativeBleTransport] Android BLE balanced priority request failed', {
+        error: error instanceof Error ? error.message : String(error),
+      });
     }
   }
 
@@ -2253,13 +2002,7 @@ export default class ReactNativeBleTransport {
       writeFrame: async (frame: Uint8Array, context: ProtocolV2CallContext) => {
         assertCurrentGeneration();
         const currentTransport = this.getCachedTransport(uuid);
-        await this.writeProtocolV2Frame(
-          uuid,
-          currentTransport,
-          frame,
-          context,
-          assertCurrentGeneration
-        );
+        await this.writeProtocolV2Frame(currentTransport, frame, context, assertCurrentGeneration);
       },
       readFrame: async () => {
         assertCurrentGeneration();
@@ -2284,6 +2027,6 @@ export default class ReactNativeBleTransport {
   }
 
   getProtocolType(path: string): ProtocolType | undefined {
-    return this.getActiveProtocol(path);
+    return this.deviceProtocol.get(path);
   }
 }