@onekeyfe/hd-transport-web-device 1.2.0-alpha.13 → 1.2.0-alpha.131

package/src/electron-ble-transport.ts

@@ -1,11 +1,14 @@
 import transport, {
   PROTOCOL_V1_MESSAGE_HEADER_SIZE,
+  PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
   PROTOCOL_V2_CHANNEL_BLE_UART,
   ProtocolV2FrameAssembler,
   ProtocolV2LinkManager,
+  TRANSPORT_EVENT,
   bytesToHex,
   hexToBytes,
   probeProtocolV2 as probeProtocolV2Helper,
+  writeProtocolV2BleFrame,
 } from '@onekeyfe/hd-transport';
 import {
   ERRORS,
@@ -13,14 +16,18 @@ 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 { parseConfigure, ProtocolV1, check } = transport;
@@ -35,6 +42,7 @@ export type BleAcquireInput = {
   uuid: string;
   forceCleanRunPromise?: boolean;
   expectedProtocol?: ProtocolType;
+  protocolHint?: ProtocolType;
 };
 
 interface PacketProcessResult {
@@ -60,29 +68,33 @@ 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_PROBE_TIMEOUT_MS = 3000;
 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;
@@ -93,6 +105,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();
@@ -117,13 +133,18 @@ export default class ElectronBleTransport {
       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.release(uuid);
+        await this.releaseNative(uuid);
       }
     },
   });
 
+  /** One-shot guard so a missing preload `release` bridge is reported once. */
+  private warnedMissingRelease = false;
+
   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();
@@ -167,12 +188,19 @@ export default class ElectronBleTransport {
       .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);
     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) {
@@ -180,6 +208,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();
@@ -207,10 +241,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.protocolV2Links
-      .invalidateAllLinks('Protocol V2 schema reconfigured')
-      .catch(error => this.Log?.debug('[Electron BLE] schema link cleanup failed:', error));
+    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() {
@@ -252,8 +295,8 @@ export default class ElectronBleTransport {
     if (forceCleanRunPromise && this.runPromise) {
       const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
       this.runPromise.reject(error);
-      this.rejectAllProtocolV2Frames(error);
       this.runPromise = null;
+      this.runPromiseDeviceId = null;
     }
 
     try {
@@ -267,7 +310,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);
       }
@@ -279,19 +324,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,
@@ -301,14 +365,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,
@@ -328,9 +384,25 @@ export default class ElectronBleTransport {
     }
   }
 
-  async release(id: string) {
+  async release(id: string, _onclose?: boolean, keepSession?: boolean) {
     try {
       await this.protocolV2Links.invalidateLink(id, 'Electron BLE transport released');
+      await this.releaseLogical(id, keepSession);
+    } catch (error) {
+      this.Log?.error('[Electron BLE] release failed:', error);
+      this.cleanupDeviceState(id);
+    }
+  }
+
+  // DeviceConnector.disconnect feature-detects this; without it REQUIRE_DISCONNECT
+  // recovery is a no-op and keep-alive hands the wedged link to every retry.
+  async disconnect(id: string) {
+    return this.releaseNative(id);
+  }
+
+  // Hard teardown, error paths only: a link presumed dead must not be reused.
+  private async releaseNative(id: string) {
+    try {
       if (this.connectedDevices.has(id)) {
         if (window.desktopApi?.nobleBle) {
           await window.desktopApi.nobleBle.unsubscribe(id);
@@ -344,6 +416,32 @@ export default class ElectronBleTransport {
     }
   }
 
+  // Logical release: link and subscription stay up for the next call. Renderer
+  // listeners are still torn down, or fresh ones would double-process packets.
+  private async releaseLogical(id: string, keepSession?: boolean) {
+    try {
+      if (!this.connectedDevices.has(id)) return;
+      this.cleanupDeviceState(id);
+
+      const release = window.desktopApi?.nobleBle?.release;
+      if (!release) {
+        // Degraded, not broken: say it once, it just looks like a slow device.
+        if (!this.warnedMissingRelease) {
+          this.warnedMissingRelease = true;
+          this.Log?.error(
+            '[Electron BLE] desktopApi.nobleBle.release is missing from the preload bridge; ' +
+              'keep-alive idle countdown will never start — map NOBLE_BLE_RELEASE in the desktop preload'
+          );
+        }
+        return;
+      }
+      await release(id, keepSession);
+    } catch (error) {
+      this.Log?.error('[Electron BLE] logical release failed:', error);
+      this.cleanupDeviceState(id);
+    }
+  }
+
   private createProtocolMismatchError(expected: ProtocolType) {
     return ERRORS.TypedError(
       HardwareErrorCode.RuntimeError,
@@ -354,7 +452,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'
     );
   }
 
@@ -379,23 +477,24 @@ 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) {
-        // 上一个协议探测失败后，重置订阅与缓冲，避免残留数据干扰下一个协议的探测。
+        // Keep the physical BLE link while switching probes. Reconnecting here can
+        // summon a second OS pairing prompt for a device that is still onboarding.
         await this.resetProbeStateAfterProtocolProbe(uuid, probeOrder[i - 1]);
       }
       const detected =
@@ -435,33 +534,20 @@ export default class ElectronBleTransport {
     this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
     this.v2Assemblers.get(uuid)?.reset();
     this.resetProtocolV2Frames(uuid);
-    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);
-    if (notifyCleanup) {
-      notifyCleanup();
-      this.notificationCleanups.delete(uuid);
-    }
-    this.notificationTokens.delete(uuid);
-
-    try {
-      await window.desktopApi?.nobleBle?.unsubscribe(uuid);
-    } catch (error) {
-      this.Log?.debug(`[Electron BLE] unsubscribe after Protocol ${protocol} probe failed:`, error);
-    }
-    try {
-      await window.desktopApi?.nobleBle?.subscribe(uuid);
-    } catch (error) {
-      this.Log?.debug(`[Electron BLE] resubscribe after Protocol ${protocol} probe failed:`, error);
-      throw error;
+    // A timed-out V1 probe retires its renderer notification token so a late V1
+    // response cannot satisfy the V2 probe. Install a fresh listener without
+    // touching the native GATT subscription or physical connection.
+    if (!this.notificationCleanups.has(uuid)) {
+      const cleanup = this.createNotificationSubscription(uuid);
+      this.notificationCleanups.set(uuid, cleanup);
     }
-
-    const cleanup = this.createNotificationSubscription(uuid);
-    this.notificationCleanups.set(uuid, cleanup);
   }
 
   private async probeProtocolV1(uuid: string) {
@@ -471,11 +557,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;
     }
   }
@@ -503,35 +591,63 @@ 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, { pacingDelayMs: 0 });
+  }
 
-      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.highThroughput;
+    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 {
@@ -540,7 +656,7 @@ export default class ElectronBleTransport {
       const error = ERRORS.TypedError(HardwareErrorCode.BleDeviceBondedCanceled);
       if (this.deviceProtocol.get(deviceId) === 'V2') {
         this.rejectProtocolV2Frames(deviceId, error);
-      } else if (this.runPromise) {
+      } else if (this.runPromise && this.runPromiseDeviceId === deviceId) {
         this.runPromise.reject(error);
       }
       return;
@@ -595,17 +711,8 @@ 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 rejectProtocolV2Frames(uuid: string, error: Error) {
@@ -639,13 +746,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);
     }
   }
@@ -671,16 +783,25 @@ export default class ElectronBleTransport {
         `Device protocol has not been detected for ${uuid}`
       );
     }
-    if (!shouldSuppressHighVolumeCallLog(name)) {
-      this.Log?.debug('transport call', createTransportCallLog(name, protocol));
-    }
-
     if (protocol === 'V2') {
       return this.callProtocolV2(uuid, name, data, options);
     }
     return this.callProtocolV1(uuid, name, data, options);
   }
 
+  async post(uuid: string, name: string, data: Record<string, unknown>) {
+    if (this.deviceProtocol.get(uuid) === 'V2') {
+      await this.protocolV2Links.sendFlowControl(
+        uuid,
+        () => this.createProtocolV2Adapter(uuid),
+        name,
+        data
+      );
+      return;
+    }
+    await this.callProtocolV1(uuid, name, data);
+  }
+
   private async callProtocolV1(
     uuid: string,
     name: string,
@@ -699,6 +820,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;
@@ -743,11 +865,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;
       }
     }
   }
@@ -762,10 +897,7 @@ export default class ElectronBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    const callOptions = {
-      ...options,
-      timeoutMs: options?.timeoutMs ?? BLE_RESPONSE_TIMEOUT_MS,
-    };
+    const callOptions = options;
 
     try {
       return await this.protocolV2Links.call(
@@ -791,16 +923,15 @@ export default class ElectronBleTransport {
 
     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);
       },
-      writeFrame: (frame: Uint8Array) => {
-        assertCurrentGeneration();
-        return this.writeWithChunking(uuid, bytesToHex(frame));
-      },
+      writeFrame: (frame: Uint8Array, context: ProtocolV2CallContext) =>
+        this.writeProtocolV2Frame(uuid, frame, context, assertCurrentGeneration),
       readFrame: async () => {
         assertCurrentGeneration();
         const rxFrame = await this.readProtocolV2Frame(uuid);
@@ -844,6 +975,12 @@ export default class ElectronBleTransport {
         bufferState.bufferLength = dataView.getInt32(5, false);
         bufferState.buffer = [...data.subarray(3)];
       } else {
+        if (bufferState.buffer.length === 0) {
+          // Tail of a cancelled call, arriving after the buffer was reset. Not an
+          // `error`: the caller rejects the in-flight call on that field.
+          this.Log?.debug('[Electron BLE] Orphan continuation chunk discarded');
+          return { isComplete: false };
+        }
         bufferState.buffer = bufferState.buffer.concat([...data]);
       }
 

package/src/transportLog.ts

@@ -1,11 +1 @@
-import type { ProtocolType } from '@onekeyfe/hd-transport';
-
-const HIGH_VOLUME_CALLS = new Set(['FileWrite', 'FilesystemFileWrite', 'EmmcFileWrite']);
-
-export function shouldSuppressHighVolumeCallLog(name: string) {
-  return HIGH_VOLUME_CALLS.has(name);
-}
-
-export function createTransportCallLog(name: string, protocol: ProtocolType) {
-  return { name, protocol };
-}
+export { createTransportCallLog, shouldSuppressHighVolumeCallLog } from '@onekeyfe/hd-transport';