@onekeyfe/hd-transport-react-native 1.2.2-alpha.114 → 1.2.2-alpha.115

package/dist/index.d.ts

@@ -135,6 +135,15 @@ declare class ReactNativeBleTransport {
     private confirmedProtocolV2;
     /** Consecutive detections that failed while trusting sessionProtocols. */
     private protocolReprobeFailures;
+    /** Endpoints whose last detection got no answer on any protocol. */
+    private silentDetections;
+    /**
+     * 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;
     /**
      * 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
@@ -228,6 +237,23 @@ declare class ReactNativeBleTransport {
     /** Protocol to route a call with: confirmed if known, otherwise the one being probed. */
     private getActiveProtocol;
     private detectProtocol;
+    /**
+     * 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.
+     */
+    private wakeSilentProtocolV1Device;
     private resetProbeStateAfterProtocolProbe;
     private probeProtocolV1;
     private probeProtocolV2;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -446,10 +446,9 @@ const isWedgedBleSetupError = (error) => (error === null || error === void 0 ? v
     error.message.startsWith(BLE_SETUP_WEDGED_MESSAGE);
 const shouldRethrowBleSetupError = (error) => isConnectTimeoutError(error) || isWedgedBleSetupError(error);
 const isNativeOperationTimeoutError = (error) => (error === null || error === void 0 ? void 0 : error.errorCode) === reactNativeBlePlx.BleErrorCode.OperationTimedOut;
-const isMtuOrCancelledConnectError = (error) => {
+const isAbandonedNativeOperationError = (error) => {
     const errorCode = error === null || error === void 0 ? void 0 : error.errorCode;
-    return (errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
-        errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled);
+    return (errorCode === reactNativeBlePlx.BleErrorCode.OperationTimedOut || errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled);
 };
 const tryToGetConfiguration = (device) => {
     if (!device || !device.serviceUUIDs)
@@ -464,7 +463,7 @@ const tryToGetConfiguration = (device) => {
 };
 const requestNegotiatedMtu = (device, stage, attempt, cancelTransaction) => __awaiter(void 0, void 0, void 0, function* () {
     if (reactNative.Platform.OS !== 'ios' && reactNative.Platform.OS !== 'android')
-        return { device, timedOut: false };
+        return { device, abandoned: false };
     const transactionId = `${device.id}:mtu:${stage}:${attempt}:${Date.now()}`;
     let timeoutId;
     let timedOut = false;
@@ -480,7 +479,7 @@ const requestNegotiatedMtu = (device, stage, attempt, cancelTransaction) => __aw
                 }, BLE_MTU_REQUEST_TIMEOUT_MS);
             }),
         ]);
-        return { device: mtuDevice, timedOut: false };
+        return { device: mtuDevice, abandoned: false };
     }
     catch (error) {
         if (timedOut && cancelTransaction) {
@@ -508,10 +507,9 @@ const requestNegotiatedMtu = (device, stage, attempt, cancelTransaction) => __aw
             stage,
             attempt,
             actual: device.mtu,
-            timedOut,
             error: error instanceof Error ? error.message : String(error),
         });
-        return { device, timedOut };
+        return { device, abandoned: timedOut };
     }
     finally {
         if (timeoutId)
@@ -520,7 +518,7 @@ const requestNegotiatedMtu = (device, stage, attempt, cancelTransaction) => __aw
 });
 const resolveNegotiatedMtu = (device, cancelTransaction) => shouldRefreshNegotiatedMtu(device.mtu)
     ? requestNegotiatedMtu(device, 'connected', 0, cancelTransaction)
-    : Promise.resolve({ device, timedOut: false });
+    : Promise.resolve({ device, abandoned: false });
 function remapError(error) {
     var _a;
     if (error instanceof reactNativeBlePlx.BleError) {
@@ -557,6 +555,8 @@ class ReactNativeBleTransport {
         this.sessionProtocols = new Map();
         this.confirmedProtocolV2 = new Set();
         this.protocolReprobeFailures = new Map();
+        this.silentDetections = new Set();
+        this.protocolWakeAttempts = new Set();
         this.staleBondErrors = new Map();
         this.acquiringProtocolV2 = new Set();
         this.protocolV2Assemblers = new Map();
@@ -1043,6 +1043,7 @@ class ReactNativeBleTransport {
                 }
             }
             let device = null;
+            let mtuHandshakeRefused = false;
             if (forceCleanRunPromise && this.runPromise) {
                 const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
                 this.runPromise.reject(error);
@@ -1051,7 +1052,6 @@ class ReactNativeBleTransport {
                 Log === null || Log === void 0 ? void 0 : Log.debug('Force clean Bluetooth run promise, forceCleanRunPromise: ', forceCleanRunPromise);
             }
             const blePlxManager = yield this.getPlxManager();
-            let skipPostConnectMtu = false;
             try {
                 yield subscribeBleOn(blePlxManager);
             }
@@ -1100,9 +1100,11 @@ class ReactNativeBleTransport {
                     if (shouldRethrowBleSetupError(e)) {
                         throw e;
                     }
-                    if (isMtuOrCancelledConnectError(e)) {
-                        skipPostConnectMtu = true;
+                    if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
+                        e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('first try to reconnect without params');
+                        mtuHandshakeRefused = true;
+                        yield this.runBestEffortNativeOperation('connect cancelled: cancel manager connection', () => blePlxManager.cancelDeviceConnection(uuid));
                         device = yield this.connectWithTimeout(uuid, () => blePlxManager.connectToDevice(uuid, fallbackConnectOptions));
                     }
                     else if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceAlreadyConnected) {
@@ -1128,9 +1130,11 @@ class ReactNativeBleTransport {
                     if (shouldRethrowBleSetupError(e)) {
                         throw e;
                     }
-                    if (isMtuOrCancelledConnectError(e)) {
-                        skipPostConnectMtu = true;
+                    if (e.errorCode === reactNativeBlePlx.BleErrorCode.DeviceMTUChangeFailed ||
+                        e.errorCode === reactNativeBlePlx.BleErrorCode.OperationCancelled) {
                         Log === null || Log === void 0 ? void 0 : Log.debug('second try to reconnect without params');
+                        mtuHandshakeRefused = true;
+                        yield this.runBestEffortNativeOperation('connect cancelled: cancel device connection', () => disconnectedDevice.cancelConnection());
                         try {
                             device = yield this.connectWithTimeout(uuid, () => disconnectedDevice.connect(fallbackConnectOptions));
                         }
@@ -1165,18 +1169,20 @@ class ReactNativeBleTransport {
             }
             if (this.stopped)
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
-            if (!skipPostConnectMtu) {
-                const mtuResult = yield resolveNegotiatedMtu(device, transactionId => blePlxManager.cancelTransaction(transactionId));
-                device = mtuResult.device;
-                if (mtuResult.timedOut) {
-                    if (this.stopped)
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
-                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] post-connect MTU timed out, reconnecting without requesting MTU');
-                    const timedOutDevice = device;
-                    yield this.runBestEffortNativeOperation('mtu timeout: cancel device connection', () => timedOutDevice.cancelConnection());
-                    if (this.stopped)
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
-                    device = yield this.connectWithTimeout(uuid, () => timedOutDevice.connect(fallbackConnectOptions));
+            if (mtuHandshakeRefused) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] skipping MTU refresh after cancelled MTU connect', {
+                    connectIdSuffix: uuid.slice(-8),
+                    actual: device.mtu,
+                });
+            }
+            else {
+                const negotiatedMtu = yield resolveNegotiatedMtu(device, transactionId => blePlxManager.cancelTransaction(transactionId));
+                device = negotiatedMtu.device;
+                if (negotiatedMtu.abandoned) {
+                    yield this.runNativeTeardown(uuid, blePlxManager, () => __awaiter(this, void 0, void 0, function* () {
+                        yield this.runBestEffortNativeOperation('mtu abandoned: cancel manager connection', () => blePlxManager.cancelDeviceConnection(uuid));
+                    }));
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'BLE MTU negotiation abandoned, reconnecting');
                 }
             }
             if (this.stopped)
@@ -1893,7 +1899,7 @@ class ReactNativeBleTransport {
                 return result;
             }
             catch (error) {
-                if (timedOut || isNativeOperationTimeoutError(error)) {
+                if (timedOut || isAbandonedNativeOperationError(error)) {
                     const resetManager = this.abandonStalledConnection(uuid, timedOut ? 'gatt-backstop' : 'gatt-native');
                     if (resetManager) {
                         throw this.createWedgedBleSetupError();
@@ -2050,6 +2056,8 @@ class ReactNativeBleTransport {
         this.acquiringProtocolV2.clear();
         this.sessionProtocols.clear();
         this.protocolReprobeFailures.clear();
+        this.silentDetections.clear();
+        this.protocolWakeAttempts.clear();
         this.writeTimeoutCounts.clear();
         this.connectionSetupTimeoutCounts.clear();
         this.monitorTokens.clear();
@@ -2123,6 +2131,7 @@ class ReactNativeBleTransport {
                 !protocolHint &&
                 reprobeFailures < PROTOCOL_REPROBE_FALLBACK_ATTEMPTS;
             const probeOrder = trustSessionProtocol ? [sessionProtocol] : fullProbeOrder;
+            yield this.wakeSilentProtocolV1Device(uuid, probeOrder);
             for (let i = 0; i < probeOrder.length; i += 1) {
                 const protocol = probeOrder[i];
                 if (i > 0) {
@@ -2142,6 +2151,8 @@ class ReactNativeBleTransport {
                         this.confirmedProtocolV2.add(uuid);
                     }
                     this.protocolReprobeFailures.delete(uuid);
+                    this.silentDetections.delete(uuid);
+                    this.protocolWakeAttempts.delete(uuid);
                     Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
                         deviceId: uuid,
                         protocol,
@@ -2150,6 +2161,7 @@ class ReactNativeBleTransport {
                     return protocol;
                 }
             }
+            this.silentDetections.add(uuid);
             if (trustSessionProtocol) {
                 this.protocolReprobeFailures.set(uuid, reprobeFailures + 1);
             }
@@ -2161,6 +2173,38 @@ class ReactNativeBleTransport {
             throw this.createProtocolDetectionError();
         });
     }
+    wakeSilentProtocolV1Device(uuid, probeOrder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] sending Protocol V1 Initialize wake', {
+                connectIdSuffix: uuid.slice(-8),
+            });
+            try {
+                this.probingProtocols.set(uuid, 'V1');
+                yield this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+            }
+            catch (error) {
+                if (shouldRethrowProtocolProbeError(error)) {
+                    this.clearProbeProtocol(uuid, 'V1');
+                    throw error;
+                }
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Protocol V1 Initialize wake did not answer:', error);
+            }
+            finally {
+                this.clearProbeProtocol(uuid, 'V1');
+            }
+        });
+    }
     resetProbeStateAfterProtocolProbe(uuid, protocol) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
@@ -2478,11 +2522,11 @@ class ReactNativeBleTransport {
             const transport = this.getCachedTransport(uuid);
             if (!shouldRefreshNegotiatedMtu(transport.mtuSize))
                 return;
-            const { device: refreshedDevice } = yield requestNegotiatedMtu(transport.device, 'highThroughput', 1, transactionId => { var _a; return (_a = this.blePlxManager) === null || _a === void 0 ? void 0 : _a.cancelTransaction(transactionId); });
+            const { device: refreshedDevice, abandoned } = yield requestNegotiatedMtu(transport.device, 'highThroughput', 1, transactionId => { var _a; return (_a = this.blePlxManager) === null || _a === void 0 ? void 0 : _a.cancelTransaction(transactionId); });
             transport.device = refreshedDevice;
             transport.mtuSize =
                 typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport.mtuSize;
-            if (shouldRefreshNegotiatedMtu(transport.mtuSize)) {
+            if (abandoned || shouldRefreshNegotiatedMtu(transport.mtuSize)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `Protocol V2 high-throughput BLE MTU unavailable: ${String(transport.mtuSize)}`);
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.2-alpha.114",
+  "version": "1.2.2-alpha.115",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,11 +20,11 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.2-alpha.114",
-    "@onekeyfe/hd-shared": "1.2.2-alpha.114",
-    "@onekeyfe/hd-transport": "1.2.2-alpha.114",
+    "@onekeyfe/hd-core": "1.2.2-alpha.115",
+    "@onekeyfe/hd-shared": "1.2.2-alpha.115",
+    "@onekeyfe/hd-transport": "1.2.2-alpha.115",
     "@onekeyfe/react-native-ble-utils": "0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "6490382eeeb6bda264b71c7e9bf96143840ee1cb"
+  "gitHead": "a115ca6998586c05c22996f278091778fd5471f1"
 }

package/src/__tests__/protocolV2Link.test.ts

@@ -169,13 +169,11 @@ const createHarness = ({
     serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
     isConnected: jest.fn(() => Promise.resolve(true)),
     cancelConnection: jest.fn(() => Promise.resolve()),
-    connect: jest.fn(),
     onDisconnected: jest.fn(callback => {
       disconnectCallback = callback;
       return { remove: jest.fn() };
     }),
   } as any;
-  device.connect.mockResolvedValue(device);
   device.requestMTU = jest.fn(() => Promise.resolve(device));
   device.requestConnectionPriority = jest.fn(() => Promise.resolve(device));
   const bleManager = {
@@ -1128,53 +1126,86 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.release(uuid, true);
   });
 
-  test('bounds a stalled MTU negotiation and continues protocol probing', async () => {
+  test('drops the link when a stalled MTU negotiation is abandoned', async () => {
     const { transport, uuid, device, bleManager } = createHarness();
     device.mtu = 23;
     device.requestMTU.mockImplementationOnce(() => new Promise(() => {}));
+    const { resolveCharacteristics } = transport as any;
 
-    await expect(transport.acquire({ uuid })).resolves.toEqual({
-      uuid,
-      protocolType: 'V2',
+    // cancelTransaction only disposes the JS subscription: RxAndroidBle releases the
+    // connection's serial queue from onComplete/onError alone, so the abandoned exchange
+    // keeps it until its own native timeout. Service discovery must not queue behind it.
+    await expect(transport.acquire({ uuid })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleConnectedError,
     });
     const transactionId = device.requestMTU.mock.calls[0]?.[1];
     expect(transactionId).toEqual(expect.stringContaining(`${uuid}:mtu:connected:0:`));
     expect(bleManager.cancelTransaction).toHaveBeenCalledWith(transactionId);
-    expect(device.cancelConnection).toHaveBeenCalled();
-    expect(device.connect).toHaveBeenCalledWith(
-      expect.objectContaining({ timeout: expect.any(Number) })
-    );
-    expect(device.connect.mock.calls.at(-1)?.[0]).not.toHaveProperty('requestMTU');
-    expect(device.requestMTU).toHaveBeenCalledTimes(1);
-    expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
-    await transport.release(uuid, true);
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(resolveCharacteristics).not.toHaveBeenCalled();
   }, 10_000);
 
-  test('does not request MTU again after connect falls back without requestMTU', async () => {
-    const { BleError: BleErrorMock, BleErrorCode } = jest.requireMock('react-native-ble-plx');
+  test('skips the MTU refresh after an MTU-bearing connect was cancelled', async () => {
     const { transport, uuid, device } = createHarness();
     device.mtu = 23;
-    device.isConnected.mockResolvedValueOnce(false).mockResolvedValue(true);
-    device.connect
-      .mockRejectedValueOnce(
-        Object.assign(new BleErrorMock('Operation was cancelled'), {
-          errorCode: BleErrorCode.OperationCancelled,
-        })
-      )
-      .mockResolvedValue(device);
+    let connected = false;
+    device.isConnected.mockImplementation(() => Promise.resolve(connected));
+    const cancelled = Object.assign(new Error('Operation was cancelled'), { errorCode: 2 });
+    device.connect = jest
+      .fn()
+      .mockRejectedValueOnce(cancelled)
+      .mockImplementation(() => {
+        connected = true;
+        return Promise.resolve(device);
+      });
 
     await expect(transport.acquire({ uuid })).resolves.toEqual({
       uuid,
       protocolType: 'V2',
     });
+
+    // ble-plx applies the connect timeout to establishConnection -> refreshGatt ->
+    // requestMtu as one chain, so the fallback means this peripheral did not finish the
+    // MTU exchange. Asking again would only park a second abandoned exchange.
     expect(device.connect).toHaveBeenCalledTimes(2);
-    expect(device.connect.mock.calls[0][0]).toEqual(expect.objectContaining({ requestMTU: 247 }));
-    expect(device.connect.mock.calls[1][0]).not.toHaveProperty('requestMTU');
     expect(device.requestMTU).not.toHaveBeenCalled();
     expect((transport as any).getCachedTransport(uuid).mtuSize).toBe(23);
     await transport.release(uuid, true);
   });
 
+  test('cleans up a cancelled native GATT setup, not only a timed-out one', async () => {
+    const { transport, uuid, bleManager } = createHarness();
+    const cancelled = Object.assign(new Error('Operation was cancelled'), { errorCode: 2 });
+    (transport as any).resolveCharacteristics = jest.fn(() => Promise.reject(cancelled));
+
+    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+  });
+
+  test('spends one Initialize wake on the detection after a fully silent one', async () => {
+    const { transport, uuid } = createHarness();
+    const probes = transport as any;
+    jest.spyOn(probes, 'probeProtocolV1').mockResolvedValue(false);
+    jest.spyOn(probes, 'probeProtocolV2').mockResolvedValue(false);
+    const callProtocolV1 = jest.spyOn(probes, 'callProtocolV1').mockResolvedValue({});
+
+    // Nothing has gone silent yet, so the device keeps whatever session it has.
+    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
+    expect(callProtocolV1).not.toHaveBeenCalled();
+
+    // The previous detection answered on no protocol, which is what a sleeping Classic
+    // looks like, so this one wakes on the fresh link before probing.
+    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
+    expect(callProtocolV1).toHaveBeenCalledTimes(1);
+    expect(callProtocolV1.mock.calls[0]?.[1]).toBe('Initialize');
+
+    // Still silent: the wake is not repeated, so a device that is simply away is not
+    // pushed into a fresh wallet session on every poll.
+    callProtocolV1.mockClear();
+    await expect(transport.acquire({ uuid })).rejects.toBeDefined();
+    expect(callProtocolV1).not.toHaveBeenCalled();
+  });
+
   test('accepts a stable low MTU without the delayed refresh loop', async () => {
     const { transport, uuid, device } = createHarness();
     device.mtu = 185;

package/src/index.ts

@@ -300,16 +300,22 @@ const shouldRethrowBleSetupError = (error: unknown): boolean =>
   isConnectTimeoutError(error) || isWedgedBleSetupError(error);
 const isNativeOperationTimeoutError = (error: unknown): boolean =>
   (error as { errorCode?: unknown })?.errorCode === BleErrorCode.OperationTimedOut;
-const isMtuOrCancelledConnectError = (error: unknown): boolean => {
+/**
+ * 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 errorCode = (error as { errorCode?: unknown })?.errorCode;
   return (
-    errorCode === BleErrorCode.DeviceMTUChangeFailed ||
-    errorCode === BleErrorCode.OperationCancelled
+    errorCode === BleErrorCode.OperationTimedOut || errorCode === BleErrorCode.OperationCancelled
   );
 };
 
-type NegotiatedMtuResult = { device: Device; timedOut: boolean };
-
 export type IOneKeyDevice = OneKeyDeviceInfoBase & Device;
 
 const tryToGetConfiguration = (device: Device) => {
@@ -321,13 +327,26 @@ 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, timedOut: false };
+  if (Platform.OS !== 'ios' && Platform.OS !== 'android') return { device, abandoned: false };
 
   const transactionId = `${device.id}:mtu:${stage}:${attempt}:${Date.now()}`;
   let timeoutId: ReturnType<typeof setTimeout> | undefined;
@@ -350,7 +369,7 @@ const requestNegotiatedMtu = async (
         }, BLE_MTU_REQUEST_TIMEOUT_MS);
       }),
     ]);
-    return { device: mtuDevice, timedOut: false };
+    return { device: mtuDevice, abandoned: false };
   } catch (error) {
     if (timedOut && cancelTransaction) {
       try {
@@ -376,10 +395,9 @@ const requestNegotiatedMtu = async (
       stage,
       attempt,
       actual: device.mtu,
-      timedOut,
       error: error instanceof Error ? error.message : String(error),
     });
-    return { device, timedOut };
+    return { device, abandoned: timedOut };
   } finally {
     if (timeoutId) clearTimeout(timeoutId);
   }
@@ -391,7 +409,7 @@ const resolveNegotiatedMtu = (
 ): Promise<NegotiatedMtuResult> =>
   shouldRefreshNegotiatedMtu(device.mtu)
     ? requestNegotiatedMtu(device, 'connected', 0, cancelTransaction)
-    : Promise.resolve({ device, timedOut: false });
+    : Promise.resolve({ device, abandoned: false });
 
 type IOBleErrorRemap = Error | BleError | null | undefined;
 
@@ -475,6 +493,17 @@ 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 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
@@ -1072,6 +1101,14 @@ export default class ReactNativeBleTransport {
     }
 
     let device: Device | null = null;
+    /**
+     * Set when an MTU-bearing connect had to fall back to `fallbackConnectOptions`.
+     * ble-plx applies `connectOptions.timeout` to the whole establishConnection ->
+     * refreshGatt -> requestMtu chain, so that fallback means the peripheral did not
+     * finish the MTU exchange on this link. Asking again below would only park a
+     * second abandoned exchange on the connection's serial queue.
+     */
+    let mtuHandshakeRefused = false;
 
     if (forceCleanRunPromise && this.runPromise) {
       const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
@@ -1082,7 +1119,6 @@ export default class ReactNativeBleTransport {
     }
 
     const blePlxManager = await this.getPlxManager();
-    let skipPostConnectMtu = false;
     try {
       await subscribeBleOn(blePlxManager);
     } catch (error) {
@@ -1134,9 +1170,18 @@ export default class ReactNativeBleTransport {
         if (shouldRethrowBleSetupError(e)) {
           throw e;
         }
-        if (isMtuOrCancelledConnectError(e)) {
-          skipPostConnectMtu = true;
+        if (
+          e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
+          e.errorCode === BleErrorCode.OperationCancelled
+        ) {
           Log?.debug('first try to reconnect without params');
+          mtuHandshakeRefused = true;
+          // 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)
           );
@@ -1166,9 +1211,18 @@ export default class ReactNativeBleTransport {
         if (shouldRethrowBleSetupError(e)) {
           throw e;
         }
-        if (isMtuOrCancelledConnectError(e)) {
-          skipPostConnectMtu = true;
+        if (
+          e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
+          e.errorCode === BleErrorCode.OperationCancelled
+        ) {
           Log?.debug('second try to reconnect without params');
+          mtuHandshakeRefused = true;
+          // 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)
@@ -1209,26 +1263,27 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.BleConnectedError, 'device is not connected');
     }
     if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
-    // 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.
-    if (!skipPostConnectMtu) {
-      const mtuResult = await resolveNegotiatedMtu(device, transactionId =>
+    if (mtuHandshakeRefused) {
+      Log?.debug('[ReactNativeBleTransport] skipping MTU refresh after cancelled MTU connect', {
+        connectIdSuffix: uuid.slice(-8),
+        actual: device.mtu,
+      });
+    } else {
+      const negotiatedMtu = await resolveNegotiatedMtu(device, transactionId =>
         blePlxManager.cancelTransaction(transactionId)
       );
-      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)
+      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'
         );
       }
     }
@@ -2127,7 +2182,7 @@ export default class ReactNativeBleTransport {
       succeeded = true;
       return result;
     } catch (error) {
-      if (timedOut || isNativeOperationTimeoutError(error)) {
+      if (timedOut || isAbandonedNativeOperationError(error)) {
         const resetManager = this.abandonStalledConnection(
           uuid,
           timedOut ? 'gatt-backstop' : 'gatt-native'
@@ -2331,6 +2386,8 @@ export default class ReactNativeBleTransport {
     // Keep transport-lifetime V2 proof so the same endpoint can finish a no-probe
     // 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();
@@ -2442,6 +2499,8 @@ export default class ReactNativeBleTransport {
       reprobeFailures < PROTOCOL_REPROBE_FALLBACK_ATTEMPTS;
     const probeOrder: ProtocolType[] = trustSessionProtocol ? [sessionProtocol] : fullProbeOrder;
 
+    await this.wakeSilentProtocolV1Device(uuid, probeOrder);
+
     for (let i = 0; i < probeOrder.length; i += 1) {
       const protocol = probeOrder[i];
       if (i > 0) {
@@ -2463,6 +2522,8 @@ export default class ReactNativeBleTransport {
           this.confirmedProtocolV2.add(uuid);
         }
         this.protocolReprobeFailures.delete(uuid);
+        this.silentDetections.delete(uuid);
+        this.protocolWakeAttempts.delete(uuid);
         Log?.debug('[ReactNativeBleTransport] protocol detected', {
           deviceId: uuid,
           protocol,
@@ -2472,6 +2533,10 @@ 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);
+
     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.
@@ -2485,6 +2550,47 @@ export default class ReactNativeBleTransport {
     throw this.createProtocolDetectionError();
   }
 
+  /**
+   * 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.
+   */
+  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);
+
+    Log?.debug('[ReactNativeBleTransport] sending Protocol V1 Initialize wake', {
+      connectIdSuffix: uuid.slice(-8),
+    });
+    try {
+      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);
+    } finally {
+      this.clearProbeProtocol(uuid, 'V1');
+    }
+  }
+
   private async resetProbeStateAfterProtocolProbe(uuid: string, protocol: ProtocolType) {
     const transport = transportCache[uuid];
     await this.protocolV2Links.invalidateLink(
@@ -2864,7 +2970,7 @@ export default class ReactNativeBleTransport {
     const transport = this.getCachedTransport(uuid);
     if (!shouldRefreshNegotiatedMtu(transport.mtuSize)) return;
 
-    const { device: refreshedDevice } = await requestNegotiatedMtu(
+    const { device: refreshedDevice, abandoned } = await requestNegotiatedMtu(
       transport.device,
       'highThroughput',
       1,
@@ -2874,7 +2980,7 @@ export default class ReactNativeBleTransport {
     transport.mtuSize =
       typeof refreshedDevice.mtu === 'number' ? refreshedDevice.mtu : transport.mtuSize;
 
-    if (shouldRefreshNegotiatedMtu(transport.mtuSize)) {
+    if (abandoned || shouldRefreshNegotiatedMtu(transport.mtuSize)) {
       throw ERRORS.TypedError(
         HardwareErrorCode.BleConnectedError,
         `Protocol V2 high-throughput BLE MTU unavailable: ${String(transport.mtuSize)}`