@onekeyfe/hd-transport-react-native 1.2.0-alpha.54 → 1.2.0-alpha.55

package/src/index.ts

@@ -28,6 +28,7 @@ import {
   HardwareErrorCode,
   createDeferred,
   isOnekeyBluetoothDevice,
+  isPro2FindMyAdvertisementName,
 } from '@onekeyfe/hd-shared';
 
 import { getConnectedDeviceIds, onDeviceBondState, pairDevice } from './BleManager';
@@ -60,6 +61,7 @@ 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;
@@ -106,22 +108,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;
@@ -272,17 +258,6 @@ 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();
-
   private deviceProtocolHints: Map<string, ProtocolType> = new Map();
 
   private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
@@ -607,12 +582,21 @@ export default class ReactNativeBleTransport {
           }
 
           const displayName = getDeviceDisplayName(device);
-          const isOneKey = isOnekeyBluetoothDevice({
-            id: device?.id,
-            name: device?.name,
-            localName: device?.localName,
-            serviceUuids: device?.serviceUUIDs,
-          });
+          // iOS may report a service-only advertisement before the named scan response.
+          // Do not cache that incomplete advertisement as an unknown device.
+          const isUnnamedIOSPeripheral = Platform.OS === 'ios' && !displayName?.trim();
+          const isFindMyPeripheral =
+            isPro2FindMyAdvertisementName(device?.name) ||
+            isPro2FindMyAdvertisementName(device?.localName);
+          const isOneKey =
+            !isUnnamedIOSPeripheral &&
+            !isFindMyPeripheral &&
+            isOnekeyBluetoothDevice({
+              id: device?.id,
+              name: device?.name,
+              localName: device?.localName,
+              serviceUuids: device?.serviceUUIDs,
+            });
           if (isOneKey) {
             addDevice(device as unknown as Device);
           } else if (displayName && /\bpro\s*2\b/i.test(displayName)) {
@@ -633,7 +617,12 @@ export default class ReactNativeBleTransport {
               'localName' in device && typeof device.localName === 'string'
                 ? device.localName
                 : null;
+            const isFindMyPeripheral =
+              isPro2FindMyAdvertisementName(device.name) ||
+              isPro2FindMyAdvertisementName(localName);
+
             if (
+              !isFindMyPeripheral &&
               isOnekeyBluetoothDevice({
                 id: device.id,
                 name: device.name,
@@ -906,7 +895,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
@@ -976,7 +965,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;
@@ -1010,7 +999,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);
@@ -1074,7 +1063,6 @@ export default class ReactNativeBleTransport {
     }
 
     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);
@@ -1141,25 +1129,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;
@@ -1185,9 +1156,6 @@ export default class ReactNativeBleTransport {
             chunk = ByteBuffer.allocate(packetCapacity);
           } catch (e) {
             onError(e);
-            if (isWedgedWriteError(e)) {
-              throw e;
-            }
             throw ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
           }
         }
@@ -1219,9 +1187,6 @@ export default class ReactNativeBleTransport {
             }
           } catch (e) {
             onError(e);
-            if (isWedgedWriteError(e)) {
-              throw e;
-            }
             throw ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
           }
         }
@@ -1235,15 +1200,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);
         }
       );
@@ -1264,12 +1223,7 @@ export default class ReactNativeBleTransport {
           // eslint-disable-next-line no-constant-condition
           while (true) {
             try {
-              await this.writeBlePacket(
-                uuid,
-                data,
-                payload => transport.writeCharacteristic.writeWithoutResponse(payload),
-                isCurrentOwner
-              );
+              await transport.writeCharacteristic.writeWithoutResponse(data);
               return;
             } catch (error) {
               const retryType = getFirmwareUploadWriteRetryType(error);
@@ -1288,7 +1242,7 @@ export default class ReactNativeBleTransport {
           }
         },
         e => {
-          releaseOwnershipIfCurrent();
+          this.runPromise = null;
           Log?.error('writeCharacteristic write error: ', e);
         }
       );
@@ -1297,18 +1251,16 @@ export default class ReactNativeBleTransport {
         const outData = o.toString('base64');
         // Upload resources on low-end phones may OOM
         try {
-          await this.writeBlePacket(
-            uuid,
-            outData,
-            payload => transport.writeCharacteristic.writeWithoutResponse(payload),
-            isCurrentOwner
-          );
+          const shouldUseWriteWithResponse =
+            Platform.OS === 'ios' && transport.writeCharacteristic.isWritableWithResponse;
+          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) {
@@ -1351,13 +1303,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);
@@ -1437,7 +1384,6 @@ export default class ReactNativeBleTransport {
       delete transportCache[session];
     }
     this.deviceProtocol.delete(session);
-    this.probingProtocols.delete(session);
     this.deviceProtocolHints.delete(session);
     this.protocolV2Assemblers.delete(session);
     this.resetProtocolV2Frames(session);
@@ -1472,105 +1418,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.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,
@@ -1586,25 +1433,34 @@ 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,
     protocolHint?: ProtocolType,
     rebuildTransport?: () => Promise<void>
   ): Promise<ProtocolType> {
+    if (Platform.OS === 'ios') {
+      const protocol = expectedProtocol ?? protocolHint ?? 'V1';
+      let source = 'ios-legacy-default';
+      if (expectedProtocol) {
+        source = 'expected';
+      } else if (protocolHint) {
+        source = 'hint';
+      }
+      this.deviceProtocol.set(uuid, protocol);
+      Log?.debug('[ReactNativeBleTransport] protocol selected', {
+        deviceId: uuid,
+        protocol,
+        source,
+      });
+      return protocol;
+    }
+
     if (expectedProtocol === 'V1') {
       if (await this.probeProtocolV1(uuid)) {
         this.deviceProtocol.set(uuid, 'V1');
@@ -1662,7 +1518,6 @@ export default class ReactNativeBleTransport {
     }
 
     this.deviceProtocol.delete(uuid);
-    this.probingProtocols.delete(uuid);
     throw this.createProtocolDetectionError();
   }
 
@@ -1724,20 +1579,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;
     }
   }
@@ -1747,7 +1596,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) =>
@@ -1762,8 +1611,6 @@ export default class ReactNativeBleTransport {
     });
     if (!detected) {
       this.clearProbeProtocol(uuid, 'V2');
-    } else {
-      this.probingProtocols.delete(uuid);
     }
     return detected;
   }
@@ -1845,12 +1692,15 @@ export default class ReactNativeBleTransport {
   }
 
   private async writeProtocolV2Packet(
-    uuid: string,
     transport: BleTransport,
     base64: string,
     context: ProtocolV2CallContext,
     assertCurrentGeneration: () => void
   ) {
+    const shouldUseWriteWithResponse =
+      Platform.OS === 'ios' &&
+      !context.highVolume &&
+      transport.writeCharacteristic.isWritableWithResponse;
     let attempt = 0;
     for (;;) {
       assertCurrentGeneration();
@@ -1858,21 +1708,11 @@ export default class ReactNativeBleTransport {
         throw new Error(`Protocol V2 BLE write aborted for ${context.messageName}`);
       }
       try {
-        await this.writeBlePacket(
-          uuid,
-          base64,
-          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) {
@@ -1895,7 +1735,6 @@ export default class ReactNativeBleTransport {
   }
 
   private async writeProtocolV2Frame(
-    uuid: string,
     transport: BleTransport,
     frame: Uint8Array,
     context: ProtocolV2CallContext,
@@ -1908,19 +1747,25 @@ export default class ReactNativeBleTransport {
       androidPacketLength: tuning.androidPacketLength,
       mtu: Platform.OS === 'android' ? transport.mtuSize : undefined,
     });
+    // 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,
@@ -1985,13 +1830,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();
@@ -2016,6 +1855,6 @@ export default class ReactNativeBleTransport {
   }
 
   getProtocolType(path: string): ProtocolType | undefined {
-    return this.getActiveProtocol(path);
+    return this.deviceProtocol.get(path);
   }
 }