@onekeyfe/hd-transport-usb 1.2.0-alpha.2 → 1.2.0-alpha.21

package/src/index.ts

@@ -1,24 +1,26 @@
 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,
+  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';
 
@@ -44,7 +46,7 @@ const SERIAL_READ_TIMEOUT_MS = 5000;
 /** Packet I/O retry configuration (matches WebUsbTransport) */
 const PACKET_IO_MAX_RETRIES = 3;
 const PACKET_IO_RETRY_DELAY = 300;
-const PROTOCOL_PROBE_TIMEOUT = 1000;
+const PROTOCOL_PROBE_TIMEOUT = 5000;
 
 /**
  * Opened device state — holds the USB device, claimed interface, and endpoints.
@@ -129,57 +131,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();
-    });
-  });
-}
-
-function resetUsbDevice(dev: usb.Device): Promise<void> {
-  return new Promise(resolve => {
-    const reset = (dev as usb.Device & { reset?: (callback: (err?: Error) => void) => void }).reset;
-    if (typeof reset !== 'function') {
-      resolve();
-      return;
-    }
-    reset.call(dev, () => resolve());
-  });
-}
-
-function clearEndpointHalt(ep: usb.InEndpoint | usb.OutEndpoint): Promise<void> {
-  return new Promise(resolve => {
-    const clearHalt = (
-      ep as (usb.InEndpoint | usb.OutEndpoint) & {
-        clearHalt?: (callback: (err?: Error) => void) => void;
-      }
-    ).clearHalt;
-    if (typeof clearHalt !== 'function') {
-      resolve();
-      return;
-    }
-    clearHalt.call(ep, () => resolve());
-  });
-}
-
 /**
  * Skip the 0x3F protocol marker byte from a USB packet.
  */
@@ -206,7 +157,7 @@ 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. */
@@ -233,21 +184,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).
@@ -267,17 +226,36 @@ export default class NodeUsbTransport {
 
   configureProtocolV2(signedData: any) {
     this.messagesV2 = parseConfigure(signedData);
-    this.protocolV2Sessions.clear();
-    this.protocolV2ReadTimeouts.clear();
-    this.Log?.debug('[NodeUsbTransport] Protocol V2 schema configured');
+    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();
   }
 
   /**
@@ -352,6 +330,7 @@ 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);
@@ -366,9 +345,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> {
@@ -423,18 +484,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));
     }
 
     if (protocol === 'V2') {
@@ -471,7 +522,6 @@ export default class NodeUsbTransport {
   }
 
   cancel() {
-    this.Log?.debug('NodeUsbTransport cancel');
     this.cancelled = true;
   }
 
@@ -501,6 +551,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') ||
@@ -515,6 +571,11 @@ export default class NodeUsbTransport {
     );
   }
 
+  private isUsbTransferTimeout(error: unknown): boolean {
+    const message = this.getErrorMessage(error).toLowerCase();
+    return message.includes('timeout') || message.includes('timed_out');
+  }
+
   private getDeviceInterface(dev: usb.Device): usb.Interface {
     const { interfaces } = dev;
     if (!interfaces?.length) {
@@ -552,6 +613,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);
@@ -596,7 +661,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) {
@@ -629,7 +694,8 @@ export default class NodeUsbTransport {
   private async transferInWithRetry(
     path: string,
     openDev: OpenDevice,
-    length: number
+    length: number,
+    options?: { waitIndefinitelyOnTimeout?: boolean }
   ): Promise<Buffer> {
     let lastError: unknown;
     let currentDev = openDev;
@@ -638,23 +704,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;
-        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;
+        if (options?.waitIndefinitelyOnTimeout && this.isUsbTransferTimeout(error)) {
+          attempt -= 1;
+        } 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;
+          }
         }
       }
     }
@@ -680,15 +750,6 @@ export default class NodeUsbTransport {
       dev.open();
       dev.timeout = TRANSFER_TIMEOUT_MS;
 
-      await resetUsbDevice(dev);
-
-      try {
-        dev.open();
-      } catch {
-        // libusb keeps some devices open across reset; continue with the current handle.
-      }
-      dev.timeout = TRANSFER_TIMEOUT_MS;
-
       const iface = this.getDeviceInterface(dev);
 
       // On Linux, detach kernel driver if active
@@ -723,9 +784,7 @@ export default class NodeUsbTransport {
       epIn.timeout = TRANSFER_TIMEOUT_MS;
       epOut.timeout = TRANSFER_TIMEOUT_MS;
 
-      await clearEndpointHalt(epIn);
-      await clearEndpointHalt(epOut);
-      await this.drainStaleInput(epIn);
+      await this.drainStaleInput(path, epIn);
 
       this.openDevices.set(path, { device: dev, iface, epIn, epOut });
     } catch (err) {
@@ -738,14 +797,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;
         }
@@ -773,39 +832,35 @@ export default class NodeUsbTransport {
     path: string,
     expectedProtocol?: ProtocolType
   ): Promise<ProtocolType> {
+    if (expectedProtocol === 'V2') {
+      // Bootloader may not answer Ping after an update reboot. An explicit V2 hint means
+      // the protocol was confirmed earlier; establish the link and let the first command
+      // verify that USB initialization completed.
+      this.deviceProtocol.set(path, 'V2');
+      this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2 (expected)`);
+      return 'V2';
+    }
+
     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');
-        this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2 (expected)`);
-        return 'V2';
-      }
-      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 (await this.probeProtocolV1(path)) {
       this.deviceProtocol.set(path, 'V1');
-      this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V1`);
       return 'V1';
     }
 
     if (await this.probeProtocolV2(path)) {
       this.deviceProtocol.set(path, 'V2');
-      this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2`);
       return 'V2';
     }
 
@@ -814,11 +869,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);
@@ -878,8 +935,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;
     }
   }
@@ -898,74 +954,68 @@ 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
-      );
-      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 Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${name}`);
   }
 
   private async callProtocolV2(
@@ -974,42 +1024,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);
   }
 
   /**