@onekeyfe/hd-transport-react-native 1.1.34-alpha.3 → 1.1.34-alpha.4

package/src/index.ts

@@ -9,44 +9,33 @@ import {
 } from 'react-native-ble-plx';
 import ByteBuffer from 'bytebuffer';
 import transport, {
+  COMMON_HEADER_SIZE,
   LogBlockCommand,
   type OneKeyDeviceInfoBase,
-  PROTOCOL_V1_MESSAGE_HEADER_SIZE,
-  PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
-  PROTOCOL_V2_CHANNEL_BLE_UART,
-  type ProtocolType,
-  ProtocolV2FrameAssembler,
-  ProtocolV2LinkManager,
-  type TransportCallOptions,
-  probeProtocolV2 as probeProtocolV2Helper,
 } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareErrorCode, createDeferred, isOnekeyDevice } from '@onekeyfe/hd-shared';
+import { LoggerNames, getLogger } from '@onekeyfe/hd-core';
 
 import { getConnectedDeviceIds, onDeviceBondState, pairDevice } from './BleManager';
-import { hasWritableCapability, resolveProtocolV2PacketCapacity } from './bleStrategy';
 import { subscribeBleOn } from './subscribeBleOn';
 import {
   ANDROID_PACKET_LENGTH,
   IOS_PACKET_LENGTH,
-  getBleUuidKey,
   getBluetoothServiceUuids,
   getInfosForServiceUuid,
-  isSameBleUuid,
 } from './constants';
 import { isHeaderChunk } from './utils/validateNotify';
 import BleTransport from './BleTransport';
 import timer from './utils/timer';
-import { bleLogger, setBleLogger } from './logger';
-import { createTransportCallLog } from './transportLog';
 
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { Characteristic, Device, Subscription } from 'react-native-ble-plx';
 import type EventEmitter from 'events';
 import type { BleAcquireInput, TransportOptions } from './types';
 
-const { check, ProtocolV1, parseConfigure } = transport;
+const { check, buildBuffers, receiveOne, parseConfigure } = transport;
 
-const Log = bleLogger;
+const Log = getLogger(LoggerNames.HdBleTransport);
 
 const transportCache: Record<string, BleTransport> = {};
 const FIRMWARE_UPLOAD_WRITE_BURST_SIZE = Platform.OS === 'ios' ? 4 : 5;
@@ -65,6 +54,11 @@ type ResolvedBleCharacteristics = {
   notifyCharacteristic: Characteristic;
 };
 
+const getBleIdentityName = (device?: { name?: string | null } | null): string | null => {
+  const localName = (device as { localName?: string | null } | undefined)?.localName;
+  return device?.name ?? localName ?? null;
+};
+
 const delay = (ms: number) =>
   new Promise<void>(resolve => {
     setTimeout(resolve, ms);
@@ -103,76 +97,9 @@ const getFirmwareUploadWriteRetryType = (error: unknown): FirmwareUploadWriteRet
 
 const resolveFirmwareUploadRetryDelay = (attempt: number, baseDelayMs = 200, maxDelayMs = 1200) =>
   Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
-const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
-const PROTOCOL_V2_PROBE_TIMEOUT_MS = 10_000;
-const DEVICE_SCAN_TIMEOUT_MS = 8000;
-const IOS_NOTIFY_READY_DELAY_MS = 150;
-const ANDROID_NOTIFY_READY_DELAY_MS = 300;
-export type ProtocolV2BleTuning = {
-  iosPacketLength?: number;
-  androidPacketLength?: number;
-};
-
-type ResolvedProtocolV2BleTuning = Required<ProtocolV2BleTuning>;
-
-const DEFAULT_PROTOCOL_V2_BLE_TUNING: ResolvedProtocolV2BleTuning = {
-  iosPacketLength: IOS_PACKET_LENGTH,
-  androidPacketLength: ANDROID_PACKET_LENGTH,
-};
-
-let protocolV2BleTuning: ResolvedProtocolV2BleTuning = { ...DEFAULT_PROTOCOL_V2_BLE_TUNING };
-
-const normalizePositiveInteger = (value: unknown, fallback: number) => {
-  const normalized = Number(value);
-  if (!Number.isFinite(normalized) || normalized <= 0) return fallback;
-  return Math.floor(normalized);
-};
-
-export function configureProtocolV2BleTuning(tuning: ProtocolV2BleTuning = {}) {
-  protocolV2BleTuning = {
-    iosPacketLength: normalizePositiveInteger(
-      tuning.iosPacketLength,
-      protocolV2BleTuning.iosPacketLength
-    ),
-    androidPacketLength: normalizePositiveInteger(
-      tuning.androidPacketLength,
-      protocolV2BleTuning.androidPacketLength
-    ),
-  };
-  Log?.debug('[ReactNativeBleTransport] BLE tuning configured', protocolV2BleTuning);
-}
-
-export function resetProtocolV2BleTuning() {
-  protocolV2BleTuning = { ...DEFAULT_PROTOCOL_V2_BLE_TUNING };
-  Log?.debug('[ReactNativeBleTransport] BLE tuning reset', protocolV2BleTuning);
-}
-
-export function getProtocolV2BleTuning() {
-  return { ...protocolV2BleTuning };
-}
-
-function inferProtocolHintFromDeviceName(name?: string | null): ProtocolType | undefined {
-  return /\bpro\s*2\b/i.test(name ?? '') ? 'V2' : undefined;
-}
-
-function getDeviceDisplayName(device?: Device | null) {
-  return device?.name || device?.localName || null;
-}
-
-function isGenericBleService(uuid?: string | null) {
-  return ['1800', '1801', '180a'].includes(getBleUuidKey(uuid));
-}
 
-function hasKnownOneKeyService(device?: Device | null) {
-  return (device?.serviceUUIDs ?? []).some(serviceUuid =>
-    getInfosForServiceUuid(serviceUuid, 'classic')
-  );
-}
-
-const ANDROID_REQUEST_MTU = 256;
-
-const connectOptions: Record<string, unknown> = {
-  requestMTU: ANDROID_REQUEST_MTU,
+let connectOptions: Record<string, unknown> = {
+  requestMTU: 256,
   timeout: 3000,
   refreshGatt: 'OnConnected',
 };
@@ -181,30 +108,12 @@ export type IOneKeyDevice = OneKeyDeviceInfoBase & Device;
 
 const tryToGetConfiguration = (device: Device) => {
   if (!device || !device.serviceUUIDs) return null;
-  const serviceUUID = device.serviceUUIDs.find(uuid => getInfosForServiceUuid(uuid, 'classic'));
-  if (!serviceUUID) return null;
+  const [serviceUUID] = device.serviceUUIDs;
   const infos = getInfosForServiceUuid(serviceUUID, 'classic');
   if (!infos) return null;
   return infos;
 };
 
-const requestAndroidMtu = async (device: Device) => {
-  if (Platform.OS !== 'android') return device;
-
-  try {
-    const mtuDevice = await device.requestMTU(ANDROID_REQUEST_MTU);
-    Log?.debug('[ReactNativeBleTransport] MTU configured', {
-      deviceId: device.id,
-      requested: ANDROID_REQUEST_MTU,
-      actual: mtuDevice.mtu,
-    });
-    return mtuDevice;
-  } catch (error) {
-    Log?.debug('[ReactNativeBleTransport] Android MTU request failed:', error);
-    return device;
-  }
-};
-
 type IOBleErrorRemap = Error | BleError | null | undefined;
 
 function remapError(error: IOBleErrorRemap) {
@@ -242,15 +151,13 @@ export default class ReactNativeBleTransport {
 
   _messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
-  _messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
-
   name = 'ReactNativeBleTransport';
 
   configured = false;
 
   stopped = false;
 
-  scanTimeout = DEVICE_SCAN_TIMEOUT_MS;
+  scanTimeout = 3000;
 
   runPromise: Deferred<any> | null = null;
 
@@ -258,48 +165,11 @@ export default class ReactNativeBleTransport {
 
   firmwareUploadWriteRecoveryIds = new Set<string>();
 
-  /** Per-device protocol type detected by active wire-level probe after connect. */
-  private deviceProtocol: Map<string, ProtocolType> = new Map();
-
-  private deviceProtocolHints: Map<string, ProtocolType> = new Map();
-
-  private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
-
-  private protocolV2FrameQueues: Map<string, Uint8Array[]> = new Map();
-
-  private protocolV2FramePromises: Map<string, Deferred<Uint8Array>> = new Map();
-
-  private protocolV2Links = new ProtocolV2LinkManager<string>({
-    getSchemas: () => {
-      if (!this._messages || !this._messagesV2) {
-        throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
-      }
-      return {
-        protocolV1: this._messages,
-        protocolV2: this._messagesV2,
-      };
-    },
-    classifyError: () => 'link-fatal',
-    onLinkInvalidated: async (uuid, reason) => {
-      this.protocolV2Assemblers.get(uuid)?.reset();
-      this.rejectProtocolV2Frames(uuid, new Error(reason));
-      Log?.debug('[ReactNativeBleTransport] Protocol V2 link invalidated:', uuid, reason);
-      if (reason.startsWith('Protocol V2 link-fatal error:')) {
-        await this.release(uuid, true);
-      }
-    },
-  });
-
-  private monitorTokens: Map<string, number> = new Map();
-
-  private nextMonitorToken = 1;
-
   constructor(options: TransportOptions) {
-    this.scanTimeout = options.scanTimeout ?? DEVICE_SCAN_TIMEOUT_MS;
+    this.scanTimeout = options.scanTimeout ?? 3000;
   }
 
-  init(logger: any, emitter: EventEmitter) {
-    setBleLogger(logger);
+  init(_logger: any, emitter: EventEmitter) {
     this.emitter = emitter;
   }
 
@@ -309,13 +179,6 @@ export default class ReactNativeBleTransport {
     this._messages = messages;
   }
 
-  configureProtocolV2(signedData: any) {
-    this._messagesV2 = parseConfigure(signedData);
-    this.protocolV2Links
-      .invalidateAllLinks('Protocol V2 schema reconfigured')
-      .catch(error => Log?.debug('Protocol V2 schema link cleanup failed:', error));
-  }
-
   listen() {
     // empty
   }
@@ -343,29 +206,7 @@ export default class ReactNativeBleTransport {
       }
     }
 
-    let fallbackServiceUuid: string | undefined;
-
     if (!infos) {
-      const services = await device.services();
-      Log?.debug(
-        '[ReactNativeBleTransport] Known OneKey service UUID not found, discovered services:',
-        services?.map(service => service.uuid)
-      );
-
-      const knownService = services.find(service =>
-        getInfosForServiceUuid(service.uuid, 'classic')
-      );
-      const fallbackService =
-        knownService ?? services.find(service => !isGenericBleService(service.uuid)) ?? services[0];
-
-      if (fallbackService) {
-        fallbackServiceUuid = fallbackService.uuid;
-        characteristics = await device.characteristicsForService(fallbackService.uuid);
-        Log?.debug('[ReactNativeBleTransport] Using fallback BLE service:', fallbackService.uuid);
-      }
-    }
-
-    if (!infos && !fallbackServiceUuid) {
       try {
         Log?.debug('cancel connection when service not found');
         await device.cancelConnection();
@@ -375,13 +216,7 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
     }
 
-    const serviceUuid = infos?.serviceUuid ?? fallbackServiceUuid;
-    const writeUuid = infos?.writeUuid ?? '00000002-0000-1000-8000-00805f9b34fb';
-    const notifyUuid = infos?.notifyUuid ?? '00000003-0000-1000-8000-00805f9b34fb';
-
-    if (!serviceUuid) {
-      throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
-    }
+    const { serviceUuid, writeUuid, notifyUuid } = infos;
 
     if (!characteristics) {
       characteristics = await device.characteristicsForService(serviceUuid);
@@ -394,9 +229,9 @@ export default class ReactNativeBleTransport {
     let writeCharacteristic;
     let notifyCharacteristic;
     for (const c of characteristics) {
-      if (isSameBleUuid(c.uuid, writeUuid)) {
+      if (c.uuid === writeUuid) {
         writeCharacteristic = c;
-      } else if (isSameBleUuid(c.uuid, notifyUuid)) {
+      } else if (c.uuid === notifyUuid) {
         notifyCharacteristic = c;
       }
     }
@@ -409,7 +244,7 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError('BLECharacteristicNotFound: notify characteristic not found');
     }
 
-    if (!hasWritableCapability(writeCharacteristic)) {
+    if (!writeCharacteristic.isWritableWithResponse) {
       throw ERRORS.TypedError('BLECharacteristicNotWritable: write characteristic not writable');
     }
 
@@ -432,10 +267,6 @@ export default class ReactNativeBleTransport {
         Log?.debug('device disconnect ignored during FirmwareUpload write recovery: ', uuid);
         return;
       }
-      if (transportCache[uuid] !== transport) {
-        Log?.debug('device disconnect ignored for stale transport: ', device?.id);
-        return;
-      }
 
       try {
         Log?.debug('device disconnect: ', device?.id);
@@ -445,14 +276,12 @@ export default class ReactNativeBleTransport {
           connectId: device?.id,
         });
         if (this.runPromise) {
-          const error = ERRORS.TypedError(HardwareErrorCode.BleConnectedError);
-          this.runPromise.reject(error);
-          this.rejectAllProtocolV2Frames(error);
+          this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError));
         }
       } catch (e) {
         Log?.debug('device disconnect error: ', e);
       } finally {
-        this.release(uuid, true);
+        this.release(uuid);
       }
     });
   }
@@ -475,6 +304,7 @@ export default class ReactNativeBleTransport {
             e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
             e.errorCode === BleErrorCode.OperationCancelled
           ) {
+            connectOptions = {};
             device = await device.connect();
           } else if (e.errorCode !== BleErrorCode.DeviceAlreadyConnected) {
             throw e;
@@ -489,18 +319,7 @@ export default class ReactNativeBleTransport {
       transport.device = device;
       transport.writeCharacteristic = writeCharacteristic;
       transport.notifyCharacteristic = notifyCharacteristic;
-      const monitorToken = this.nextMonitorToken;
-      this.nextMonitorToken += 1;
-      const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
-      transport.monitorToken = monitorToken;
-      transport.notifyTransactionId = notifyTransactionId;
-      this.monitorTokens.set(uuid, monitorToken);
-      transport.notifySubscription = this._monitorCharacteristic(
-        notifyCharacteristic,
-        uuid,
-        monitorToken,
-        notifyTransactionId
-      );
+      transport.notifySubscription = this._monitorCharacteristic(notifyCharacteristic, uuid);
       this.attachDisconnectSubscription(transport, device, uuid);
     } finally {
       this.firmwareUploadWriteRecoveryIds.delete(uuid);
@@ -546,11 +365,11 @@ export default class ReactNativeBleTransport {
       blePlxManager.startDeviceScan(
         getBluetoothServiceUuids(),
         {
-          allowDuplicates: true,
           scanMode: ScanMode.LowLatency,
         },
         (error, device) => {
           if (error) {
+            Log?.debug('ble scan manager: ', blePlxManager);
             Log?.debug('ble scan error: ', error);
             if (
               [BleErrorCode.BluetoothPoweredOff, BleErrorCode.BluetoothInUnknownState].includes(
@@ -573,20 +392,14 @@ export default class ReactNativeBleTransport {
             return;
           }
 
-          const displayName = getDeviceDisplayName(device);
-          const isOneKey =
-            isOnekeyDevice(device?.name ?? null, device?.id) ||
-            isOnekeyDevice(device?.localName ?? null, device?.id) ||
-            hasKnownOneKeyService(device);
-          if (isOneKey) {
+          if (isOnekeyDevice(getBleIdentityName(device), device?.id)) {
+            Log?.debug('search device start ======================');
+            const { name, localName, id } = device ?? {};
+            Log?.debug(
+              `device name: ${name ?? ''}\nlocalName: ${localName ?? ''}\nid: ${id ?? ''}`
+            );
             addDevice(device as unknown as Device);
-          } else if (displayName && /\bpro\s*2\b/i.test(displayName)) {
-            Log?.debug('[ReactNativeBleTransport] Pro2-like BLE device was not accepted:', {
-              name: device?.name,
-              localName: device?.localName,
-              id: device?.id,
-              serviceUUIDs: device?.serviceUUIDs,
-            });
+            Log?.debug('search device end ======================\n');
           }
         }
       );
@@ -598,6 +411,7 @@ export default class ReactNativeBleTransport {
             const hasCachedServiceUuid = Boolean(serviceUUIDs?.length);
             const keepDevice = Platform.OS === 'ios' || hasCachedServiceUuid;
             if (keepDevice) {
+              Log?.debug('search connected peripheral: ', device.id);
               addDevice(device as unknown as Device);
             }
           }
@@ -606,22 +420,7 @@ export default class ReactNativeBleTransport {
 
       const addDevice = (device: Device) => {
         if (deviceList.every(d => d.id !== device.id)) {
-          const displayName = getDeviceDisplayName(device) ?? 'Unknown BLE Device';
-          const protocolHint = inferProtocolHintFromDeviceName(displayName);
-          if (protocolHint) {
-            this.deviceProtocolHints.set(device.id, protocolHint);
-          }
-          deviceList.push({
-            ...device,
-            name: displayName,
-            commType: 'ble',
-          } as IOneKeyDevice);
-          Log?.debug('[ReactNativeBleTransport] OneKey BLE device discovered', {
-            deviceId: device.id,
-            name: displayName,
-            serviceUUIDs: device.serviceUUIDs,
-            protocolHint,
-          });
+          deviceList.push({ ...device, commType: 'ble' } as IOneKeyDevice);
         }
       };
 
@@ -633,40 +432,25 @@ export default class ReactNativeBleTransport {
   }
 
   async acquire(input: BleAcquireInput) {
-    const { uuid, forceCleanRunPromise, expectedProtocol } = input;
+    const { uuid, forceCleanRunPromise } = input;
 
     if (!uuid) {
       throw ERRORS.TypedError(HardwareErrorCode.BleRequiredUUID);
     }
 
-    const cachedTransport = transportCache[uuid];
-    if (cachedTransport) {
-      const cachedProtocol = this.deviceProtocol.get(uuid);
-      const isCachedDeviceConnected = await cachedTransport.device.isConnected().catch(() => false);
-      if (
-        isCachedDeviceConnected &&
-        cachedProtocol &&
-        (!expectedProtocol || cachedProtocol === expectedProtocol)
-      ) {
-        Log?.debug('[ReactNativeBleTransport] reuse cached BLE transport:', uuid, cachedProtocol);
-        return { uuid, protocolType: cachedProtocol };
-      }
+    let device: Device | null = null;
 
+    if (transportCache[uuid]) {
       /**
-       * If the transport is not reusable due to a protocol mismatch or stale
-       * connection, clean it up before creating a new transport instance.
+       * If the transport is not released due to an exception operation
+       * it will be handled again here
        */
-      Log?.debug('transport not reusable, will release: ', uuid);
-      await this.release(uuid, true);
+      Log?.debug('transport not be released, will release: ', uuid);
+      await this.release(uuid);
     }
 
-    let device: Device | null = null;
-
     if (forceCleanRunPromise && this.runPromise) {
-      const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
-      this.runPromise.reject(error);
-      this.rejectAllProtocolV2Frames(error);
-      this.runPromise = null;
+      this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise));
       Log?.debug('Force clean Bluetooth run promise, forceCleanRunPromise: ', forceCleanRunPromise);
     }
 
@@ -678,12 +462,11 @@ export default class ReactNativeBleTransport {
       throw error;
     }
 
+    // check device is bonded
     if (Platform.OS === 'android') {
       const bondState = await pairDevice(uuid);
       if (bondState.bonding) {
         await onDeviceBondState(uuid);
-      } else if (!bondState.bonded) {
-        throw ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
       }
     }
 
@@ -709,6 +492,7 @@ export default class ReactNativeBleTransport {
           e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
           e.errorCode === BleErrorCode.OperationCancelled
         ) {
+          connectOptions = {};
           Log?.debug('first try to reconnect without params');
           device = await blePlxManager.connectToDevice(uuid);
         } else if (e.errorCode === BleErrorCode.DeviceAlreadyConnected) {
@@ -728,16 +512,17 @@ export default class ReactNativeBleTransport {
       Log?.debug('not connected, try to connect to device: ', uuid);
 
       try {
-        device = await device.connect(connectOptions);
+        await device.connect(connectOptions);
       } catch (e) {
         Log?.debug('not connected, try to connect to device has error: ', e);
         if (
           e.errorCode === BleErrorCode.DeviceMTUChangeFailed ||
           e.errorCode === BleErrorCode.OperationCancelled
         ) {
+          connectOptions = {};
           Log?.debug('second try to reconnect without params');
           try {
-            device = await device.connect();
+            await device.connect();
           } catch (e) {
             Log?.debug('last try to reconnect error: ', e);
             // last try to reconnect device if this issue exists
@@ -745,7 +530,7 @@ export default class ReactNativeBleTransport {
             if (e.errorCode === BleErrorCode.OperationCancelled) {
               Log?.debug('last try to reconnect');
               await device.cancelConnection();
-              device = await device.connect();
+              await device.connect();
             }
           }
         } else {
@@ -754,50 +539,18 @@ export default class ReactNativeBleTransport {
       }
     }
 
-    device = await requestAndroidMtu(device);
     const { writeCharacteristic, notifyCharacteristic } = await this.resolveCharacteristics(device);
 
-    const protocolHint = expectedProtocol
-      ? undefined
-      : this.deviceProtocolHints.get(uuid) ??
-        inferProtocolHintFromDeviceName(getDeviceDisplayName(device));
-
     // release transport before new transport instance
-    await this.release(uuid, true);
-    if (protocolHint) {
-      this.deviceProtocolHints.set(uuid, protocolHint);
-    }
+    await this.release(uuid);
 
     const transport = new BleTransport(device, writeCharacteristic, notifyCharacteristic);
-    if (Platform.OS === 'android') {
-      transport.mtuSize = typeof device.mtu === 'number' ? device.mtu : transport.mtuSize;
-    }
-    const monitorToken = this.nextMonitorToken;
-    this.nextMonitorToken += 1;
-    const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
-    transport.monitorToken = monitorToken;
-    transport.notifyTransactionId = notifyTransactionId;
-    this.monitorTokens.set(uuid, monitorToken);
     transport.notifySubscription = this._monitorCharacteristic(
       transport.notifyCharacteristic,
-      uuid,
-      monitorToken,
-      notifyTransactionId
+      uuid
     );
     transportCache[uuid] = transport;
 
-    this.protocolV2Assemblers.set(uuid, new ProtocolV2FrameAssembler());
-
-    if (Platform.OS === 'ios') {
-      await new Promise<void>(resolve => {
-        setTimeout(resolve, IOS_NOTIFY_READY_DELAY_MS);
-      });
-    } else if (Platform.OS === 'android') {
-      await delay(ANDROID_NOTIFY_READY_DELAY_MS);
-    }
-
-    const protocolType = await this.detectProtocol(uuid, expectedProtocol, protocolHint);
-
     this.emitter?.emit('device-connect', {
       name: device.name,
       id: device.id,
@@ -806,19 +559,13 @@ export default class ReactNativeBleTransport {
 
     this.attachDisconnectSubscription(transport, device, uuid);
 
-    return { uuid, protocolType };
+    return { uuid };
   }
 
-  _monitorCharacteristic(
-    characteristic: Characteristic,
-    uuid: string,
-    monitorToken: number,
-    notifyTransactionId: string
-  ): Subscription {
+  _monitorCharacteristic(characteristic: Characteristic, uuid: string): Subscription {
     let bufferLength = 0;
     let buffer: any[] = [];
     const subscription = characteristic.monitor((error, c) => {
-      const isCurrentMonitor = this.monitorTokens.get(uuid) === monitorToken;
       if (error) {
         Log?.debug(
           `error monitor ${characteristic.uuid}, deviceId: ${characteristic.deviceID}: ${
@@ -829,33 +576,6 @@ export default class ReactNativeBleTransport {
           Log?.debug('notify error ignored during FirmwareUpload write recovery: ', uuid);
           return;
         }
-        if (!isCurrentMonitor) {
-          Log?.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
-          return;
-        }
-        if (this.deviceProtocol.get(uuid) === 'V2') {
-          let errorCode:
-            | typeof HardwareErrorCode.BleDeviceBondError
-            | typeof HardwareErrorCode.BleCharacteristicNotifyError
-            | typeof HardwareErrorCode.BleCharacteristicNotifyChangeFailure
-            | typeof HardwareErrorCode.BleTimeoutError =
-            HardwareErrorCode.BleCharacteristicNotifyError;
-          if (error.reason?.includes('The connection has timed out unexpectedly')) {
-            errorCode = HardwareErrorCode.BleTimeoutError;
-          } else if (error.reason?.includes('Encryption is insufficient')) {
-            errorCode = HardwareErrorCode.BleDeviceBondError;
-          } 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') ||
-            error.reason?.includes('notify change failed for device')
-          ) {
-            errorCode = HardwareErrorCode.BleCharacteristicNotifyChangeFailure;
-          }
-          this.rejectProtocolV2Frames(uuid, ERRORS.TypedError(errorCode));
-          return;
-        }
         if (this.runPromise) {
           let ERROR:
             | typeof HardwareErrorCode.BleDeviceBondError
@@ -875,45 +595,27 @@ export default class ReactNativeBleTransport {
             error.reason?.includes('Writing is not permitted') || // pro firmware 2.3.4 upgrade
             error.reason?.includes('notify change failed for device')
           ) {
-            const notifyError = ERRORS.TypedError(
-              HardwareErrorCode.BleCharacteristicNotifyChangeFailure
+            this.runPromise.reject(
+              ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotifyChangeFailure)
             );
-            this.runPromise.reject(notifyError);
-            this.rejectAllProtocolV2Frames(notifyError);
             Log?.debug(
               `${HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`
             );
             return;
           }
-          const notifyError = ERRORS.TypedError(ERROR);
-          this.runPromise.reject(notifyError);
-          this.rejectAllProtocolV2Frames(notifyError);
+          this.runPromise.reject(ERRORS.TypedError(ERROR));
           Log?.debug(': monitor notify error, and has unreleased Promise', Error);
         }
 
         return;
       }
 
-      if (!isCurrentMonitor) {
-        Log?.debug('monitor data ignored for stale transport: ', uuid, notifyTransactionId);
-        return;
-      }
-
       if (!c) {
         throw ERRORS.TypedError(HardwareErrorCode.BleMonitorError);
       }
 
       try {
         const data = Buffer.from(c.value as string, 'base64');
-        const protocol = this.deviceProtocol.get(uuid);
-        if (!protocol) {
-          Log?.debug('monitor data ignored before protocol detection: ', uuid);
-          return;
-        }
-        if (protocol === 'V2') {
-          this.handleProtocolV2Notification(uuid, monitorToken, new Uint8Array(data));
-          return;
-        }
         // console.log('[hd-transport-react-native] Received a packet, ', 'buffer: ', data);
         if (isHeaderChunk(data)) {
           bufferLength = data.readInt32BE(5);
@@ -922,7 +624,7 @@ export default class ReactNativeBleTransport {
           buffer = buffer.concat([...data]);
         }
 
-        if (buffer.length - PROTOCOL_V1_MESSAGE_HEADER_SIZE >= bufferLength) {
+        if (buffer.length - COMMON_HEADER_SIZE >= bufferLength) {
           const value = Buffer.from(buffer);
           // console.log(
           //   '[hd-transport-react-native] Received a complete packet of data, resolve Promise, this.runPromise: ',
@@ -936,41 +638,17 @@ export default class ReactNativeBleTransport {
         }
       } catch (error) {
         Log?.debug('monitor data error: ', error);
-        const notifyError = ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
-        if (this.deviceProtocol.get(uuid) === 'V2') {
-          this.rejectProtocolV2Frames(uuid, notifyError);
-        } else {
-          this.runPromise?.reject(notifyError);
-        }
+        this.runPromise?.reject(ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError));
       }
-    }, notifyTransactionId);
+    }, uuid);
 
     return subscription;
   }
 
-  async release(uuid: string, onclose = false) {
+  async release(uuid: string) {
     const transport = transportCache[uuid];
-    await this.protocolV2Links.invalidateLink(uuid, 'React Native BLE transport released');
-    if (this.runPromise) {
-      const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
-      this.runPromise.reject(error);
-      this.runPromise = null;
-      this.rejectAllProtocolV2Frames(error);
-    } else {
-      this.resetProtocolV2Frames(uuid);
-    }
-
-    if (Platform.OS === 'android' && !onclose && transport) {
-      this.protocolV2Assemblers.get(uuid)?.reset();
-      this.resetProtocolV2Frames(uuid);
-      return Promise.resolve(true);
-    }
 
     if (transport) {
-      if (this.monitorTokens.get(uuid) === transport.monitorToken) {
-        this.monitorTokens.delete(uuid);
-      }
-
       // Clean up disconnect subscription first to prevent callbacks on released transport
       Log?.debug('release: removing disconnect subscription for device: ', uuid);
       transport.disconnectSubscription?.remove();
@@ -984,27 +662,12 @@ export default class ReactNativeBleTransport {
       transport.notifySubscription?.remove();
       transport.notifySubscription = undefined;
 
-      if (transport.notifyTransactionId) {
-        try {
-          await this.blePlxManager?.cancelTransaction(transport.notifyTransactionId);
-        } catch (e) {
-          Log?.debug('release: cancel notify transaction error (ignored): ', e?.message || e);
-        }
-      }
-
       delete transportCache[uuid];
-    }
 
-    this.deviceProtocol.delete(uuid);
-    // Preserve a name-derived hint across disconnects so reconnect can probe V2 first.
-    this.protocolV2Assemblers.get(uuid)?.reset();
-    this.protocolV2Assemblers.delete(uuid);
-    this.resetProtocolV2Frames(uuid);
-
-    try {
-      await this.blePlxManager?.cancelTransaction(uuid);
-    } catch (e) {
-      Log?.debug('release: cancel transaction error (ignored): ', e?.message || e);
+      // Temporary close the Android disconnect after each request
+      if (Platform.OS === 'android') {
+        // await this.blePlxManager?.cancelDeviceConnection(uuid);
+      }
     }
 
     return Promise.resolve(true);
@@ -1014,12 +677,7 @@ export default class ReactNativeBleTransport {
     await this.call(session, name, data);
   }
 
-  async call(
-    uuid: string,
-    name: string,
-    data: Record<string, unknown>,
-    options?: TransportCallOptions
-  ) {
+  async call(uuid: string, name: string, data: Record<string, unknown>) {
     if (this.stopped) {
       // eslint-disable-next-line prefer-promise-reject-errors
       return Promise.reject(ERRORS.TypedError('Transport stopped.'));
@@ -1028,44 +686,33 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    const protocol = this.getProtocolType(uuid);
-    if (!protocol) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.RuntimeError,
-        `Device protocol has not been detected for ${uuid}`
-      );
-    }
-    Log?.debug('transport call', createTransportCallLog(name, protocol, data));
-
-    if (protocol === 'V2') {
-      return this.callProtocolV2(uuid, name, data, options);
-    }
-
     const forceRun = name === 'Initialize' || name === 'Cancel';
+
+    Log?.debug('transport-react-native call this.runPromise', this.runPromise);
     if (this.runPromise && !forceRun) {
       throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
     }
 
-    return this.callProtocolV1(uuid, name, data, options);
-  }
-
-  private async callProtocolV1(
-    uuid: string,
-    name: string,
-    data: Record<string, unknown>,
-    options?: TransportCallOptions
-  ) {
-    if (!this._messages) {
-      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    const transport = transportCache[uuid];
+    if (!transport) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
     }
 
-    const transport = this.getCachedTransport(uuid);
-    const runPromise = createDeferred<string>();
-    runPromise.promise.catch(() => undefined);
-    this.runPromise = runPromise;
+    this.runPromise = createDeferred();
     const messages = this._messages;
-    const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
-    let timeout: ReturnType<typeof setTimeout> | undefined;
+    // Upload resources on low-end phones may OOM
+    if (name === 'ResourceUpdate' || name === 'ResourceAck') {
+      Log?.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', {
+        file_name: data?.file_name,
+        hash: data?.hash,
+      });
+    } else if (LogBlockCommand.has(name)) {
+      Log?.debug('transport-react-native', 'call-', ' name: ', name);
+    } else {
+      Log?.debug('transport-react-native', 'call-', ' name: ', name, ' data: ', data);
+    }
+
+    const buffers = buildBuffers(messages, name, data);
 
     async function writeChunkedData(
       buffers: ByteBuffer[],
@@ -1139,13 +786,14 @@ export default class ReactNativeBleTransport {
         }
       );
     } else if (name === 'FirmwareUpload') {
-      Log?.debug('[ReactNativeBleTransport] Firmware upload transport configured', {
+      Log?.debug('[ReactNativeBleTransport] FirmwareUpload write uses throttled BLE packets:', {
         packetCapacity: FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY,
         burstSize: FIRMWARE_UPLOAD_WRITE_BURST_SIZE,
         pauseMs: FIRMWARE_UPLOAD_WRITE_PAUSE_MS,
         flushDelayMs: FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS,
         maxRetries: FIRMWARE_UPLOAD_WRITE_MAX_RETRIES,
       });
+
       await writeFirmwareUploadChunkedData(
         buffers,
         async data => {
@@ -1199,6 +847,7 @@ export default class ReactNativeBleTransport {
       for (const o of buffers) {
         const outData = o.toString('base64');
         // Upload resources on low-end phones may OOM
+        // this.Log.debug('send hex strting: ', o.toString('hex'));
         try {
           await transport.writeCharacteristic.writeWithoutResponse(outData);
         } catch (e) {
@@ -1216,40 +865,20 @@ export default class ReactNativeBleTransport {
     }
 
     try {
-      const response = await Promise.race([
-        runPromise.promise,
-        new Promise<never>((_, reject) => {
-          if (options?.timeoutMs) {
-            timeout = setTimeout(() => {
-              const error = ERRORS.TypedError(
-                HardwareErrorCode.BleTimeoutError,
-                `BLE response timeout after ${options.timeoutMs}ms for ${name}`
-              );
-              runPromise.reject(error);
-              reject(error);
-            }, options.timeoutMs);
-          }
-        }),
-      ]);
+      const response = await this.runPromise.promise;
 
       if (typeof response !== 'string') {
         throw new Error('Returning data is not string.');
       }
 
-      const jsonData = ProtocolV1.decodeMessage(messages, response);
+      Log?.debug('receive data: ', response);
+      const jsonData = receiveOne(messages, response);
       return check.call(jsonData);
     } catch (e) {
-      if (name === 'Initialize' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS) {
-        Log?.debug('[ReactNativeBleTransport] Protocol V1 Initialize probe call failed:', e);
-      } else {
-        Log?.error('call error: ', e);
-      }
+      Log?.error('call error: ', e);
       throw e;
     } finally {
-      if (timeout) clearTimeout(timeout);
-      if (this.runPromise === runPromise) {
-        this.runPromise = null;
-      }
+      this.runPromise = null;
     }
   }
 
@@ -1258,7 +887,7 @@ export default class ReactNativeBleTransport {
   }
 
   async disconnect(session: string) {
-    await this.protocolV2Links.invalidateLink(session, 'React Native BLE transport disconnected');
+    Log?.debug('transport-react-native transport resetSession: ', session);
     const transport = transportCache[session];
 
     // Clean up disconnect subscription first to prevent onDisconnected callback
@@ -1316,10 +945,6 @@ export default class ReactNativeBleTransport {
     if (transportCache[session]) {
       delete transportCache[session];
     }
-    this.deviceProtocol.delete(session);
-    this.deviceProtocolHints.delete(session);
-    this.protocolV2Assemblers.delete(session);
-    this.resetProtocolV2Frames(session);
 
     // emit the disconnect event
     try {
@@ -1342,374 +967,4 @@ export default class ReactNativeBleTransport {
     }
     this.runPromise = null;
   }
-
-  private getCachedTransport(uuid: string) {
-    const transport = transportCache[uuid];
-    if (!transport) {
-      throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
-    }
-    return transport;
-  }
-
-  private createProtocolMismatchError(expected: ProtocolType) {
-    return ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`
-    );
-  }
-
-  private createProtocolDetectionError() {
-    return ERRORS.TypedError(
-      HardwareErrorCode.BleTimeoutError,
-      'Unable to detect BLE protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping'
-    );
-  }
-
-  private clearProbeProtocol(uuid: string, protocol: ProtocolType) {
-    if (this.deviceProtocol.get(uuid) === protocol) {
-      this.deviceProtocol.delete(uuid);
-    }
-  }
-
-  private async detectProtocol(
-    uuid: string,
-    expectedProtocol?: ProtocolType,
-    protocolHint?: ProtocolType
-  ): Promise<ProtocolType> {
-    if (expectedProtocol === 'V1') {
-      if (await this.probeProtocolV1(uuid)) {
-        this.deviceProtocol.set(uuid, 'V1');
-        Log?.debug('[ReactNativeBleTransport] protocol detected', {
-          deviceId: uuid,
-          protocol: 'V1',
-          source: 'expected',
-        });
-        return 'V1';
-      }
-      throw this.createProtocolMismatchError(expectedProtocol);
-    }
-
-    if (expectedProtocol === 'V2') {
-      // Skip probing when the caller explicitly confirms V2, such as reconnect after a
-      // firmware reboot where expectedProtocol carries the previously probed result.
-      this.deviceProtocol.set(uuid, 'V2');
-      Log?.debug('[ReactNativeBleTransport] protocol detected', {
-        deviceId: uuid,
-        protocol: 'V2',
-        source: 'expected',
-      });
-      return 'V2';
-    }
-
-    // Protocol must be actively probed after connection. Name, PID, and descriptors only
-    // influence probe order; a V2 hint probes V2 first and falls back to V1.
-    const probeOrder: ProtocolType[] =
-      protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
-
-    for (let i = 0; i < probeOrder.length; i += 1) {
-      const protocol = probeOrder[i];
-      if (i > 0) {
-        // Reset subscriptions and buffers after a failed probe before trying another protocol.
-        await this.resetProbeStateAfterProtocolProbe(uuid, probeOrder[i - 1]);
-      }
-      const detected =
-        protocol === 'V1' ? await this.probeProtocolV1(uuid) : await this.probeProtocolV2(uuid);
-      if (detected) {
-        this.deviceProtocol.set(uuid, protocol);
-        Log?.debug('[ReactNativeBleTransport] protocol detected', {
-          deviceId: uuid,
-          protocol,
-          source: 'probe',
-        });
-        return protocol;
-      }
-    }
-
-    this.deviceProtocol.delete(uuid);
-    throw this.createProtocolDetectionError();
-  }
-
-  private async resetProbeStateAfterProtocolProbe(uuid: string, protocol: ProtocolType) {
-    const transport = transportCache[uuid];
-    await this.protocolV2Links.invalidateLink(
-      uuid,
-      `Reset notify state after Protocol ${protocol} probe`
-    );
-    this.protocolV2Assemblers.get(uuid)?.reset();
-    this.resetProtocolV2Frames(uuid);
-    if (this.runPromise) {
-      const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
-      this.runPromise.reject(error);
-      this.runPromise = null;
-    }
-
-    if (!transport) return;
-
-    const previousNotifyTransactionId = transport.notifyTransactionId;
-    if (this.monitorTokens.get(uuid) === transport.monitorToken) {
-      this.monitorTokens.delete(uuid);
-    }
-    transport.notifySubscription?.remove();
-    transport.notifySubscription = undefined;
-    if (previousNotifyTransactionId) {
-      try {
-        await this.blePlxManager?.cancelTransaction(previousNotifyTransactionId);
-      } catch (error) {
-        Log?.debug(
-          `[ReactNativeBleTransport] cancel notify after Protocol ${protocol} probe failed:`,
-          error?.message || error
-        );
-      }
-    }
-
-    const monitorToken = this.nextMonitorToken;
-    this.nextMonitorToken += 1;
-    const notifyTransactionId = `${uuid}:notify:${monitorToken}`;
-    transport.monitorToken = monitorToken;
-    transport.notifyTransactionId = notifyTransactionId;
-    this.monitorTokens.set(uuid, monitorToken);
-    transport.notifySubscription = this._monitorCharacteristic(
-      transport.notifyCharacteristic,
-      uuid,
-      monitorToken,
-      notifyTransactionId
-    );
-    if (Platform.OS === 'ios') {
-      await new Promise<void>(resolve => {
-        setTimeout(resolve, IOS_NOTIFY_READY_DELAY_MS);
-      });
-    }
-  }
-
-  private async probeProtocolV1(uuid: string) {
-    if (!this._messages) {
-      return false;
-    }
-
-    try {
-      this.deviceProtocol.set(uuid, 'V1');
-      await this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
-      return true;
-    } catch (error) {
-      this.clearProbeProtocol(uuid, 'V1');
-      Log?.debug('[ReactNativeBleTransport] Protocol V1 Initialize probe failed:', error);
-      return false;
-    }
-  }
-
-  private async probeProtocolV2(uuid: string) {
-    if (!this._messages || !this._messagesV2) {
-      return false;
-    }
-
-    this.deviceProtocol.set(uuid, 'V2');
-    this.protocolV2Assemblers.get(uuid)?.reset();
-    const detected = await probeProtocolV2Helper({
-      call: (name: string, data: Record<string, unknown>, options?: TransportCallOptions) =>
-        this.callProtocolV2(uuid, name, data, options),
-      timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
-      logger: Log,
-      logPrefix: 'ProtocolV2 RN-BLE',
-      onProbeFailed: () => {
-        this.protocolV2Assemblers.get(uuid)?.reset();
-        this.resetProtocolV2Frames(uuid);
-      },
-    });
-    if (!detected) {
-      this.clearProbeProtocol(uuid, 'V2');
-    }
-    return detected;
-  }
-
-  private handleProtocolV2Notification(uuid: string, monitorToken: number, data: Uint8Array) {
-    try {
-      if (this.monitorTokens.get(uuid) !== monitorToken) return;
-
-      if (data.length === 0) return;
-
-      const assembler = this.protocolV2Assemblers.get(uuid);
-      if (!assembler) return;
-
-      for (const frameData of assembler.drain(data)) {
-        this.resolveProtocolV2Frame(uuid, frameData);
-      }
-    } catch (error) {
-      Log?.debug('[ReactNativeBleTransport] Protocol V2 notification error:', error);
-      const notifyError = ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
-      this.rejectProtocolV2Frames(uuid, notifyError);
-      this.protocolV2Links
-        .invalidateLink(uuid, `Protocol V2 notification error: ${error}`)
-        .catch(invalidateError =>
-          Log?.debug(
-            '[ReactNativeBleTransport] Protocol V2 notify cleanup failed:',
-            invalidateError
-          )
-        );
-    }
-  }
-
-  private getProtocolV2FrameQueue(uuid: string) {
-    let queue = this.protocolV2FrameQueues.get(uuid);
-    if (!queue) {
-      queue = [];
-      this.protocolV2FrameQueues.set(uuid, queue);
-    }
-    return queue;
-  }
-
-  private resolveProtocolV2Frame(uuid: string, frame: Uint8Array) {
-    const framePromise = this.protocolV2FramePromises.get(uuid);
-    if (framePromise) {
-      framePromise.resolve(frame);
-      this.protocolV2FramePromises.delete(uuid);
-      return;
-    }
-    this.getProtocolV2FrameQueue(uuid).push(frame);
-  }
-
-  private rejectAllProtocolV2Frames(error: Error) {
-    this.protocolV2FrameQueues.clear();
-    for (const framePromise of this.protocolV2FramePromises.values()) {
-      framePromise.reject(error);
-    }
-    this.protocolV2FramePromises.clear();
-  }
-
-  private resetProtocolV2Frames(uuid: string) {
-    this.protocolV2FrameQueues.delete(uuid);
-    this.protocolV2FramePromises.delete(uuid);
-  }
-
-  private rejectProtocolV2Frames(uuid: string, error: Error) {
-    this.protocolV2FrameQueues.delete(uuid);
-    const framePromise = this.protocolV2FramePromises.get(uuid);
-    if (framePromise) {
-      this.protocolV2FramePromises.delete(uuid);
-      framePromise.reject(error);
-    }
-  }
-
-  private async readProtocolV2Frame(uuid: string) {
-    const queuedFrame = this.getProtocolV2FrameQueue(uuid).shift();
-    if (queuedFrame) {
-      return queuedFrame;
-    }
-
-    const framePromise = createDeferred<Uint8Array>();
-    this.protocolV2FramePromises.set(uuid, framePromise);
-    try {
-      return await framePromise.promise;
-    } finally {
-      if (this.protocolV2FramePromises.get(uuid) === framePromise) {
-        this.protocolV2FramePromises.delete(uuid);
-      }
-    }
-  }
-
-  private async writeProtocolV2Frame(transport: BleTransport, frame: Uint8Array) {
-    const tuning = getProtocolV2BleTuning();
-    const packetCapacity = resolveProtocolV2PacketCapacity({
-      platform: Platform.OS,
-      iosPacketLength: tuning.iosPacketLength,
-      androidPacketLength: tuning.androidPacketLength,
-      mtu: Platform.OS === 'android' ? transport.mtuSize : undefined,
-    });
-    for (let offset = 0; offset < frame.length; offset += packetCapacity) {
-      const chunk = frame.slice(offset, offset + packetCapacity);
-      const base64 = Buffer.from(chunk).toString('base64');
-      await transport.writeCharacteristic.writeWithoutResponse(base64);
-    }
-  }
-
-  private async callProtocolV2(
-    uuid: string,
-    name: string,
-    data: Record<string, unknown>,
-    options?: TransportCallOptions
-  ) {
-    if (!this._messages || !this._messagesV2) {
-      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
-    }
-
-    const callOptions = {
-      ...options,
-      // Align with V1 BLE and the USB V2 base transport: only arm a watchdog when the caller
-      // explicitly passes timeoutMs. Interactive acks (ButtonAck/PinMatrixAck/PassphraseAck)
-      // have their timeoutMs removed by DeviceCommands.stripInteractiveAckTimeout, so we must
-      // not fill in a 30s default here — that would hard-cap the time a user spends confirming
-      // a transaction or entering a PIN/passphrase on the device and tear down the BLE link.
-      timeoutMs: options?.timeoutMs,
-    };
-    const highVolumeWrite = LogBlockCommand.has(name);
-
-    if (highVolumeWrite) {
-      const tuning = getProtocolV2BleTuning();
-      Log?.debug('[ReactNativeBleTransport] Protocol V2 high-volume write configured', {
-        name,
-        writeMode: 'withoutResponse',
-        packetCapacity: Platform.OS === 'ios' ? tuning.iosPacketLength : tuning.androidPacketLength,
-      });
-    }
-
-    try {
-      return await this.protocolV2Links.call(
-        uuid,
-        () => this.createProtocolV2Adapter(uuid),
-        name,
-        data,
-        callOptions
-      );
-    } catch (e) {
-      Log?.error('[ReactNativeBleTransport] Protocol V2 call error:', e);
-      throw e;
-    }
-  }
-
-  private createProtocolV2Adapter(uuid: string) {
-    const generation = this.monitorTokens.get(uuid) ?? 0;
-    const assertCurrentGeneration = () => {
-      if (this.monitorTokens.get(uuid) !== generation) {
-        throw new Error(`Protocol V2 monitor generation changed for ${uuid}`);
-      }
-    };
-
-    return {
-      router: PROTOCOL_V2_CHANNEL_BLE_UART,
-      maxFrameBytes: PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
-      generation,
-      prepareCall: () => {
-        assertCurrentGeneration();
-        this.protocolV2Assemblers.get(uuid)?.reset();
-        this.resetProtocolV2Frames(uuid);
-      },
-      writeFrame: async (frame: Uint8Array) => {
-        assertCurrentGeneration();
-        const currentTransport = this.getCachedTransport(uuid);
-        await this.writeProtocolV2Frame(currentTransport, frame);
-      },
-      readFrame: async () => {
-        assertCurrentGeneration();
-        const rxFrame = await this.readProtocolV2Frame(uuid);
-        if (!(rxFrame instanceof Uint8Array)) {
-          throw new Error('Protocol V2 response is not Uint8Array');
-        }
-        return rxFrame;
-      },
-      reset: (reason: string) => {
-        this.protocolV2Assemblers.get(uuid)?.reset();
-        this.rejectProtocolV2Frames(uuid, new Error(reason));
-      },
-      logger: Log,
-      logPrefix: 'ProtocolV2 RN-BLE',
-      createTimeoutError: (messageName: string, timeout: number) =>
-        ERRORS.TypedError(
-          HardwareErrorCode.BleTimeoutError,
-          `BLE response timeout after ${timeout}ms for ${messageName}`
-        ),
-    };
-  }
-
-  getProtocolType(path: string): ProtocolType | undefined {
-    return this.deviceProtocol.get(path);
-  }
 }