@onekeyfe/hd-transport-web-device 1.2.0-alpha.7 → 1.2.0-alpha.71

package/src/electron-ble-transport.ts

@@ -1,12 +1,14 @@
 import transport, {
-  LogBlockCommand,
   PROTOCOL_V1_MESSAGE_HEADER_SIZE,
+  PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
   PROTOCOL_V2_CHANNEL_BLE_UART,
   ProtocolV2FrameAssembler,
-  ProtocolV2Session,
+  ProtocolV2LinkManager,
+  TRANSPORT_EVENT,
   bytesToHex,
   hexToBytes,
   probeProtocolV2 as probeProtocolV2Helper,
+  writeProtocolV2BleFrame,
 } from '@onekeyfe/hd-transport';
 import {
   ERRORS,
@@ -14,25 +16,21 @@ import {
   HardwareErrorCodeMessage,
   createDeferred,
   isHeaderChunk,
-  wait,
 } from '@onekeyfe/hd-shared';
 
+import { createTransportCallLog, shouldSuppressHighVolumeCallLog } from './transportLog';
+import { resolveBlePacketCapacity } from './ble-packet-capacity';
+
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { DesktopAPI } from '@onekeyfe/hd-transport-electron';
-import type { OneKeyDeviceInfo, ProtocolType, TransportCallOptions } from '@onekeyfe/hd-transport';
+import type {
+  OneKeyDeviceInfo,
+  ProtocolType,
+  ProtocolV2CallContext,
+  TransportCallOptions,
+} from '@onekeyfe/hd-transport';
 import type EventEmitter from 'events';
 
-const FILE_WRITE_LOG_BLOCK_PATTERN = /(?:^|[^a-z])(?:raw)?(?:filesystem|emmc)?filewrite$/i;
-
-function shouldSuppressHighVolumeCallLog(name: string) {
-  const normalized = name.replace(/[_\s-]/g, '');
-  return FILE_WRITE_LOG_BLOCK_PATTERN.test(normalized);
-}
-
-function isLogBlockCommand(name: string) {
-  return (LogBlockCommand as Set<string> | undefined)?.has?.(name) ?? false;
-}
-
 const { parseConfigure, ProtocolV1, check } = transport;
 
 declare global {
@@ -45,6 +43,7 @@ export type BleAcquireInput = {
   uuid: string;
   forceCleanRunPromise?: boolean;
   expectedProtocol?: ProtocolType;
+  protocolHint?: ProtocolType;
 };
 
 interface PacketProcessResult {
@@ -70,9 +69,9 @@ const toBleDescriptor = (
     ...(protocolType ? { protocolType } : {}),
   } as OneKeyDeviceInfo);
 
-const BLE_PACKET_SIZE = 192;
+const BLE_PACKET_SIZE_FALLBACK = 192;
+const BLE_PACKET_SIZE_MAXIMUM = 244;
 const BLE_WRITE_DELAY_MS = 5;
-const BLE_RESPONSE_TIMEOUT_MS = 30_000;
 const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
 const PROTOCOL_V2_PROBE_TIMEOUT_MS = 5000;
 
@@ -80,19 +79,23 @@ const PROTOCOL_V2_PROBE_TIMEOUT_MS = 5000;
  * Desktop Electron BLE transport with automatic Protocol V1/V2 detection.
  *
  * Protocol V1 devices continue using chunked packets. Protocol V2 is detected
- * after a Protocol V1 Initialize timeout by probing Protocol V2 Ping.
+ * after a Protocol V1 GetFeatures timeout by probing Protocol V2 Ping.
  */
 export default class ElectronBleTransport {
   private _messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
   private _messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
 
+  private protocolV2SchemaConfiguration: string | undefined;
+
   name = 'ElectronBleTransport';
 
   configured = false;
 
   runPromise: Deferred<Uint8Array | string> | null = null;
 
+  private runPromiseDeviceId: string | null = null;
+
   Log?: any;
 
   emitter?: EventEmitter;
@@ -103,6 +106,10 @@ export default class ElectronBleTransport {
 
   private deviceProtocolHints: Map<string, ProtocolType> = new Map();
 
+  private deviceMtus: Map<string, number> = new Map();
+
+  private devicePacketCapacities: Map<string, number> = new Map();
+
   private v1Buffers: Map<string, { buffer: number[]; bufferLength: number }> = new Map();
 
   private v2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
@@ -111,12 +118,31 @@ export default class ElectronBleTransport {
 
   private v2FramePromises: Map<string, Deferred<Uint8Array>> = new Map();
 
-  private activeProtocolV2Call: { uuid: string; token: number } | null = null;
-
-  private nextProtocolV2CallToken = 1;
+  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.v2Assemblers.get(uuid)?.reset();
+      this.rejectProtocolV2Frames(uuid, new Error(reason));
+      this.Log?.debug('[Electron BLE] Protocol V2 link invalidated:', uuid, reason);
+      if (reason.startsWith('Protocol V2 link-fatal error:')) {
+        await this.releaseNative(uuid);
+      }
+    },
+  });
 
   private notificationCleanups: Map<string, () => void> = new Map();
 
+  private mtuCleanups: Map<string, () => void> = new Map();
+
   private disconnectCleanups: Map<string, () => void> = new Map();
 
   private notificationTokens: Map<string, number> = new Map();
@@ -155,17 +181,24 @@ export default class ElectronBleTransport {
   }
 
   private cleanupDeviceState(deviceId: string): void {
+    this.protocolV2Links
+      .invalidateLink(deviceId, 'Electron BLE device state cleaned')
+      .catch(error => this.Log?.debug('[Electron BLE] link cleanup failed:', error));
     this.connectedDevices.delete(deviceId);
     this.deviceProtocol.delete(deviceId);
+    this.deviceMtus.delete(deviceId);
+    this.devicePacketCapacities.delete(deviceId);
     // Keep deviceProtocolHints — it's inferred from device name (e.g. "Pro 2" → V2)
     // and doesn't depend on connection state. Preserving it avoids redundant V1 probe on reconnect.
     this.v1Buffers.delete(deviceId);
     this.v2Assemblers.delete(deviceId);
     this.resetProtocolV2Frames(deviceId);
-    if (this.activeProtocolV2Call?.uuid === deviceId) {
-      this.activeProtocolV2Call = null;
-    }
     this.notificationTokens.delete(deviceId);
+    if (this.runPromise && this.runPromiseDeviceId === deviceId) {
+      this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected));
+      this.runPromise = null;
+      this.runPromiseDeviceId = null;
+    }
 
     const notifyCleanup = this.notificationCleanups.get(deviceId);
     if (notifyCleanup) {
@@ -173,6 +206,12 @@ export default class ElectronBleTransport {
       this.notificationCleanups.delete(deviceId);
     }
 
+    const mtuCleanup = this.mtuCleanups.get(deviceId);
+    if (mtuCleanup) {
+      mtuCleanup();
+      this.mtuCleanups.delete(deviceId);
+    }
+
     const disconnectCleanup = this.disconnectCleanups.get(deviceId);
     if (disconnectCleanup) {
       disconnectCleanup();
@@ -200,8 +239,19 @@ export default class ElectronBleTransport {
   }
 
   configureProtocolV2(signedData: any) {
+    const configuration = typeof signedData === 'string' ? signedData : JSON.stringify(signedData);
+    if (this.protocolV2SchemaConfiguration === configuration) {
+      return;
+    }
+
+    const isReconfiguration = this.protocolV2SchemaConfiguration !== undefined;
     this._messagesV2 = parseConfigure(signedData);
-    this.Log?.debug('[Electron BLE] Protocol V2 schema configured');
+    this.protocolV2SchemaConfiguration = configuration;
+    if (isReconfiguration) {
+      this.protocolV2Links
+        .invalidateAllLinks('Protocol V2 schema reconfigured')
+        .catch(error => this.Log?.debug('[Electron BLE] schema link cleanup failed:', error));
+    }
   }
 
   async listen() {
@@ -236,12 +286,15 @@ export default class ElectronBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.BleRequiredUUID);
     }
 
+    if (this.connectedDevices.has(uuid)) {
+      await this.release(uuid);
+    }
+
     if (forceCleanRunPromise && this.runPromise) {
       const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
       this.runPromise.reject(error);
-      this.rejectAllProtocolV2Frames(error);
       this.runPromise = null;
-      this.activeProtocolV2Call = null;
+      this.runPromiseDeviceId = null;
     }
 
     try {
@@ -255,7 +308,9 @@ export default class ElectronBleTransport {
       }
       const protocolHint = expectedProtocol
         ? undefined
-        : this.deviceProtocolHints.get(uuid) ?? inferProtocolHintFromDeviceName(device.name);
+        : input.protocolHint ??
+          this.deviceProtocolHints.get(uuid) ??
+          inferProtocolHintFromDeviceName(device.name);
       if (protocolHint) {
         this.deviceProtocolHints.set(uuid, protocolHint);
       }
@@ -267,19 +322,38 @@ export default class ElectronBleTransport {
         this.handleBluetoothError(error);
       }
 
+      const mtuCleanup = this.createMtuSubscription(uuid);
+      if (mtuCleanup) {
+        this.mtuCleanups.set(uuid, mtuCleanup);
+      }
+
       this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
-      this.v2Assemblers.set(uuid, new ProtocolV2FrameAssembler());
+      this.v2Assemblers.set(uuid, new ProtocolV2FrameAssembler(PROTOCOL_V2_BLE_FRAME_MAX_BYTES));
 
       await window.desktopApi.nobleBle.subscribe(uuid);
+      await this.refreshBlePacketCapacity(uuid);
 
       const cleanup = this.createNotificationSubscription(uuid);
       this.notificationCleanups.set(uuid, cleanup);
+      const connectionToken = this.notificationTokens.get(uuid);
+
+      const protocolType = await this.detectProtocol(uuid, expectedProtocol, protocolHint);
+      if (protocolType === 'V2') {
+        this.Log?.debug('[Electron BLE] Protocol V2 write configured', {
+          writeMode: 'withoutResponse',
+          negotiatedMtu: this.deviceMtus.get(uuid),
+          packetCapacity: this.devicePacketCapacities.get(uuid) ?? BLE_PACKET_SIZE_FALLBACK,
+        });
+      }
 
       const disconnectCleanup = window.desktopApi.nobleBle.onDeviceDisconnected(
         (disconnectedDevice: any) => {
-          if (disconnectedDevice.id === uuid) {
+          if (
+            disconnectedDevice.id === uuid &&
+            this.notificationTokens.get(uuid) === connectionToken
+          ) {
             this.cleanupDeviceState(uuid);
-            this.emitter?.emit('device-disconnect', {
+            this.emitter?.emit(TRANSPORT_EVENT.DEVICE_DISCONNECT, {
               name: disconnectedDevice.name,
               id: disconnectedDevice.id,
               connectId: disconnectedDevice.id,
@@ -289,14 +363,6 @@ export default class ElectronBleTransport {
       );
       this.disconnectCleanups.set(uuid, disconnectCleanup);
 
-      const protocolType = await this.detectProtocol(uuid, expectedProtocol, protocolHint);
-
-      this.emitter?.emit('device-connect', {
-        name: device.name,
-        id: device.id,
-        connectId: device.id,
-      });
-
       return {
         ...toBleDescriptor({ id: device.id, name: device.name }, protocolType),
         uuid,
@@ -317,6 +383,16 @@ export default class ElectronBleTransport {
   }
 
   async release(id: string) {
+    try {
+      await this.protocolV2Links.invalidateLink(id, 'Electron BLE transport released');
+      await this.releaseNative(id);
+    } catch (error) {
+      this.Log?.error('[Electron BLE] release failed:', error);
+      this.cleanupDeviceState(id);
+    }
+  }
+
+  private async releaseNative(id: string) {
     try {
       if (this.connectedDevices.has(id)) {
         if (window.desktopApi?.nobleBle) {
@@ -341,7 +417,7 @@ export default class ElectronBleTransport {
   private createProtocolDetectionError() {
     return ERRORS.TypedError(
       HardwareErrorCode.BleTimeoutError,
-      'Unable to detect BLE protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping'
+      'Unable to detect BLE protocol: device did not respond to Protocol V1 GetFeatures or Protocol V2 Ping'
     );
   }
 
@@ -366,23 +442,23 @@ export default class ElectronBleTransport {
     }
 
     if (expectedProtocol === 'V2') {
-      // 免探测路径：调用方显式承诺该设备是 V2（例如固件升级重启后的重连场景，
-      // 上层已经探测过协议并通过 expectedProtocol 传回），这里不再重复探测。
-      this.deviceProtocol.set(uuid, 'V2');
-      this.Log?.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V2 (expected)`);
-      return 'V2';
+      if (await this.probeProtocolV2(uuid)) {
+        this.deviceProtocol.set(uuid, 'V2');
+        this.Log?.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+        return 'V2';
+      }
+      throw this.createProtocolMismatchError(expectedProtocol);
     }
 
-    // 项目约束：协议判断必须在连接后主动探测，不能依赖设备名/PID/descriptor。
-    // 设备名 hint（如 "Pro 2"）只用于调整探测顺序：hint=V2 时先探 V2、失败回落 V1，
-    // 不能作为最终结论。
+    // 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 =
@@ -415,16 +491,18 @@ export default class ElectronBleTransport {
   }
 
   private async resetProbeStateAfterProtocolProbe(uuid: string, protocol: ProtocolType) {
+    await this.protocolV2Links.invalidateLink(
+      uuid,
+      `Reset notify state after Protocol ${protocol} probe`
+    );
     this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
     this.v2Assemblers.get(uuid)?.reset();
     this.resetProtocolV2Frames(uuid);
-    if (this.activeProtocolV2Call?.uuid === uuid) {
-      this.activeProtocolV2Call = null;
-    }
-    if (this.runPromise) {
+    if (this.runPromise && this.runPromiseDeviceId === uuid) {
       const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
       this.runPromise.reject(error);
       this.runPromise = null;
+      this.runPromiseDeviceId = null;
     }
 
     const notifyCleanup = this.notificationCleanups.get(uuid);
@@ -440,9 +518,18 @@ export default class ElectronBleTransport {
       this.Log?.debug(`[Electron BLE] unsubscribe after Protocol ${protocol} probe failed:`, error);
     }
     try {
+      await window.desktopApi?.nobleBle?.disconnect(uuid);
+    } catch (error) {
+      this.Log?.debug(`[Electron BLE] disconnect after Protocol ${protocol} probe failed:`, error);
+    }
+    this.connectedDevices.delete(uuid);
+    try {
+      await window.desktopApi?.nobleBle?.connect(uuid);
+      this.connectedDevices.add(uuid);
       await window.desktopApi?.nobleBle?.subscribe(uuid);
+      await this.refreshBlePacketCapacity(uuid);
     } catch (error) {
-      this.Log?.debug(`[Electron BLE] resubscribe after Protocol ${protocol} probe failed:`, error);
+      this.Log?.debug(`[Electron BLE] reconnect after Protocol ${protocol} probe failed:`, error);
       throw error;
     }
 
@@ -457,11 +544,13 @@ export default class ElectronBleTransport {
 
     try {
       this.deviceProtocol.set(uuid, 'V1');
-      await this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+      // 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 });
       return true;
     } catch (error) {
       this.clearProbeProtocol(uuid, 'V1');
-      this.Log?.debug('[Electron BLE] Protocol V1 Initialize probe failed:', error);
+      this.Log?.debug('[Electron BLE] Protocol V1 GetFeatures probe failed:', error);
       return false;
     }
   }
@@ -489,44 +578,73 @@ export default class ElectronBleTransport {
     return detected;
   }
 
-  private async writeWithChunking(uuid: string, hexData: string): Promise<void> {
-    const totalBytes = hexData.length / 2;
-
-    if (totalBytes <= BLE_PACKET_SIZE) {
-      await wait(BLE_WRITE_DELAY_MS);
-      await this.writeOnce(uuid, hexData);
-      return;
+  private async writeOnce(uuid: string, hexData: string): Promise<void> {
+    const nobleBle = window.desktopApi?.nobleBle;
+    if (!nobleBle) {
+      throw new Error('Noble BLE API not available');
     }
 
-    for (let offset = 0; offset < hexData.length; ) {
-      const chunkHexLen = Math.min(BLE_PACKET_SIZE * 2, hexData.length - offset);
-      const chunkHex = hexData.substring(offset, offset + chunkHexLen);
-      offset += chunkHexLen;
+    await nobleBle.write(uuid, hexData);
+  }
 
-      await this.writeOnce(uuid, chunkHex);
+  private async refreshBlePacketCapacity(uuid: string): Promise<void> {
+    const device = await window.desktopApi?.nobleBle?.getDevice(uuid);
+    this.updateBlePacketCapacity(uuid, device?.mtu);
+  }
 
-      if (offset < hexData.length) {
-        await wait(BLE_WRITE_DELAY_MS);
-      }
+  private updateBlePacketCapacity(uuid: string, mtu?: number): void {
+    const packetCapacity = resolveBlePacketCapacity(
+      mtu,
+      BLE_PACKET_SIZE_MAXIMUM,
+      BLE_PACKET_SIZE_FALLBACK
+    );
+    if (typeof mtu === 'number') {
+      this.deviceMtus.set(uuid, mtu);
+    } else {
+      this.deviceMtus.delete(uuid);
     }
+    this.devicePacketCapacities.set(uuid, packetCapacity);
   }
 
-  private async writeOnce(uuid: string, hexData: string): Promise<void> {
-    const nobleBle = window.desktopApi?.nobleBle;
-    if (!nobleBle) {
-      throw new Error('Noble BLE API not available');
-    }
+  private createMtuSubscription(uuid: string): (() => void) | undefined {
+    const onMtuChanged = window.desktopApi?.nobleBle?.onMtuChanged;
+    if (!onMtuChanged) return undefined;
+    return onMtuChanged(device => {
+      if (device.id === uuid) {
+        this.updateBlePacketCapacity(uuid, device.mtu);
+      }
+    });
+  }
 
-    await nobleBle.write(uuid, hexData);
+  private writeProtocolV2Frame(
+    uuid: string,
+    frame: Uint8Array,
+    context: ProtocolV2CallContext,
+    assertCurrentGeneration: () => void
+  ) {
+    const packetCapacity = this.devicePacketCapacities.get(uuid) ?? BLE_PACKET_SIZE_FALLBACK;
+    const shouldPace = !context.highVolume;
+    return writeProtocolV2BleFrame({
+      frame,
+      packetCapacity,
+      assertActive: assertCurrentGeneration,
+      signal: context.signal,
+      abortMessage: `Protocol V2 BLE write aborted for ${context.messageName}`,
+      initialDelayMs: shouldPace && frame.length <= packetCapacity ? BLE_WRITE_DELAY_MS : 0,
+      burstSize: shouldPace ? 1 : undefined,
+      burstPauseMs: shouldPace ? BLE_WRITE_DELAY_MS : 0,
+      writePacket: packet => this.writeOnce(uuid, bytesToHex(packet)),
+    });
   }
 
   private handleNotification(deviceId: string, hexData: string): void {
     if (hexData === 'PAIRING_REJECTED') {
       this.Log?.debug('[Electron BLE] Pairing rejection detected for device:', deviceId);
-      if (this.runPromise) {
-        const error = ERRORS.TypedError(HardwareErrorCode.BleDeviceBondedCanceled);
+      const error = ERRORS.TypedError(HardwareErrorCode.BleDeviceBondedCanceled);
+      if (this.deviceProtocol.get(deviceId) === 'V2') {
+        this.rejectProtocolV2Frames(deviceId, error);
+      } else if (this.runPromise && this.runPromiseDeviceId === deviceId) {
         this.runPromise.reject(error);
-        this.rejectAllProtocolV2Frames(error);
       }
       return;
     }
@@ -545,12 +663,6 @@ export default class ElectronBleTransport {
 
   private handleProtocolV2Notification(deviceId: string, hexData: string): void {
     try {
-      if (!this.runPromise || this.activeProtocolV2Call?.uuid !== deviceId) {
-        this.v2Assemblers.get(deviceId)?.reset();
-        this.resetProtocolV2Frames(deviceId);
-        return;
-      }
-
       const bytes = hexToBytes(hexData);
       if (bytes.length === 0) return;
 
@@ -562,11 +674,8 @@ export default class ElectronBleTransport {
       }
     } catch (error) {
       this.Log?.error('[Electron BLE] Protocol V2 notification error:', error);
-      if (this.runPromise) {
-        const notifyError = ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
-        this.runPromise.reject(notifyError);
-        this.rejectAllProtocolV2Frames(notifyError);
-      }
+      const notifyError = ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
+      this.rejectProtocolV2Frames(deviceId, notifyError);
     }
   }
 
@@ -589,21 +698,17 @@ export default class ElectronBleTransport {
     this.getProtocolV2FrameQueue(uuid).push(frame);
   }
 
-  private rejectAllProtocolV2Frames(error: Error) {
-    this.v2FrameQueues.clear();
-    for (const framePromise of this.v2FramePromises.values()) {
-      framePromise.reject(error);
-    }
-    this.v2FramePromises.clear();
-  }
-
   private resetProtocolV2Frames(uuid: string) {
-    this.v2FrameQueues.delete(uuid);
-    this.v2FramePromises.delete(uuid);
+    this.rejectProtocolV2Frames(uuid, new Error(`Protocol V2 frame state reset for ${uuid}`));
   }
 
-  private isActiveProtocolV2Call(uuid: string, token: number) {
-    return this.activeProtocolV2Call?.uuid === uuid && this.activeProtocolV2Call.token === token;
+  private rejectProtocolV2Frames(uuid: string, error: Error) {
+    this.v2FrameQueues.delete(uuid);
+    const framePromise = this.v2FramePromises.get(uuid);
+    if (framePromise) {
+      this.v2FramePromises.delete(uuid);
+      framePromise.reject(error);
+    }
   }
 
   private async readProtocolV2Frame(uuid: string) {
@@ -628,13 +733,18 @@ export default class ElectronBleTransport {
 
     if (result.error) {
       this.Log?.error('[Electron BLE] Protocol V1 packet processing error:', result.error);
-      if (this.runPromise) {
+      if (this.runPromise && this.runPromiseDeviceId === deviceId) {
         this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError));
       }
       return;
     }
 
-    if (result.isComplete && result.completePacket && this.runPromise) {
+    if (
+      result.isComplete &&
+      result.completePacket &&
+      this.runPromise &&
+      this.runPromiseDeviceId === deviceId
+    ) {
       this.runPromise.resolve(result.completePacket);
     }
   }
@@ -660,12 +770,8 @@ export default class ElectronBleTransport {
         `Device protocol has not been detected for ${uuid}`
       );
     }
-    if (shouldSuppressHighVolumeCallLog(name)) {
-      // 高频文件写入不要逐包发 debug 事件，否则调试日志会反向拖慢传输。
-    } else if (isLogBlockCommand(name)) {
-      this.Log?.debug('[Electron BLE] call', 'name:', name, 'protocol:', protocol);
-    } else {
-      this.Log?.debug('[Electron BLE] call', 'name:', name, 'data:', data, 'protocol:', protocol);
+    if (!shouldSuppressHighVolumeCallLog(name)) {
+      this.Log?.debug('transport call', createTransportCallLog(name, protocol, data));
     }
 
     if (protocol === 'V2') {
@@ -692,6 +798,7 @@ export default class ElectronBleTransport {
     const runPromise = createDeferred<Uint8Array | string>();
     runPromise.promise.catch(() => undefined);
     this.runPromise = runPromise;
+    this.runPromiseDeviceId = uuid;
     const messages = this._messages;
     const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
     let timeout: ReturnType<typeof setTimeout> | undefined;
@@ -736,11 +843,24 @@ export default class ElectronBleTransport {
       return check.call(jsonData);
     } catch (e) {
       this.Log?.error('[Electron BLE] Protocol V1 call error:', e);
+      const isProbeTimeout =
+        name === 'GetFeatures' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS;
+      if ((e as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleTimeoutError) {
+        this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
+        const notifyCleanup = this.notificationCleanups.get(uuid);
+        notifyCleanup?.();
+        this.notificationCleanups.delete(uuid);
+        this.notificationTokens.delete(uuid);
+        if (!isProbeTimeout) {
+          await this.releaseNative(uuid);
+        }
+      }
       throw e;
     } finally {
       if (timeout) clearTimeout(timeout);
       if (this.runPromise === runPromise) {
         this.runPromise = null;
+        this.runPromiseDeviceId = null;
       }
     }
   }
@@ -755,77 +875,61 @@ export default class ElectronBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    const forceRun = name === 'Initialize' || name === 'Cancel' || name === 'Ping';
-    if (this.runPromise) {
-      if (!forceRun) {
-        throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
-      }
-      const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
-      this.runPromise.reject(error);
-      this.rejectAllProtocolV2Frames(error);
-      this.runPromise = null;
-      this.activeProtocolV2Call = null;
+    const callOptions = options;
+
+    try {
+      return await this.protocolV2Links.call(
+        uuid,
+        () => this.createProtocolV2Adapter(uuid),
+        name,
+        data,
+        callOptions
+      );
+    } catch (e) {
+      this.Log?.error('[Electron BLE] Protocol V2 call error:', e);
+      throw e;
     }
+  }
 
-    const runPromise = createDeferred<Uint8Array | string>();
-    runPromise.promise.catch(() => undefined);
-    this.runPromise = runPromise;
-    const callToken = this.nextProtocolV2CallToken++;
-    this.activeProtocolV2Call = { uuid, token: callToken };
-    this.v2Assemblers.get(uuid)?.reset();
-    this.resetProtocolV2Frames(uuid);
-    let completed = false;
-    const callOptions = {
-      ...options,
-      timeoutMs: options?.timeoutMs ?? BLE_RESPONSE_TIMEOUT_MS,
+  private createProtocolV2Adapter(uuid: string) {
+    const generation = this.notificationTokens.get(uuid) ?? 0;
+    const assertCurrentGeneration = () => {
+      if (this.notificationTokens.get(uuid) !== generation) {
+        throw new Error(`Protocol V2 notification generation changed for ${uuid}`);
+      }
     };
 
-    try {
-      const session = new ProtocolV2Session({
-        schemas: {
-          protocolV1: this._messages,
-          protocolV2: this._messagesV2,
-        },
-        router: PROTOCOL_V2_CHANNEL_BLE_UART,
-        writeFrame: (frame: Uint8Array) => this.writeWithChunking(uuid, bytesToHex(frame)),
-        readFrame: async () => {
-          const rxFrame = await this.readProtocolV2Frame(uuid);
-          if (!(rxFrame instanceof Uint8Array)) {
-            throw new Error('Response is not Uint8Array');
-          }
-          return rxFrame;
-        },
-        logger: this.Log,
-        logPrefix: 'ProtocolV2 BLE',
-        createTimeoutError: (_messageName: string, timeout: number) =>
-          ERRORS.TypedError(
-            HardwareErrorCode.BleTimeoutError,
-            `BLE response timeout after ${timeout}ms for ${name}`
-          ),
-      });
-
-      const result = await session.call(name, data, callOptions);
-      completed = true;
-      return result;
-    } catch (e) {
-      if (this.isActiveProtocolV2Call(uuid, callToken)) {
+    return {
+      router: PROTOCOL_V2_CHANNEL_BLE_UART,
+      maxFrameBytes: PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
+      generation,
+      prepareCall: () => {
+        assertCurrentGeneration();
         this.v2Assemblers.get(uuid)?.reset();
         this.resetProtocolV2Frames(uuid);
-      }
-      this.Log?.error('[Electron BLE] Protocol V2 call error:', e);
-      throw e;
-    } finally {
-      if (this.isActiveProtocolV2Call(uuid, callToken)) {
-        if (!completed) {
-          this.v2Assemblers.get(uuid)?.reset();
+      },
+      writeFrame: (frame: Uint8Array, context: ProtocolV2CallContext) =>
+        this.writeProtocolV2Frame(uuid, frame, context, assertCurrentGeneration),
+      readFrame: async () => {
+        assertCurrentGeneration();
+        const rxFrame = await this.readProtocolV2Frame(uuid);
+        if (!(rxFrame instanceof Uint8Array)) {
+          throw new Error('Response is not Uint8Array');
         }
-        this.resetProtocolV2Frames(uuid);
-        this.activeProtocolV2Call = null;
-      }
-      if (this.runPromise === runPromise) {
-        this.runPromise = null;
-      }
-    }
+        return rxFrame;
+      },
+      reset: (reason: string) => {
+        this.v2Assemblers.get(uuid)?.reset();
+        this.rejectProtocolV2Frames(uuid, new Error(reason));
+      },
+      logger: this.Log,
+      logPrefix: 'ProtocolV2 BLE',
+      createTimeoutError: (messageName: string, timeout: number) =>
+        ERRORS.TypedError(
+          HardwareErrorCode.BleTimeoutError,
+          `BLE response timeout after ${timeout}ms for ${messageName}`
+        ),
+    };
   }
 
   private processProtocolV1Notification(deviceId: string, hexData: string): PacketProcessResult {