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

package/src/index.ts

@@ -1,24 +1,27 @@
 import ByteBuffer from 'bytebuffer';
 import * as usb from 'usb';
 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,
-  ProtocolV2FrameAssembler,
-  ProtocolV2Session,
+  ProtocolV2LinkError,
+  ProtocolV2UsbTransportBase,
   probeProtocolV2 as probeProtocolV2Helper,
 } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareErrorCode, ONEKEY_WEBUSB_FILTER, wait } from '@onekeyfe/hd-shared';
 
+import { createTransportCallLog, shouldSuppressHighVolumeCallLog } from './transportLog';
+
 import type EventEmitter from 'events';
 import type {
   AcquireInput,
   OneKeyDeviceInfo,
   ProtocolType,
+  ProtocolV2CallContext,
+  ProtocolV2Schemas,
   TransportCallOptions,
 } from '@onekeyfe/hd-transport';
 
@@ -129,31 +132,6 @@ function readSerialNumber(dev: usb.Device, openDevices?: Map<string, OpenDevice>
   });
 }
 
-/**
- * Promisified USB IN transfer (single attempt).
- */
-function transferInOnce(ep: usb.InEndpoint, length: number): Promise<Buffer> {
-  return new Promise((resolve, reject) => {
-    ep.transfer(length, (err: Error | undefined, data: Buffer | undefined) => {
-      if (err) return reject(err);
-      if (!data || data.length === 0) return reject(new Error('Empty USB transfer'));
-      resolve(data);
-    });
-  });
-}
-
-/**
- * Promisified USB OUT transfer (single attempt).
- */
-function transferOutOnce(ep: usb.OutEndpoint, data: Buffer): Promise<void> {
-  return new Promise((resolve, reject) => {
-    ep.transfer(data, (err: Error | undefined) => {
-      if (err) return reject(err);
-      resolve();
-    });
-  });
-}
-
 /**
  * Skip the 0x3F protocol marker byte from a USB packet.
  */
@@ -180,12 +158,14 @@ function toArrayBuffer(buf: Buffer): ArrayBuffer {
  *
  * Modeled after WebUsbTransport.
  */
-export default class NodeUsbTransport {
+export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string> {
   messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
   /** Protobuf schema for Protocol V2 transports. */
   messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
 
+  private protocolV2SchemaSource: string | undefined;
+
   name = 'NodeUsbTransport';
 
   version = '';
@@ -207,21 +187,29 @@ export default class NodeUsbTransport {
   /** Per-path protocol type detected by active wire-level probe. */
   private deviceProtocol: Map<string, ProtocolType> = new Map();
 
-  /** Per-path Protocol V2 frame assembler, preserving buffered frames during reads. */
-  private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
-
-  /** Per-path Protocol V2 session, preserving seq across API calls on the same device path. */
-  private protocolV2Sessions: Map<string, ProtocolV2Session> = new Map();
-
-  /** Current Protocol V2 read timeout, consumed by cached session readFrame closures. */
-  private protocolV2ReadTimeouts: Map<string, number | undefined> = new Map();
-
   /** per-path reconnect lock to prevent concurrent reconnects */
   private reconnectLocks = new Map<string, Promise<OpenDevice>>();
 
+  /**
+   * Retain the low-level Transfer so release()/stop() can cancel native pending reads.
+   * Endpoint.transfer() hides it and may keep the CLI alive after output completes.
+   */
+  private activeTransfers = new Map<
+    usb.Transfer,
+    { path: string; settled: Promise<void>; resolveSettled: () => void }
+  >();
+
   /** set to true when cancel() is called; checked by retry loops */
   private cancelled = false;
 
+  constructor() {
+    super({
+      router: PROTOCOL_V2_CHANNEL_USB,
+      maxFrameBytes: PROTOCOL_V2_FRAME_MAX_BYTES,
+      logPrefix: 'ProtocolV2 NodeUSB',
+    });
+  }
+
   /**
    * Initialize transport.
    * Signature matches the Transport.init interface (logger, emitter).
@@ -240,18 +228,47 @@ export default class NodeUsbTransport {
   }
 
   configureProtocolV2(signedData: any) {
+    const schemaSource =
+      typeof signedData === 'string'
+        ? signedData
+        : JSON.stringify(signedData) ?? String(signedData);
+    if (schemaSource === this.protocolV2SchemaSource) return;
+
+    const hadProtocolV2Schema = this.protocolV2SchemaSource !== undefined;
     this.messagesV2 = parseConfigure(signedData);
-    this.protocolV2Sessions.clear();
-    this.protocolV2ReadTimeouts.clear();
-    this.Log?.debug('[NodeUsbTransport] Protocol V2 schema configured');
+    this.protocolV2SchemaSource = schemaSource;
+    if (!hadProtocolV2Schema) return;
+
+    this.invalidateAllProtocolV2UsbLinks('Protocol V2 schema reconfigured').catch(error =>
+      this.Log?.debug('[NodeUsbTransport] schema link cleanup failed:', error)
+    );
   }
 
   listen() {
     // empty — could add hotplug events via usb.on('attach'/'detach')
   }
 
-  stop() {
-    // Placeholder — no background listeners to tear down
+  async stop(): Promise<void> {
+    this.cancelled = true;
+
+    await this.cancelActiveTransfers();
+
+    try {
+      await this.disposeProtocolV2UsbLinks('Node USB transport stopped');
+    } catch (error) {
+      this.Log?.debug('[NodeUsbTransport] stop link cleanup failed:', error);
+    }
+
+    // Reconnect may already be in flight when dispose starts. Wait for it to
+    // settle, then close every remaining handle so it cannot reopen USB after
+    // the first cleanup pass.
+    await Promise.allSettled(this.reconnectLocks.values());
+    await this.cancelActiveTransfers();
+    await Promise.all(Array.from(this.openDevices.keys(), path => this.closeOpenDevice(path)));
+
+    this.reconnectLocks.clear();
+    this.deviceProtocol.clear();
+    this.serialToBusId.clear();
   }
 
   /**
@@ -326,12 +343,18 @@ export default class NodeUsbTransport {
     }
 
     try {
+      await this.rotateProtocolV2UsbGeneration(path, 'Node USB transport acquired');
       await this.closeOpenDevice(path);
       await this.openDevice(path);
-      await this.detectProtocol(path, input.expectedProtocol);
+      await this.detectProtocol(path, input.expectedProtocol, input.protocolHint);
       return path;
     } catch (error: any) {
       this.Log?.debug('NodeUsbTransport acquire error: ', error);
+      try {
+        await this.release(path);
+      } catch (cleanupError) {
+        this.Log?.debug('NodeUsbTransport acquire cleanup error: ', cleanupError);
+      }
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, error.message ?? String(error));
     }
   }
@@ -340,9 +363,91 @@ export default class NodeUsbTransport {
    * Release device — release interface and close.
    */
   async release(path: string, _onclose?: boolean): Promise<void> {
+    await this.cancelActiveTransfers(path);
+    await this.invalidateProtocolV2UsbLink(path, 'Node USB transport released');
     await this.closeOpenDevice(path);
     this.deviceProtocol.delete(path);
-    this.protocolV2Assemblers.delete(path);
+  }
+
+  private async cancelActiveTransfers(path?: string): Promise<void> {
+    const transfers = Array.from(this.activeTransfers.entries()).filter(
+      ([, active]) => path === undefined || active.path === path
+    );
+    transfers.forEach(([transfer]) => {
+      try {
+        transfer.cancel();
+      } catch {
+        // A transfer may finish between the snapshot and cancel().
+      }
+    });
+    await Promise.allSettled(transfers.map(([, active]) => active.settled));
+  }
+
+  private createTrackedTransfer(
+    path: string,
+    endpoint: usb.InEndpoint | usb.OutEndpoint,
+    callback: (error: Error | undefined, buffer: Buffer, actualLength: number) => void
+  ): usb.Transfer {
+    let resolveSettled: () => void = () => undefined;
+    const settled = new Promise<void>(resolve => {
+      resolveSettled = resolve;
+    });
+    const transfer = endpoint.makeTransfer(endpoint.timeout, (error, buffer, actualLength) => {
+      this.activeTransfers.delete(transfer);
+      resolveSettled();
+      callback(error, buffer, actualLength);
+    });
+    this.activeTransfers.set(transfer, { path, settled, resolveSettled });
+    return transfer;
+  }
+
+  private transferInOnce(path: string, ep: usb.InEndpoint, length: number): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      const buffer = Buffer.alloc(length);
+      const transfer = this.createTrackedTransfer(
+        path,
+        ep,
+        (error, _submittedBuffer, actualLength) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          if (actualLength <= 0) {
+            reject(new Error('Empty USB transfer'));
+            return;
+          }
+          resolve(buffer.subarray(0, actualLength));
+        }
+      );
+      try {
+        transfer.submit(buffer);
+      } catch (error) {
+        const active = this.activeTransfers.get(transfer);
+        this.activeTransfers.delete(transfer);
+        active?.resolveSettled();
+        reject(error);
+      }
+    });
+  }
+
+  private transferOutOnce(path: string, ep: usb.OutEndpoint, data: Buffer): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const transfer = this.createTrackedTransfer(path, ep, error => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+      try {
+        transfer.submit(data);
+      } catch (error) {
+        const active = this.activeTransfers.get(transfer);
+        this.activeTransfers.delete(transfer);
+        active?.resolveSettled();
+        reject(error);
+      }
+    });
   }
 
   private async closeOpenDevice(path: string): Promise<void> {
@@ -397,18 +502,8 @@ export default class NodeUsbTransport {
         `Device protocol has not been detected for ${path}`
       );
     }
-    if (LogBlockCommand.has(name)) {
-      this.Log?.debug('NodeUsbTransport call-', ' name: ', name, ' protocol: ', protocol);
-    } else {
-      this.Log?.debug(
-        'NodeUsbTransport call-',
-        ' name: ',
-        name,
-        ' data: ',
-        data,
-        ' protocol: ',
-        protocol
-      );
+    if (!shouldSuppressHighVolumeCallLog(name)) {
+      this.Log?.debug('transport call', createTransportCallLog(name, protocol, data));
     }
 
     if (protocol === 'V2') {
@@ -445,7 +540,6 @@ export default class NodeUsbTransport {
   }
 
   cancel() {
-    this.Log?.debug('NodeUsbTransport cancel');
     this.cancelled = true;
   }
 
@@ -475,6 +569,12 @@ export default class NodeUsbTransport {
 
   private isRetryableError(error: unknown): boolean {
     const message = this.getErrorMessage(error).toLowerCase();
+    // cancelActiveTransfers() terminates timed-out or releasing native requests.
+    // LIBUSB_TRANSFER_CANCELLED is not transient. Retrying would start another pending
+    // read on the rebuilt interface and race protocol probing against release.
+    if (message.includes('cancelled') || message.includes('canceled')) {
+      return false;
+    }
     return (
       message.includes('libusb') ||
       message.includes('transfer') ||
@@ -531,6 +631,10 @@ export default class NodeUsbTransport {
       );
       await wait(attempt * PACKET_IO_RETRY_DELAY);
 
+      await this.rotateProtocolV2UsbGeneration(
+        path,
+        `Node USB Protocol V1 ${direction} reconnect attempt ${attempt}`
+      );
       // Close the existing device without clearing the detected protocol cache.
       try {
         await this.closeOpenDevice(path);
@@ -575,7 +679,7 @@ export default class NodeUsbTransport {
           const packet = new Uint8Array(PACKET_SIZE);
           packet[0] = REPORT_ID;
           packet.set(new Uint8Array(buffer), 1);
-          await transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(packet));
+          await this.transferOutOnce(path, this.getOpenDevice(path).epOut, Buffer.from(packet));
         }
         return; // all chunks sent successfully
       } catch (error) {
@@ -618,27 +722,27 @@ export default class NodeUsbTransport {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
       }
       try {
-        return await transferInOnce(currentDev.epIn, length);
+        return await this.transferInOnce(path, currentDev.epIn, length);
       } catch (error) {
         lastError = error;
         if (options?.waitIndefinitelyOnTimeout && this.isUsbTransferTimeout(error)) {
           attempt -= 1;
-          continue;
-        }
-        const shouldRetry = attempt < PACKET_IO_MAX_RETRIES && this.isRetryableError(error);
-        if (!shouldRetry) {
-          throw error;
-        }
-        try {
-          currentDev = await this.reconnectForRetry(path, 'in', attempt, error);
-        } catch (reconnectError) {
-          lastError = reconnectError;
-          this.Log?.debug(
-            `[NodeUsbTransport] reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(
-              reconnectError
-            )}`
-          );
-          break;
+        } else {
+          const shouldRetry = attempt < PACKET_IO_MAX_RETRIES && this.isRetryableError(error);
+          if (!shouldRetry) {
+            throw error;
+          }
+          try {
+            currentDev = await this.reconnectForRetry(path, 'in', attempt, error);
+          } catch (reconnectError) {
+            lastError = reconnectError;
+            this.Log?.debug(
+              `[NodeUsbTransport] reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(
+                reconnectError
+              )}`
+            );
+            break;
+          }
         }
       }
     }
@@ -698,7 +802,7 @@ export default class NodeUsbTransport {
       epIn.timeout = TRANSFER_TIMEOUT_MS;
       epOut.timeout = TRANSFER_TIMEOUT_MS;
 
-      await this.drainStaleInput(epIn);
+      await this.drainStaleInput(path, epIn);
 
       this.openDevices.set(path, { device: dev, iface, epIn, epOut });
     } catch (err) {
@@ -711,14 +815,14 @@ export default class NodeUsbTransport {
     }
   }
 
-  private async drainStaleInput(epIn: usb.InEndpoint): Promise<void> {
+  private async drainStaleInput(path: string, epIn: usb.InEndpoint): Promise<void> {
     const originalTimeout = epIn.timeout;
     epIn.timeout = 50;
     try {
       // Drain a small bounded number of packets left by the previous USB session.
       for (let index = 0; index < 16; index += 1) {
         try {
-          await transferInOnce(epIn, PACKET_SIZE);
+          await this.transferInOnce(path, epIn, PACKET_SIZE);
         } catch {
           break;
         }
@@ -744,17 +848,9 @@ export default class NodeUsbTransport {
 
   private async detectProtocol(
     path: string,
-    expectedProtocol?: ProtocolType
+    expectedProtocol?: ProtocolType,
+    protocolHint?: ProtocolType
   ): Promise<ProtocolType> {
-    if (expectedProtocol === 'V1') {
-      if (await this.probeProtocolV1(path)) {
-        this.deviceProtocol.set(path, 'V1');
-        this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V1 (expected)`);
-        return 'V1';
-      }
-      throw this.createProtocolMismatchError(expectedProtocol);
-    }
-
     if (expectedProtocol === 'V2') {
       if (await this.probeProtocolV2(path)) {
         this.deviceProtocol.set(path, 'V2');
@@ -764,22 +860,27 @@ export default class NodeUsbTransport {
       throw this.createProtocolMismatchError(expectedProtocol);
     }
 
-    if (this.deviceProtocol.get(path) === 'V2' && (await this.probeProtocolV2(path))) {
-      this.deviceProtocol.set(path, 'V2');
-      this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2 (cached)`);
-      return 'V2';
+    if (expectedProtocol === 'V1') {
+      if (await this.probeProtocolV1(path)) {
+        this.deviceProtocol.set(path, 'V1');
+        return 'V1';
+      }
+      throw this.createProtocolMismatchError(expectedProtocol);
     }
 
-    if (await this.probeProtocolV1(path)) {
-      this.deviceProtocol.set(path, 'V1');
-      this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V1`);
-      return 'V1';
-    }
+    const probeOrder: ProtocolType[] =
+      protocolHint === 'V2' || this.deviceProtocol.get(path) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
 
-    if (await this.probeProtocolV2(path)) {
-      this.deviceProtocol.set(path, 'V2');
-      this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2`);
-      return 'V2';
+    for (const [index, protocol] of probeOrder.entries()) {
+      if (index > 0) {
+        await this.resetConnectionAfterProbe(path);
+      }
+      const detected =
+        protocol === 'V1' ? await this.probeProtocolV1(path) : await this.probeProtocolV2(path);
+      if (detected) {
+        this.deviceProtocol.set(path, protocol);
+        return protocol;
+      }
     }
 
     this.deviceProtocol.delete(path);
@@ -787,11 +888,13 @@ export default class NodeUsbTransport {
   }
 
   private async resetConnectionAfterProbe(path: string) {
-    this.protocolV2Assemblers.get(path)?.reset();
-    this.protocolV2Sessions.delete(path);
-    this.protocolV2ReadTimeouts.delete(path);
+    await this.rotateProtocolV2UsbGeneration(path, 'Node USB protocol probe reset');
 
     try {
+      // A timed-out probe may leave an IN transfer pending. Cancel and await it before
+      // closing the interface, or libusb may never callback and release()/stop() will
+      // wait forever, surfacing as Polling timeout (809).
+      await this.cancelActiveTransfers(path);
       await this.closeOpenDevice(path);
     } catch (error) {
       this.Log?.debug('[NodeUsbTransport] close after protocol probe error:', error);
@@ -851,8 +954,7 @@ export default class NodeUsbTransport {
     try {
       await this.callProtocolV1(path, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT });
       return true;
-    } catch (error) {
-      this.Log?.debug('[NodeUsbTransport] Protocol V1 Initialize probe failed:', error);
+    } catch (_error) {
       return false;
     }
   }
@@ -871,75 +973,71 @@ export default class NodeUsbTransport {
     });
   }
 
-  private async writeProtocolV2Frame(path: string, frame: Uint8Array) {
-    let lastError: unknown;
-    for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
+  protected getProtocolV2UsbSchemas(): ProtocolV2Schemas {
+    if (!this.messages || !this.messagesV2) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+    return {
+      protocolV1: this.messages,
+      protocolV2: this.messagesV2,
+    };
+  }
+
+  protected getProtocolV2UsbLogger() {
+    return this.Log;
+  }
+
+  protected async writeProtocolV2UsbPacket(
+    path: string,
+    frame: Uint8Array,
+    _context: ProtocolV2CallContext
+  ): Promise<void> {
+    if (this.cancelled) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
+    }
+    await this.transferOutOnce(path, this.getOpenDevice(path).epOut, Buffer.from(frame));
+  }
+
+  protected async readProtocolV2UsbPacket(
+    path: string,
+    _context: ProtocolV2CallContext
+  ): Promise<Uint8Array> {
+    for (;;) {
       if (this.cancelled) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
       }
       try {
-        await transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(frame));
-        return;
+        const packet = await this.transferInOnce(
+          path,
+          this.getOpenDevice(path).epIn,
+          PROTOCOL_V2_FRAME_MAX_BYTES
+        );
+        return new Uint8Array(
+          packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength)
+        );
       } catch (error) {
-        lastError = error;
-        const shouldRetry = attempt < PACKET_IO_MAX_RETRIES && this.isRetryableError(error);
-        if (!shouldRetry) {
+        if (!this.isUsbTransferTimeout(error)) {
           throw error;
         }
-        try {
-          await this.reconnectForRetry(path, 'out', attempt, error);
-        } catch (reconnectError) {
-          lastError = reconnectError;
-          this.Log?.debug(
-            `[NodeUsbTransport] Protocol V2 write reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(
-              reconnectError
-            )}`
-          );
-          break;
-        }
       }
     }
-    throw lastError;
   }
 
-  private async receiveProtocolV2Frame(path: string, timeoutMs?: number): Promise<Uint8Array> {
-    let assembler = this.protocolV2Assemblers.get(path);
-    if (!assembler) {
-      assembler = new ProtocolV2FrameAssembler(PROTOCOL_V2_FRAME_MAX_BYTES);
-      this.protocolV2Assemblers.set(path, assembler);
-    }
+  protected async resetProtocolV2UsbNativeLink(path: string, _reason: string): Promise<void> {
+    await this.cancelActiveTransfers(path);
+    await this.closeOpenDevice(path);
+  }
 
-    let frame: Uint8Array | undefined = assembler.push(new Uint8Array(0));
-    const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
+  protected onProtocolV2UsbLinkInvalidated(path: string, reason: string) {
+    this.deviceProtocol.delete(path);
+    this.Log?.debug(`[NodeUsbTransport] Protocol V2 link invalidated: ${path}`, reason);
+  }
 
-    while (!frame) {
-      const transferIn = this.transferInWithRetry(
-        path,
-        this.getOpenDevice(path),
-        PROTOCOL_V2_FRAME_MAX_BYTES,
-        { waitIndefinitelyOnTimeout: !deadline }
-      );
-      const packet = deadline
-        ? await this.withProtocolReadTimeout(
-            path,
-            transferIn,
-            Math.max(deadline - Date.now(), 1),
-            'V2'
-          )
-        : await transferIn;
-      const bytes = new Uint8Array(
-        packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength)
-      );
-      try {
-        frame = assembler.push(bytes);
-      } catch (error) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.NetworkError,
-          error instanceof Error ? error.message : String(error)
-        );
-      }
-    }
-    return frame;
+  protected createProtocolV2UsbTimeoutError(name: string, timeoutMs: number): Error {
+    return new ProtocolV2LinkError(
+      'response-timeout',
+      `Protocol V2 response timeout after ${timeoutMs}ms for ${name}`
+    );
   }
 
   private async callProtocolV2(
@@ -948,42 +1046,7 @@ export default class NodeUsbTransport {
     data: Record<string, unknown>,
     options?: TransportCallOptions
   ) {
-    const protocolV1Messages = this.messages;
-    if (!this.messagesV2) {
-      throw ERRORS.TypedError(
-        HardwareErrorCode.TransportNotConfigured,
-        'Protocol V2 schema not configured'
-      );
-    }
-    if (!protocolV1Messages) {
-      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
-    }
-
-    let session = this.protocolV2Sessions.get(path);
-    if (!session) {
-      session = new ProtocolV2Session({
-        schemas: {
-          protocolV1: protocolV1Messages,
-          protocolV2: this.messagesV2,
-        },
-        router: PROTOCOL_V2_CHANNEL_USB,
-        writeFrame: (frame: Uint8Array) => this.writeProtocolV2Frame(path, frame),
-        readFrame: () => this.receiveProtocolV2Frame(path, this.protocolV2ReadTimeouts.get(path)),
-        logger: this.Log,
-        logPrefix: 'ProtocolV2 NodeUSB',
-        createTimeoutError: (messageName: string, timeoutMs: number) =>
-          new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${messageName}`),
-      });
-      this.protocolV2Sessions.set(path, session);
-    }
-
-    this.protocolV2ReadTimeouts.set(path, options?.timeoutMs);
-    this.protocolV2Assemblers.get(path)?.reset();
-    try {
-      return await session.call(name, data, options);
-    } finally {
-      this.protocolV2ReadTimeouts.delete(path);
-    }
+    return this.callProtocolV2Usb(path, name, data, options);
   }
 
   /**

package/src/transportLog.ts

@@ -0,0 +1 @@
+export { createTransportCallLog, shouldSuppressHighVolumeCallLog } from '@onekeyfe/hd-transport';