@onekeyfe/hd-transport-web-device 1.2.0-alpha.2 → 1.2.0-alpha.20

package/src/webusb.ts

@@ -1,19 +1,28 @@
 /* eslint-disable no-undef */
 import transport, {
-  LogBlockCommand,
   PROTOCOL_V1_CHUNK_PAYLOAD_SIZE,
   PROTOCOL_V1_MESSAGE_HEADER_SIZE,
   PROTOCOL_V1_REPORT_ID,
   PROTOCOL_V1_USB_PACKET_SIZE,
   PROTOCOL_V2_CHANNEL_USB,
   PROTOCOL_V2_FRAME_MAX_BYTES,
+  PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS,
   ProtocolV2FrameAssembler,
+  ProtocolV2SequenceCursor,
   ProtocolV2Session,
   probeProtocolV2 as probeProtocolV2Helper,
 } from '@onekeyfe/hd-transport';
-import { ERRORS, HardwareErrorCode, ONEKEY_WEBUSB_FILTER, wait } from '@onekeyfe/hd-shared';
+import {
+  ERRORS,
+  HardwareErrorCode,
+  ONEKEY_WEBUSB_FILTER,
+  isKnownTrezorWebUsbDevice,
+  wait,
+} from '@onekeyfe/hd-shared';
 import ByteBuffer from 'bytebuffer';
 
+import { createTransportCallLog, shouldSuppressHighVolumeCallLog } from './transportLog';
+
 import type {
   AcquireInput,
   OneKeyDeviceInfoBase,
@@ -33,22 +42,6 @@ const HEADER_LENGTH = PROTOCOL_V1_MESSAGE_HEADER_SIZE;
 const PACKET_IO_MAX_RETRIES = 3;
 const PACKET_IO_RETRY_DELAY = 300;
 const PROTOCOL_PROBE_TIMEOUT = 1000;
-const WEBUSB_FILE_WRITE_LOG_BLOCK_PATTERN = /(?:^|[^a-z])(?:raw)?(?:filesystem|emmc)?filewrite$/i;
-
-function shouldSuppressWebUsbCallLog(name: string) {
-  const normalized = name.replace(/[_\s-]/g, '');
-  return WEBUSB_FILE_WRITE_LOG_BLOCK_PATTERN.test(normalized);
-}
-
-function isLogBlockCommand(name: string) {
-  return (LogBlockCommand as Set<string> | undefined)?.has?.(name) ?? false;
-}
-
-function shouldBlockWebUsbCallDataLog(name: string) {
-  const normalized = name.replace(/[_\s-]/g, '');
-  return isLogBlockCommand(name) || WEBUSB_FILE_WRITE_LOG_BLOCK_PATTERN.test(normalized);
-}
-
 function inferProtocolHintFromDeviceName(name?: string | null): ProtocolType | undefined {
   return /\bpro\s*2\b/i.test(name ?? '') ? 'V2' : undefined;
 }
@@ -84,22 +77,26 @@ export default class WebUsbTransport {
 
   private deviceProtocolHints: Map<string, ProtocolType> = new Map();
 
-  /** 按设备缓存 Protocol V2 frame assembler，保留同一次读取里多出来的后续 frame。 */
+  /** Per-device Protocol V2 assembler that retains extra frames from one read. */
   private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
 
-  /** 按设备缓存 Protocol V2 session，保持 seq 与设备会话一致递增。 */
+  /** Per-device Protocol V2 session that keeps sequence numbers monotonic. */
   private protocolV2Sessions: Map<string, ProtocolV2Session> = new Map();
 
-  /** 当前 Protocol V2 调用的读取超时，由缓存 session 的 readFrame 闭包读取。 */
+  /** Sequence cursors survive ordinary reconnects and cached session rebuilds. */
+  private protocolV2Sequences: Map<string, ProtocolV2SequenceCursor> = new Map();
+
+  /** Read timeout for the current Protocol V2 call, consumed by cached readFrame. */
   private protocolV2ReadTimeouts: Map<string, number | undefined> = new Map();
 
+  private protocolV2WriteTimeoutMs = PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS;
+
   /** Per-path USB endpoint / interface numbers (discovered from USB descriptors) */
   private deviceEndpoints: Map<string, DeviceEndpoints> = new Map();
 
   /**
-   * 早期 Pro2 工程板 USB descriptor 没有烧录 serial number。
-   * 为这类设备生成会话内稳定的 mock path（同一 USBDevice 实例复用同一 path），
-   * 避免设备因为空 serial 被发现流程整体丢弃。重新插拔后实例变化，path 会重新生成。
+   * Early Pro2 boards have no USB serial number. Assign a session-stable mock path per
+   * USBDevice instance so discovery retains them; reconnecting creates a new instance/path.
    */
   private mockSerialPaths: WeakMap<USBDevice, string> = new WeakMap();
 
@@ -159,7 +156,6 @@ export default class WebUsbTransport {
     this.messagesV2 = parseConfigure(signedData);
     this.protocolV2Sessions.clear();
     this.protocolV2ReadTimeouts.clear();
-    this.Log?.debug('[WebUsbTransport] Protocol V2 schema configured');
   }
 
   /**
@@ -192,8 +188,7 @@ export default class WebUsbTransport {
   }
 
   /**
-   * 设备 path：正常设备直接用 USB serial number；
-   * 空 serial（早期工程板）回退到会话内稳定的 mock path。
+   * Use the USB serial as the device path, falling back to a session-stable mock path.
    */
   private getDevicePath(device: USBDevice): string {
     if (typeof device.serialNumber === 'string' && device.serialNumber.length > 0) {
@@ -218,11 +213,13 @@ export default class WebUsbTransport {
     if (!this.usb) return [];
 
     const devices = await this.usb.getDevices();
-    const onekeyDevices = devices.filter(dev =>
-      ONEKEY_WEBUSB_FILTER.some(
-        desc => dev.vendorId === desc.vendorId && dev.productId === desc.productId
-      )
-    );
+    const onekeyDevices = devices.filter(dev => {
+      const isOneKey = ONEKEY_WEBUSB_FILTER.some(
+        (desc: { vendorId: number; productId: number }) =>
+          dev.vendorId === desc.vendorId && dev.productId === desc.productId
+      );
+      return isOneKey && !isKnownTrezorWebUsbDevice(dev);
+    });
 
     this.deviceList = onekeyDevices.map(device => {
       const path = this.getDevicePath(device);
@@ -238,14 +235,6 @@ export default class WebUsbTransport {
       };
     });
 
-    // Debug: log all discovered devices. Protocol is detected after acquire via wire probe.
-    for (const dev of onekeyDevices) {
-      this.Log.debug(
-        `[WebUSB] Device: name="${dev.productName}" serial="${dev.serialNumber}" ` +
-          `VID=0x${dev.vendorId.toString(16)} PID=0x${dev.productId.toString(16)}`
-      );
-    }
-
     return this.deviceList;
   }
 
@@ -300,23 +289,21 @@ export default class WebUsbTransport {
     if (expectedProtocol === 'V1') {
       if (await this.probeProtocolV1(path)) {
         this.deviceProtocol.set(path, 'V1');
-        this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> V1 (expected)`);
         return 'V1';
       }
+      await this.resetConnectionAfterProbe(path);
       throw this.createProtocolMismatchError(expectedProtocol);
     }
 
     if (expectedProtocol === 'V2') {
-      // 免探测路径：调用方显式承诺该设备是 V2（例如固件升级重启后的重连场景，
-      // 上层已经探测过协议并通过 expectedProtocol 传回），这里不再重复探测。
+      // 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(path, 'V2');
-      this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> V2 (expected)`);
       return 'V2';
     }
 
-    // 项目约束：协议判断必须在连接后主动探测，不能依赖设备名/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(path) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
 
@@ -325,9 +312,14 @@ export default class WebUsbTransport {
         protocol === 'V1' ? await this.probeProtocolV1(path) : await this.probeProtocolV2(path);
       if (detected) {
         this.deviceProtocol.set(path, protocol);
-        this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> ${protocol}`);
         return protocol;
       }
+      if (protocol === 'V1') {
+        // A timed-out WebUSB transferIn cannot be cancelled in place. Closing and
+        // reopening the device guarantees the next protocol probe cannot consume a
+        // late V1 response. V2 timeout recovery is owned by callProtocolV2.
+        await this.resetConnectionAfterProbe(path);
+      }
     }
 
     this.deviceProtocol.delete(path);
@@ -414,13 +406,6 @@ export default class WebUsbTransport {
    */
   async connectToDevice(path: string, first: boolean) {
     let device: USBDevice = await this.findDevice(path);
-    this.Log.debug(
-      '[WebUsbTransport] connecting to device:',
-      device.productName,
-      'PID:',
-      device.productId
-    );
-
     if (!device.opened) {
       await device.open();
     }
@@ -571,16 +556,7 @@ export default class WebUsbTransport {
     let lastError: unknown;
     for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt += 1) {
       try {
-        const device = await this.findDevice(path);
-        if (!device.opened) {
-          await this.connect(path, false);
-        }
-        const endpoints = this.deviceEndpoints.get(path);
-        const endpointOut = endpoints?.endpointOut ?? this.endpointId;
-        const transferBuffer = this.toArrayBuffer(
-          packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength)
-        );
-        await device.transferOut(endpointOut, transferBuffer);
+        await this.transferOutOnce(path, packet);
         return;
       } catch (error) {
         lastError = error;
@@ -603,6 +579,19 @@ export default class WebUsbTransport {
     throw lastError;
   }
 
+  private async transferOutOnce(path: string, packet: Uint8Array) {
+    const device = await this.findDevice(path);
+    if (!device.opened) {
+      await this.connect(path, false);
+    }
+    const endpoints = this.deviceEndpoints.get(path);
+    const endpointOut = endpoints?.endpointOut ?? this.endpointId;
+    const transferBuffer = this.toArrayBuffer(
+      packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength)
+    );
+    await device.transferOut(endpointOut, transferBuffer);
+  }
+
   private async transferInWithRetry(
     path: string,
     length: number,
@@ -672,13 +661,12 @@ export default class WebUsbTransport {
   }
 
   private async withProtocolReadTimeout<T>(
-    path: string,
+    _path: string,
     promise: Promise<T>,
     timeoutMs: number,
     protocol: ProtocolType,
     onTimeout?: () => void
   ): Promise<T> {
-    void path;
     let timer: ReturnType<typeof setTimeout> | undefined;
     let timedOut = false;
     const waitForeverAfterTimeout = () => new Promise<never>(() => {});
@@ -695,7 +683,7 @@ export default class WebUsbTransport {
       return await Promise.race([
         guardedPromise,
         new Promise<never>((_, reject) => {
-          timer = setTimeout(async () => {
+          timer = setTimeout(() => {
             timedOut = true;
             onTimeout?.();
             reject(new Error(`Protocol ${protocol} read timeout after ${timeoutMs}ms`));
@@ -715,8 +703,7 @@ export default class WebUsbTransport {
     try {
       await this.callProtocolV1(path, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT });
       return true;
-    } catch (error) {
-      this.Log.debug('[WebUsbTransport] Protocol V1 Initialize probe failed:', error);
+    } catch (_error) {
       return false;
     }
   }
@@ -731,7 +718,6 @@ export default class WebUsbTransport {
       timeoutMs: PROTOCOL_PROBE_TIMEOUT,
       logger: this.Log,
       logPrefix: 'ProtocolV2 WebUSB',
-      onProbeFailed: () => this.resetConnectionAfterProbe(path),
     });
   }
 
@@ -761,12 +747,8 @@ export default class WebUsbTransport {
       );
     }
 
-    if (shouldSuppressWebUsbCallLog(name)) {
-      // 高频文件写入不要逐包发 debug 事件，否则浏览器侧会被日志处理拖慢。
-    } else if (shouldBlockWebUsbCallDataLog(name)) {
-      this.Log.debug('call-', ' name: ', name, ' protocol: ', protocol);
-    } else {
-      this.Log.debug('call-', ' name: ', name, ' data: ', data, ' protocol: ', protocol);
+    if (!shouldSuppressHighVolumeCallLog(name)) {
+      this.Log.debug('transport call', createTransportCallLog(name, protocol));
     }
 
     if (protocol === 'V2') {
@@ -829,13 +811,20 @@ export default class WebUsbTransport {
 
     let session = this.protocolV2Sessions.get(path);
     if (!session) {
+      let sequenceCursor = this.protocolV2Sequences.get(path);
+      if (!sequenceCursor) {
+        sequenceCursor = new ProtocolV2SequenceCursor();
+        this.protocolV2Sequences.set(path, sequenceCursor);
+      }
       session = new ProtocolV2Session({
         schemas: {
           protocolV1: protocolV1Messages,
           protocolV2: this.messagesV2,
         },
         router: PROTOCOL_V2_CHANNEL_USB,
-        writeFrame: (frame: Uint8Array) => this.transferOutWithRetry(path, frame),
+        sequenceCursor,
+        writeTimeoutMs: this.protocolV2WriteTimeoutMs,
+        writeFrame: (frame: Uint8Array) => this.transferOutOnce(path, frame),
         readFrame: () => this.receiveProtocolV2Frame(path, this.protocolV2ReadTimeouts.get(path)),
         logger: this.Log,
         logPrefix: 'ProtocolV2 WebUSB',
@@ -849,6 +838,22 @@ export default class WebUsbTransport {
     this.protocolV2Assemblers.get(path)?.reset();
     try {
       return await session.call(name, data, options);
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+      if (
+        message.includes('protocol v2 read timeout') ||
+        message.includes('protocol v2 write timeout') ||
+        message.includes('protocol v2 delivery timeout') ||
+        message.includes('response timeout')
+      ) {
+        try {
+          await this.resetConnectionAfterProbe(path);
+        } catch (resetError) {
+          this.Log.debug('[WebUsbTransport] Protocol V2 timeout reset failed:', resetError);
+        }
+      }
+      throw error;
     } finally {
       this.protocolV2ReadTimeouts.delete(path);
     }
@@ -956,6 +961,8 @@ export default class WebUsbTransport {
     this.deviceProtocolHints.delete(path);
     this.protocolV2Assemblers.get(path)?.reset();
     this.protocolV2Assemblers.delete(path);
+    this.protocolV2Sessions.delete(path);
+    this.protocolV2ReadTimeouts.delete(path);
     this.deviceEndpoints.delete(path);
   }