@onekeyfe/hd-transport-react-native 1.2.2-alpha.116 → 1.2.2-alpha.118

package/src/index.ts

@@ -185,10 +185,7 @@ const shouldRethrowProtocolProbeError = (error: unknown): boolean => {
     code === HardwareErrorCode.BleDeviceDisconnected ||
     code === HardwareErrorCode.BleCharacteristicNotifyError ||
     code === HardwareErrorCode.BleCharacteristicNotifyChangeFailure ||
-    code === HardwareErrorCode.BleWriteCharacteristicError ||
-    // A link stuck at the default MTU cannot answer Protocol V2 at all; reporting it as a
-    // probe miss would send detection on to report a protocol mismatch instead.
-    isProtocolV2DefaultMtuError(error)
+    code === HardwareErrorCode.BleWriteCharacteristicError
   );
 };
 /** Consecutive wedged writes on one device before the BLE manager itself is recreated. */
@@ -259,28 +256,16 @@ const connectOptions: Record<string, unknown> = {
   refreshGatt: 'OnConnected',
 };
 
-/** Fallback connect options: drops requestMTU (the thing being worked around) but keeps the native budget. */
+/** Connect options without requestMTU: the iOS fallback and every bare Android connect. */
 const fallbackConnectOptions: Record<string, unknown> = {
   timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
 };
 
 /**
- * Android connects with the bare native budget: no MTU request and no GATT cache refresh
- * inside that timer. ble-plx runs establishConnection -> refreshGatt -> requestMtu under one
- * timeout, and refreshGatt makes the Android stack rediscover every service at the default
- * 23-byte MTU before the MTU request can leave the ATT queue. A Pro 2 needs 2-5s for that
- * rediscovery, so the budget expired with the request still unsent. Closing the client then
- * left the exchange marked in progress for the whole LE link, and the stack parked every
- * later MTU request on it ("Put conn_id on wait list"; btsnoop showed no Exchange MTU
- * Request on the air). The MTU is negotiated as a separate first step instead.
- */
-const androidConnectOptions: Record<string, unknown> = {
-  timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
-};
-
-/**
- * Only used when the cached GATT table is known or likely to be stale; the rediscovery it
- * starts is then allowed to finish before the MTU exchange instead of racing it.
+ * Android never requests the MTU inside the native connect budget: refreshGatt makes the stack
+ * rediscover first, and a budget that expires with the MTU request unsent parks every later MTU
+ * request on that LE link. refreshGatt itself is only added after a firmware install or a
+ * stale-table symptom, and discovery finishes before the MTU exchange.
  */
 const androidRefreshGattConnectOptions: Record<string, unknown> = {
   timeout: BLE_NATIVE_CONNECT_TIMEOUT_MS,
@@ -288,61 +273,27 @@ const androidRefreshGattConnectOptions: Record<string, unknown> = {
 };
 
 /**
- * Bound for the Android MTU exchange. A healthy exchange with a Pro 2 completes in ~50ms.
- * When the phone has no cached GATT table (first connect after bonding, or a connect after
- * an aborted discovery) the stack runs its own discovery first and only executes the MTU
- * request after it; single passes on a Pro 2 at MTU 23 measured 1.7-4.8s and a refresh
- * plus restart 7.7s, so the bound has to sit well above those. An exchange the stack holds
- * as already in progress never completes, so a longer bound costs nothing on that link.
+ * With no cached GATT table the stack runs its own discovery (up to ~8s) before the MTU
+ * exchange, so the bound sits above that; a stuck exchange never completes.
  */
 export const ANDROID_MTU_EXCHANGE_TIMEOUT_MS = 12_000;
 
 /**
- * Android keeps an LE link up for its GATT link idle timer (4s) after the last client
- * closes, and per-link ATT state such as a pending MTU exchange lives as long as the link.
- * A reconnect inside that window attaches to the same link. The only connectivity signal
- * reachable from here, BluetoothManager.getConnectedDevices(GATT), is built from the
- * per-app GATT client registry rather than the LE link: it empties the moment this client
- * closes on phones with no resident GATT server, and stays populated for the life of the
- * link on phones that have one. So an unusable link is held for at least the quiet period
- * (past the idle timer), and additionally until that registry no longer lists the device,
- * within the overall bound.
+ * Android keeps an LE link, with per-link ATT state such as a pending MTU exchange, for its
+ * 4s GATT link idle timer after the last client closes; a reconnect inside it reuses the link.
  */
 export const ANDROID_LINK_DROP_QUIET_MS = 5000;
-export const ANDROID_LINK_DROP_TIMEOUT_MS = 8000;
 const ANDROID_LINK_DROP_POLL_MS = 250;
 
 /**
- * Nothing works at the default 23-byte ATT MTU on Android. Protocol V1 writes 192-byte
- * packets whatever the MTU, and a Pro 2 answers Protocol V2 with a single ATT_MTU-3
- * notification and never sends the rest of the frame, so the 29-byte reply to a probe Ping
- * arrives as 20 bytes declaring 29 and the call hangs. Only a known default MTU counts; an
- * unknown value keeps the existing conservative-packet behaviour.
+ * Android cannot use a link at the default 23-byte ATT MTU: Protocol V1 writes 192-byte
+ * packets regardless, and a Pro 2 sends only the first ATT_MTU-3 bytes of a V2 reply.
+ * An unknown MTU is not treated as default.
  */
 const isKnownDefaultMtu = (mtu: unknown): boolean =>
   typeof mtu === 'number' && Number.isFinite(mtu) && mtu <= 23;
-const DEFAULT_MTU_LINK_MESSAGE = 'BLE link stayed at the default MTU';
-const createDefaultMtuLinkError = (mtu: unknown) =>
-  ERRORS.TypedError(
-    HardwareErrorCode.BleConnectedError,
-    `${DEFAULT_MTU_LINK_MESSAGE} ${String(mtu)}, reconnecting on a fresh link`
-  );
-const PROTOCOL_V2_DEFAULT_MTU_MESSAGE = 'Protocol V2 needs a negotiated BLE MTU';
-const isProtocolV2DefaultMtuError = (error: unknown): boolean =>
-  (error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleConnectedError &&
-  typeof (error as { message?: unknown })?.message === 'string' &&
-  (error as { message: string }).message.startsWith(PROTOCOL_V2_DEFAULT_MTU_MESSAGE);
-const createProtocolV2DefaultMtuError = (mtu: unknown) =>
-  ERRORS.TypedError(
-    HardwareErrorCode.BleConnectedError,
-    `${PROTOCOL_V2_DEFAULT_MTU_MESSAGE}, current MTU ${String(mtu)}`
-  );
 
-/**
- * Symptoms of a cached GATT table that no longer matches the device. The UUIDs still
- * resolve from the cache in the firmware-upgrade case, so the stale handles surface at
- * discovery (missing or mis-typed characteristic) or when notifications are enabled.
- */
+/** Discovery found no OneKey service, or a characteristic of the wrong shape: the cached GATT table may be stale. */
 const isMissingGattShapeError = (error: unknown): boolean => {
   const code = (error as { errorCode?: unknown })?.errorCode;
   const message = (error as { message?: unknown })?.message;
@@ -358,9 +309,9 @@ const isMissingGattShapeError = (error: unknown): boolean => {
 const isStaleGattTableNotifyReason = (reason: string | null | undefined): boolean =>
   !!reason &&
   (reason.includes('Cannot write client characteristic config descriptor') ||
-    reason.includes('Cannot find client characteristic config descriptor') ||
+    reason.includes('Cannot find client characteristic config descriptor') || // pro firmware 2.3.0 upgrade
     reason.includes('The handle is invalid') ||
-    reason.includes('Writing is not permitted'));
+    reason.includes('Writing is not permitted')); // pro firmware 2.3.4 upgrade
 
 /**
  * JS backstop for connect. The native adapter applies its own 3s budget, but it
@@ -401,22 +352,16 @@ const shouldRethrowBleSetupError = (error: unknown): boolean =>
   isConnectTimeoutError(error) || isWedgedBleSetupError(error);
 const isNativeOperationTimeoutError = (error: unknown): boolean =>
   (error as { errorCode?: unknown })?.errorCode === BleErrorCode.OperationTimedOut;
-/**
- * ble-plx reports its own expired budget as OperationCancelled, not OperationTimedOut:
- * safeConnectToDevice disposes the operation chain and its doFinally reports a
- * cancellation. Either code means the native layer abandoned work that still owned
- * connection/GATT state, so both have to go through the stalled-connection cleanup.
- * Only used where nothing else recovers the link — the connect path does its own
- * ordered teardown before retrying, and routing it here too would both duplicate that
- * and spend the manager-reset budget on a connect that is about to be retried.
- */
-const isAbandonedNativeOperationError = (error: unknown): boolean => {
+const isMtuOrCancelledConnectError = (error: unknown): boolean => {
   const errorCode = (error as { errorCode?: unknown })?.errorCode;
   return (
-    errorCode === BleErrorCode.OperationTimedOut || errorCode === BleErrorCode.OperationCancelled
+    errorCode === BleErrorCode.DeviceMTUChangeFailed ||
+    errorCode === BleErrorCode.OperationCancelled
   );
 };
 
+type NegotiatedMtuResult = { device: Device; timedOut: boolean };
+
 export type IOneKeyDevice = OneKeyDeviceInfoBase & Device;
 
 const tryToGetConfiguration = (device: Device) => {
@@ -428,26 +373,13 @@ const tryToGetConfiguration = (device: Device) => {
   return infos;
 };
 
-type NegotiatedMtuResult = {
-  device: Device;
-  /**
-   * True when the bounded wait gave up while the native MTU exchange was still
-   * outstanding. `cancelTransaction` only disposes the JS-side subscription:
-   * RxAndroidBle releases a connection's serial operation queue from onComplete /
-   * onError alone, so an abandoned exchange keeps that queue until its own native
-   * timeout. Any GATT work issued before then — service discovery above all —
-   * queues behind it and cannot settle inside its own budget.
-   */
-  abandoned: boolean;
-};
-
 const requestNegotiatedMtu = async (
   device: Device,
   stage: 'connected' | 'highThroughput',
   attempt: number,
   cancelTransaction?: (transactionId: string) => Promise<void> | void
 ): Promise<NegotiatedMtuResult> => {
-  if (Platform.OS !== 'ios' && Platform.OS !== 'android') return { device, abandoned: false };
+  if (Platform.OS !== 'ios' && Platform.OS !== 'android') return { device, timedOut: false };
 
   const transactionId = `${device.id}:mtu:${stage}:${attempt}:${Date.now()}`;
   let timeoutId: ReturnType<typeof setTimeout> | undefined;
@@ -470,7 +402,7 @@ const requestNegotiatedMtu = async (
         }, BLE_MTU_REQUEST_TIMEOUT_MS);
       }),
     ]);
-    return { device: mtuDevice, abandoned: false };
+    return { device: mtuDevice, timedOut: false };
   } catch (error) {
     if (timedOut && cancelTransaction) {
       try {
@@ -496,9 +428,10 @@ const requestNegotiatedMtu = async (
       stage,
       attempt,
       actual: device.mtu,
+      timedOut,
       error: error instanceof Error ? error.message : String(error),
     });
-    return { device, abandoned: timedOut };
+    return { device, timedOut };
   } finally {
     if (timeoutId) clearTimeout(timeoutId);
   }
@@ -510,7 +443,7 @@ const resolveNegotiatedMtu = (
 ): Promise<NegotiatedMtuResult> =>
   shouldRefreshNegotiatedMtu(device.mtu)
     ? requestNegotiatedMtu(device, 'connected', 0, cancelTransaction)
-    : Promise.resolve({ device, abandoned: false });
+    : Promise.resolve({ device, timedOut: false });
 
 type IOBleErrorRemap = Error | BleError | null | undefined;
 
@@ -594,31 +527,12 @@ export default class ReactNativeBleTransport {
   /** Consecutive detections that failed while trusting sessionProtocols. */
   private protocolReprobeFailures: Map<string, number> = new Map();
 
-  /** Endpoints whose last detection got no answer on any protocol. */
-  private silentDetections = new Set<string>();
+  /** Endpoints whose last detection got no answer; 'woken' once their Initialize wake is spent. */
+  private silentDetections = new Map<string, 'silent' | 'woken'>();
 
-  /**
-   * Android endpoints whose cached GATT table is suspect and must be rediscovered on the
-   * next connect. The cache is no longer refreshed on every connect, so a missing OneKey
-   * service or characteristic marks the endpoint instead.
-   */
+  /** Android endpoints whose cached GATT table is suspect; the next connect refreshes it. */
   private androidGattCacheRefreshes = new Set<string>();
 
-  /** Instance copies of the Android timing bounds so tests can shorten real-time waits. */
-  androidMtuExchangeTimeoutMs = ANDROID_MTU_EXCHANGE_TIMEOUT_MS;
-
-  androidLinkDropQuietMs = ANDROID_LINK_DROP_QUIET_MS;
-
-  androidLinkDropTimeoutMs = ANDROID_LINK_DROP_TIMEOUT_MS;
-
-  /**
-   * Endpoints already sent a Protocol V1 wake. The wake starts a fresh wallet session
-   * on the device, and a failed detection tears the link down and reconnects on every
-   * poll, so neither set is cleared on teardown: one wake is spent per endpoint until a
-   * detection succeeds, which re-arms it for the next time the device sleeps.
-   */
-  private protocolWakeAttempts = new Set<string>();
-
   /**
    * Native encryption/pairing failures seen before Protocol V2 probe starts.
    * Pro2/Neo GATT connect can succeed on a stale iOS bond; the CCCD write then
@@ -889,13 +803,9 @@ export default class ReactNativeBleTransport {
 
       let { device } = transport;
       const isConnected = await device.isConnected().catch(() => false);
-      // A firmware upload reconnect keeps the GATT refresh; on Android it uses the same
-      // order as acquire: bare connect, discovery, then the MTU exchange on its own.
-      const reconnectOptions =
-        Platform.OS === 'android' ? androidRefreshGattConnectOptions : connectOptions;
       if (!isConnected) {
         try {
-          device = await this.connectWithTimeout(uuid, () => device.connect(reconnectOptions));
+          device = await this.connectWithTimeout(uuid, () => device.connect(connectOptions));
         } catch (e) {
           if (
             e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
@@ -910,17 +820,8 @@ export default class ReactNativeBleTransport {
 
       const { writeCharacteristic, notifyCharacteristic } =
         await this.resolveCharacteristicsWithTimeout(uuid, device);
-      if (Platform.OS === 'android') {
-        const manager = await this.getPlxManager();
-        device = await this.negotiateAndroidMtu(uuid, manager, device);
-        if (isKnownDefaultMtu(device.mtu)) {
-          await this.dropAndroidLink(uuid, manager, device, 'firmware reconnect default mtu');
-          throw createDefaultMtuLinkError(device.mtu);
-        }
-      }
 
       transport.device = device;
-      transport.mtuSize = typeof device.mtu === 'number' ? device.mtu : transport.mtuSize;
       transport.writeCharacteristic = writeCharacteristic;
       transport.notifyCharacteristic = notifyCharacteristic;
       const monitorToken = this.nextMonitorToken;
@@ -1106,7 +1007,7 @@ export default class ReactNativeBleTransport {
     characteristics?: ResolvedBleCharacteristics
   ) {
     const { writeCharacteristic, notifyCharacteristic } =
-      characteristics ?? (await this.resolveCharacteristicsForAcquire(uuid, device));
+      characteristics ?? (await this.resolveCharacteristicsWithTimeout(uuid, device));
     if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
     const transport = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
     transport.mtuSize = typeof device.mtu === 'number' ? device.mtu : undefined;
@@ -1209,13 +1110,9 @@ export default class ReactNativeBleTransport {
         const isCachedDeviceConnected = await cachedTransport.device
           .isConnected()
           .catch(() => false);
-        // A cached Android link at the default MTU, or one whose GATT table is suspect,
-        // has to go through the full acquire again so the MTU exchange and the refresh
-        // connect actually run instead of every retry reusing the same unusable link.
+        // A suspect GATT table is only refreshed through a new connect.
         const isCachedAndroidLinkUsable =
-          Platform.OS !== 'android' ||
-          (!isKnownDefaultMtu(cachedTransport.mtuSize) &&
-            !this.androidGattCacheRefreshes.has(uuid));
+          Platform.OS !== 'android' || !this.androidGattCacheRefreshes.has(uuid);
         if (
           isCachedDeviceConnected &&
           isCachedAndroidLinkUsable &&
@@ -1238,19 +1135,16 @@ export default class ReactNativeBleTransport {
 
     let device: Device | null = null;
     const isAndroid = Platform.OS === 'android';
-    // A firmware-install reconnect keeps the per-connect GATT refresh it always had: the
-    // install loader may expose a different table than the firmware that was cached.
+    // A firmware-install reconnect always refreshes: the new firmware may expose a different table.
     const refreshAndroidGattCache =
       isAndroid && (!!skipProtocolProbe || this.androidGattCacheRefreshes.has(uuid));
     let nativeConnectOptions = connectOptions;
     if (isAndroid) {
       nativeConnectOptions = refreshAndroidGattCache
         ? androidRefreshGattConnectOptions
-        : androidConnectOptions;
+        : fallbackConnectOptions;
     }
-    // Only a connect that actually carried refreshGatt consumes a pending refresh; the
-    // fallback connects below drop that option, so the marker then survives for the next
-    // attempt instead of being cleared by a connect that never reached the cache.
+    // Only a connect that carried refreshGatt clears the marker; the fallback connects drop it.
     let androidRefreshConnectRan = false;
 
     if (forceCleanRunPromise && this.runPromise) {
@@ -1262,6 +1156,7 @@ export default class ReactNativeBleTransport {
     }
 
     const blePlxManager = await this.getPlxManager();
+    let skipPostConnectMtu = false;
     try {
       await subscribeBleOn(blePlxManager);
     } catch (error) {
@@ -1314,17 +1209,9 @@ export default class ReactNativeBleTransport {
         if (shouldRethrowBleSetupError(e)) {
           throw e;
         }
-        if (
-          e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
-          e.errorCode === BleErrorCode.OperationCancelled
-        ) {
+        if (isMtuOrCancelledConnectError(e)) {
+          skipPostConnectMtu = true;
           Log?.debug('first try to reconnect without params');
-          // The disposed chain can still own native connection state, and the retry
-          // would otherwise run on top of a half-open GATT client.
-          await this.runBestEffortNativeOperation(
-            'connect cancelled: cancel manager connection',
-            () => blePlxManager.cancelDeviceConnection(uuid)
-          );
           device = await this.connectWithTimeout(uuid, () =>
             blePlxManager.connectToDevice(uuid, fallbackConnectOptions)
           );
@@ -1341,7 +1228,11 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.BleConnectedError, 'unable to connect to device');
     }
 
-    if (isAndroid && refreshAndroidGattCache && (await device.isConnected().catch(() => false))) {
+    if (
+      refreshAndroidGattCache &&
+      !androidRefreshConnectRan &&
+      (await device.isConnected().catch(() => false))
+    ) {
       // refreshGatt only reaches the stack through a connect. A link that is still up would
       // skip the connect below and keep serving the stale table, so it is dropped first.
       await this.dropAndroidLink(uuid, blePlxManager, device, 'gatt cache refresh');
@@ -1362,17 +1253,9 @@ export default class ReactNativeBleTransport {
         if (shouldRethrowBleSetupError(e)) {
           throw e;
         }
-        if (
-          e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
-          e.errorCode === BleErrorCode.OperationCancelled
-        ) {
+        if (isMtuOrCancelledConnectError(e)) {
+          skipPostConnectMtu = true;
           Log?.debug('second try to reconnect without params');
-          // The disposed chain can still own native connection state, and the retry
-          // would otherwise run on top of a half-open GATT client.
-          await this.runBestEffortNativeOperation(
-            'connect cancelled: cancel device connection',
-            () => disconnectedDevice.cancelConnection()
-          );
           try {
             device = await this.connectWithTimeout(uuid, () =>
               disconnectedDevice.connect(fallbackConnectOptions)
@@ -1418,43 +1301,38 @@ export default class ReactNativeBleTransport {
       if (refreshAndroidGattCache) {
         // refreshGatt has already started a full rediscovery; let it finish before the MTU
         // exchange so the request is not queued behind it.
-        characteristics = await this.resolveCharacteristicsForAcquire(uuid, device);
+        characteristics = await this.resolveCharacteristicsWithTimeout(uuid, device);
         if (androidRefreshConnectRan) this.androidGattCacheRefreshes.delete(uuid);
         if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
       }
       device = await this.negotiateAndroidMtu(uuid, blePlxManager, device);
-      if (isKnownDefaultMtu(device.mtu)) {
-        // Neither protocol works at the default MTU on Android, so the link is not worth
-        // keeping for any device family. Counted like a setup timeout so a device that keeps
-        // ending here reaches the wedged-link guard instead of the full retry ladder.
-        const resetManager = this.abandonStalledConnection(uuid, 'mtu-default');
-        await this.dropAndroidLink(uuid, blePlxManager, device, 'default mtu');
-        if (resetManager) throw this.createWedgedBleSetupError();
-        throw createDefaultMtuLinkError(device.mtu);
-      }
-    } else {
-      const negotiatedMtu = await resolveNegotiatedMtu(device, transactionId =>
+    } else if (!skipPostConnectMtu) {
+      // Match 1.1.31: MTU is a connect() best-effort. If connect already fell back
+      // without requestMTU, do not put another requestMTU on the native serial
+      // queue — that is what wedges GATT after Account#2 reconnect.
+      const mtuResult = await resolveNegotiatedMtu(device, transactionId =>
         blePlxManager.cancelTransaction(transactionId)
       );
-      device = negotiatedMtu.device;
-      if (negotiatedMtu.abandoned) {
-        // Service discovery would queue behind the abandoned exchange and miss its own
-        // budget. Drop the link so the next attempt starts on a queue nothing holds.
-        await this.runNativeTeardown(uuid, blePlxManager, async () => {
-          await this.runBestEffortNativeOperation('mtu abandoned: cancel manager connection', () =>
-            blePlxManager.cancelDeviceConnection(uuid)
-          );
-        });
-        throw ERRORS.TypedError(
-          HardwareErrorCode.BleConnectedError,
-          'BLE MTU negotiation abandoned, reconnecting'
+      device = mtuResult.device;
+      if (mtuResult.timedOut) {
+        if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
+        Log?.debug(
+          '[ReactNativeBleTransport] post-connect MTU timed out, reconnecting without requesting MTU'
+        );
+        const timedOutDevice = device;
+        await this.runBestEffortNativeOperation('mtu timeout: cancel device connection', () =>
+          timedOutDevice.cancelConnection()
+        );
+        if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
+        device = await this.connectWithTimeout(uuid, () =>
+          timedOutDevice.connect(fallbackConnectOptions)
         );
       }
     }
     if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
     const acquiredDevice = device;
     const { writeCharacteristic, notifyCharacteristic } =
-      characteristics ?? (await this.resolveCharacteristicsForAcquire(uuid, acquiredDevice));
+      characteristics ?? (await this.resolveCharacteristicsWithTimeout(uuid, acquiredDevice));
     if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
 
     const protocolHint = expectedProtocol
@@ -1565,6 +1443,9 @@ export default class ReactNativeBleTransport {
           this.rememberStaleBondError(uuid, toBleStaleBondHardwareError(error));
           return;
         }
+        if (Platform.OS === 'android' && isStaleGattTableNotifyReason(error.reason)) {
+          this.androidGattCacheRefreshes.add(uuid);
+        }
         if (this.getActiveProtocol(uuid) === 'V2') {
           let errorCode:
             | typeof HardwareErrorCode.BleCharacteristicNotifyError
@@ -1574,17 +1455,11 @@ export default class ReactNativeBleTransport {
           if (error.reason?.includes('The connection has timed out unexpectedly')) {
             errorCode = HardwareErrorCode.BleTimeoutError;
           } else if (
-            error.reason?.includes('Cannot write client characteristic config descriptor') ||
-            error.reason?.includes('Cannot find client characteristic config descriptor') ||
-            error.reason?.includes('The handle is invalid') ||
-            error.reason?.includes('Writing is not permitted') ||
+            isStaleGattTableNotifyReason(error.reason) ||
             error.reason?.includes('notify change failed for device')
           ) {
             errorCode = HardwareErrorCode.BleCharacteristicNotifyChangeFailure;
           }
-          if (Platform.OS === 'android' && isStaleGattTableNotifyReason(error.reason)) {
-            this.androidGattCacheRefreshes.add(uuid);
-          }
           this.rejectProtocolV2Frames(uuid, ERRORS.TypedError(errorCode));
           return;
         }
@@ -1597,18 +1472,12 @@ export default class ReactNativeBleTransport {
             ERROR = HardwareErrorCode.BleTimeoutError;
           }
           if (
-            error.reason?.includes('Cannot write client characteristic config descriptor') ||
-            error.reason?.includes('Cannot find client characteristic config descriptor') || // pro firmware 2.3.0 upgrade
-            error.reason?.includes('The handle is invalid') ||
-            error.reason?.includes('Writing is not permitted') || // pro firmware 2.3.4 upgrade
+            isStaleGattTableNotifyReason(error.reason) ||
             error.reason?.includes('notify change failed for device')
           ) {
             const notifyError = ERRORS.TypedError(
               HardwareErrorCode.BleCharacteristicNotifyChangeFailure
             );
-            if (Platform.OS === 'android' && isStaleGattTableNotifyReason(error.reason)) {
-              this.androidGattCacheRefreshes.add(uuid);
-            }
             this.runPromise.reject(notifyError);
             Log?.debug(
               `${HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`
@@ -2033,13 +1902,14 @@ export default class ReactNativeBleTransport {
       const jsonData = ProtocolV1.decodeMessage(messages, response);
       return check.call(jsonData);
     } catch (e) {
-      if (name === 'GetFeatures' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS) {
-        Log?.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe call failed:', e);
+      const isProbeTimeout =
+        options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS &&
+        (name === 'GetFeatures' || name === 'Initialize');
+      if (isProbeTimeout) {
+        Log?.debug(`[ReactNativeBleTransport] Protocol V1 ${name} probe call failed:`, e);
       } else {
         Log?.error('call error: ', e);
       }
-      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.
@@ -2273,10 +2143,8 @@ export default class ReactNativeBleTransport {
   }
 
   /**
-   * Negotiate the ATT MTU as the first request on an Android GATT client, with nothing queued
-   * ahead of it, and never close the client while it is outstanding: an exchange abandoned
-   * mid-flight stays marked in progress for the whole LE link. A link that already negotiated
-   * an MTU answers at once with the recorded value.
+   * Android: request the MTU with nothing queued ahead and never close the client while it is
+   * outstanding; a link that times out or stays at MTU 23 is dropped.
    */
   private async negotiateAndroidMtu(
     uuid: string,
@@ -2286,61 +2154,58 @@ export default class ReactNativeBleTransport {
     if (!shouldRefreshNegotiatedMtu(device.mtu)) return device;
 
     const startedAt = Date.now();
-    const transactionId = `${device.id}:mtu:connected:0:${startedAt}`;
     let timer: ReturnType<typeof setTimeout> | undefined;
     let timedOut = false;
-    const request = device.requestMTU(ANDROID_REQUEST_MTU, transactionId);
-    request.catch(() => undefined);
+    let negotiated = device;
+    let failure: string | undefined;
     try {
-      const negotiated = await Promise.race([
-        request,
+      negotiated = await Promise.race([
+        device.requestMTU(ANDROID_REQUEST_MTU, `${device.id}:mtu:connected:0:${startedAt}`),
         new Promise<never>((_, reject) => {
           timer = setTimeout(() => {
             timedOut = true;
             reject(
-              new Error(`BLE MTU exchange timeout after ${this.androidMtuExchangeTimeoutMs}ms`)
+              new Error(`BLE MTU exchange timeout after ${ANDROID_MTU_EXCHANGE_TIMEOUT_MS}ms`)
             );
-          }, this.androidMtuExchangeTimeoutMs);
+          }, ANDROID_MTU_EXCHANGE_TIMEOUT_MS);
         }),
       ]);
-      Log?.debug('[ReactNativeBleTransport] BLE MTU exchange completed', {
-        connectIdSuffix: uuid.slice(-8),
-        elapsedMs: Date.now() - startedAt,
-        actual: negotiated.mtu,
-      });
-      return negotiated;
     } catch (error) {
-      Log?.debug('[ReactNativeBleTransport] BLE MTU exchange failed', {
-        connectIdSuffix: uuid.slice(-8),
-        elapsedMs: Date.now() - startedAt,
-        timedOut,
-        actual: device.mtu,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
-      // A request the stack rejected is not left pending; the caller's MTU check decides.
-      if (!timedOut) return device;
-      // The JS-side subscription is released for hygiene only: the native operation, and
-      // the per-link state it may already hold, end with the link below.
-      await Promise.resolve(manager.cancelTransaction(transactionId)).catch(() => undefined);
-      const resetManager = this.abandonStalledConnection(uuid, 'mtu-backstop');
-      await this.dropAndroidLink(uuid, manager, device, 'mtu exchange timeout');
-      if (resetManager) throw this.createWedgedBleSetupError();
-      throw ERRORS.TypedError(
-        HardwareErrorCode.BleConnectedError,
-        'BLE MTU exchange did not complete, reconnecting on a fresh link'
-      );
+      failure = error instanceof Error ? error.message : String(error);
     } finally {
       if (timer) clearTimeout(timer);
     }
+    Log?.debug(`[ReactNativeBleTransport] BLE MTU exchange ${failure ? 'failed' : 'completed'}`, {
+      connectIdSuffix: uuid.slice(-8),
+      elapsedMs: Date.now() - startedAt,
+      timedOut,
+      actual: negotiated.mtu,
+      error: failure,
+    });
+    if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
+    if (!timedOut && !isKnownDefaultMtu(negotiated.mtu)) return negotiated;
+
+    // Counted like a setup timeout so a link that keeps failing reaches the wedged-link guard.
+    const resetManager = this.abandonStalledConnection(
+      uuid,
+      timedOut ? 'mtu-backstop' : 'mtu-default'
+    );
+    await this.dropAndroidLink(
+      uuid,
+      manager,
+      negotiated,
+      timedOut ? 'mtu exchange timeout' : 'default mtu'
+    );
+    if (resetManager) throw this.createWedgedBleSetupError();
+    throw ERRORS.TypedError(
+      HardwareErrorCode.BleConnectedError,
+      timedOut
+        ? 'BLE MTU exchange did not complete, reconnecting on a fresh link'
+        : `BLE link stayed at the default MTU ${negotiated.mtu}, reconnecting on a fresh link`
+    );
   }
 
-  /**
-   * Abandon an Android LE link whose per-link GATT state is unusable. Closing the GATT
-   * client alone keeps the link up for the stack's idle timer, and Core's retry arrives
-   * inside that window, so this holds for at least ANDROID_LINK_DROP_QUIET_MS and until the
-   * GATT registry no longer lists the device, capped at ANDROID_LINK_DROP_TIMEOUT_MS.
-   */
+  /** Close the client and wait out the link idle timer so the next connect gets a fresh link. */
   private async dropAndroidLink(
     uuid: string,
     manager: BlePlxManager,
@@ -2359,55 +2224,16 @@ export default class ReactNativeBleTransport {
     });
 
     const startedAt = Date.now();
-    const target = uuid.toUpperCase();
-    let registryClear = false;
-    let quietPeriodElapsed = false;
-    while (!this.stopped) {
-      const elapsed = Date.now() - startedAt;
-      quietPeriodElapsed = elapsed >= this.androidLinkDropQuietMs;
-      if (!registryClear) {
-        const connected: Array<{ id?: unknown }> | undefined = await getConnectedDeviceIds(
-          []
-        ).catch(() => undefined);
-        registryClear =
-          !!connected &&
-          !connected.some(peripheral => String(peripheral?.id ?? '').toUpperCase() === target);
-      }
-      if ((registryClear && quietPeriodElapsed) || elapsed >= this.androidLinkDropTimeoutMs) {
-        break;
-      }
+    while (!this.stopped && Date.now() - startedAt < ANDROID_LINK_DROP_QUIET_MS) {
       await delay(ANDROID_LINK_DROP_POLL_MS);
     }
     Log?.debug('[ReactNativeBleTransport] Android BLE link drop', {
       connectIdSuffix: uuid.slice(-8),
       reason,
-      registryClear,
-      quietPeriodElapsed,
       stopped: this.stopped,
-      elapsedMs: Date.now() - startedAt,
     });
   }
 
-  private async resolveCharacteristicsForAcquire(
-    uuid: string,
-    device: Device
-  ): Promise<ResolvedBleCharacteristics> {
-    try {
-      return await this.resolveCharacteristicsWithTimeout(uuid, device);
-    } catch (error) {
-      if (Platform.OS === 'android' && isMissingGattShapeError(error)) {
-        this.androidGattCacheRefreshes.add(uuid);
-        // The refresh only reaches the stack through a connect, and a link that is still
-        // up would let the next acquire skip that connect and serve the same stale table.
-        const manager = this.blePlxManager;
-        if (manager) {
-          await this.dropAndroidLink(uuid, manager, device, 'stale gatt table');
-        }
-      }
-      throw error;
-    }
-  }
-
   /** Run a native connect under the JS backstop budget. */
   private async connectWithTimeout<T>(uuid: string, connect: () => Promise<T>): Promise<T> {
     if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
@@ -2488,7 +2314,7 @@ export default class ReactNativeBleTransport {
       succeeded = true;
       return result;
     } catch (error) {
-      if (timedOut || isAbandonedNativeOperationError(error)) {
+      if (timedOut || isNativeOperationTimeoutError(error)) {
         const resetManager = this.abandonStalledConnection(
           uuid,
           timedOut ? 'gatt-backstop' : 'gatt-native'
@@ -2497,6 +2323,9 @@ export default class ReactNativeBleTransport {
           throw this.createWedgedBleSetupError();
         }
       }
+      if (Platform.OS === 'android' && isMissingGattShapeError(error)) {
+        this.androidGattCacheRefreshes.add(uuid);
+      }
       throw error;
     } finally {
       if (timer) clearTimeout(timer);
@@ -2699,7 +2528,6 @@ export default class ReactNativeBleTransport {
     // firmware reconnect after the native BLE manager is recreated.
     this.protocolReprobeFailures.clear();
     this.silentDetections.clear();
-    this.protocolWakeAttempts.clear();
     this.writeTimeoutCounts.clear();
     this.connectionSetupTimeoutCounts.clear();
     this.monitorTokens.clear();
@@ -2835,7 +2663,6 @@ export default class ReactNativeBleTransport {
         }
         this.protocolReprobeFailures.delete(uuid);
         this.silentDetections.delete(uuid);
-        this.protocolWakeAttempts.delete(uuid);
         Log?.debug('[ReactNativeBleTransport] protocol detected', {
           deviceId: uuid,
           protocol,
@@ -2845,9 +2672,8 @@ export default class ReactNativeBleTransport {
       }
     }
 
-    // Nothing answered on any probed protocol. Remember it so the next detection, which
-    // the caller reaches on a freshly reconnected link, can spend a wake first.
-    this.silentDetections.add(uuid);
+    // Arms the wake for the next detection.
+    if (!this.silentDetections.has(uuid)) this.silentDetections.set(uuid, 'silent');
 
     if (trustSessionProtocol) {
       // Still silent on its own protocol: count it, and let the streak expire the
@@ -2863,29 +2689,19 @@ export default class ReactNativeBleTransport {
   }
 
   /**
-   * Sent once before probing when the previous detection on this endpoint got no answer
-   * at all. On Classic-family firmware that silence is also what a sleeping device looks
-   * like: its BLE co-processor keeps serving connect, GATT and MTU while the main MCU
-   * sits in the screensaver loop, whose host-message filter accepts only Initialize and
-   * the *Ack messages. GetFeatures and Ping are dropped there without a reply, so no
-   * amount of probing can bring the device back.
-   *
-   * Initialize is the one message that breaks that loop, but it also starts a fresh
-   * wallet session, which is why it is not the probe itself — a bare Initialize on every
-   * acquire would drop a hidden-wallet session before Core can restore it. Requiring a
-   * fully silent previous detection keeps it to devices with no session left to protect.
-   *
-   * The firmware consumes the wake to leave its loop and does not reliably answer it, so
-   * the result is ignored: the probes that follow are what decide the protocol.
+   * A sleeping Classic drops GetFeatures/Ping and only leaves its screensaver on Initialize, which
+   * resets the wallet session, so it is sent once after a fully silent detection. The firmware does
+   * not reliably answer it, so its timeout must not drop the link.
    */
   private async wakeSilentProtocolV1Device(uuid: string, probeOrder: ProtocolType[]) {
-    if (!this._messages) return;
-    if (!probeOrder.includes('V1')) return;
-    if (!this.silentDetections.has(uuid)) return;
-    if (this.protocolWakeAttempts.has(uuid)) return;
-    if (!transportCache[uuid]) return;
-    this.protocolWakeAttempts.add(uuid);
-
+    if (
+      Platform.OS !== 'android' ||
+      !probeOrder.includes('V1') ||
+      this.silentDetections.get(uuid) !== 'silent'
+    ) {
+      return;
+    }
+    this.silentDetections.set(uuid, 'woken');
     Log?.debug('[ReactNativeBleTransport] sending Protocol V1 Initialize wake', {
       connectIdSuffix: uuid.slice(-8),
     });
@@ -2893,11 +2709,7 @@ export default class ReactNativeBleTransport {
       this.probingProtocols.set(uuid, 'V1');
       await this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
     } catch (error) {
-      if (shouldRethrowProtocolProbeError(error)) {
-        this.clearProbeProtocol(uuid, 'V1');
-        throw error;
-      }
-      Log?.debug('[ReactNativeBleTransport] Protocol V1 Initialize wake did not answer:', error);
+      if (shouldRethrowProtocolProbeError(error)) throw error;
     } finally {
       this.clearProbeProtocol(uuid, 'V1');
     }
@@ -3205,13 +3017,6 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    if (Platform.OS === 'android') {
-      const activeTransport = transportCache[uuid];
-      if (activeTransport && isKnownDefaultMtu(activeTransport.mtuSize)) {
-        throw createProtocolV2DefaultMtuError(activeTransport.mtuSize);
-      }
-    }
-
     const isProtocolProbe = this.probingProtocols.get(uuid) === 'V2';
     const callOptions = options;
     const highThroughputWrite = isProtocolV2HighThroughputCall(name);
@@ -3289,7 +3094,7 @@ export default class ReactNativeBleTransport {
     const transport = this.getCachedTransport(uuid);
     if (!shouldRefreshNegotiatedMtu(transport.mtuSize)) return;
 
-    const { device: refreshedDevice, abandoned } = await requestNegotiatedMtu(
+    const { device: refreshedDevice } = await requestNegotiatedMtu(
       transport.device,
       'highThroughput',
       1,
@@ -3299,7 +3104,7 @@ export default class ReactNativeBleTransport {
     transport.mtuSize =
       typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport.mtuSize;
 
-    if (abandoned || shouldRefreshNegotiatedMtu(transport.mtuSize)) {
+    if (shouldRefreshNegotiatedMtu(transport.mtuSize)) {
       throw ERRORS.TypedError(
         HardwareErrorCode.BleConnectedError,
         `Protocol V2 high-throughput BLE MTU unavailable: ${String(transport.mtuSize)}`