@onekeyfe/hd-transport-usb 1.2.0-alpha.15 → 1.2.0-alpha.151

package/__tests__/protocol-v2-link.test.ts

@@ -62,6 +62,7 @@ const createHarness = () => {
   const path = '6136';
   const responseQueue: Buffer[] = [];
   const sentSeqs: number[] = [];
+  let cancelledTransferCount = 0;
   let writeError: Error | undefined;
   let holdNextRead:
     | {
@@ -71,29 +72,84 @@ const createHarness = () => {
       }
     | undefined;
 
+  const performInTransfer = (callback: (error?: Error, data?: Buffer) => void) => {
+    if (epIn.timeout === 50) {
+      callback(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
+      return;
+    }
+    if (holdNextRead) {
+      const pending = holdNextRead;
+      holdNextRead = undefined;
+      pending.callback = callback;
+      pending.markStarted();
+      return;
+    }
+    const response = responseQueue.shift();
+    if (!response) {
+      callback(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
+      return;
+    }
+    callback(undefined, response);
+  };
+
   const epIn = {
     direction: 'in',
     address: 0x81,
     timeout: 30_000,
     transfer: jest.fn((_length: number, callback: (error?: Error, data?: Buffer) => void) => {
-      if (epIn.timeout === 50) {
-        callback(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
-        return;
-      }
-      if (holdNextRead) {
-        const pending = holdNextRead;
-        holdNextRead = undefined;
-        pending.callback = callback;
-        pending.markStarted();
-        return;
-      }
-      const response = responseQueue.shift();
-      if (!response) {
-        callback(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
-        return;
-      }
-      callback(undefined, response);
+      performInTransfer(callback);
     }),
+    makeTransfer: jest.fn(
+      (
+        _timeout: number,
+        callback: (error: Error | undefined, data: Buffer, actualLength: number) => void
+      ) => {
+        let settled = false;
+        const finish = (error?: Error, data = Buffer.alloc(0)) => {
+          if (settled) return;
+          settled = true;
+          callback(error, data, data.length);
+        };
+        return {
+          submit: jest.fn((buffer: Buffer) => {
+            performInTransfer((error, data) => {
+              if (error) {
+                finish(error);
+                return;
+              }
+              data?.copy(buffer);
+              finish(undefined, buffer.subarray(0, data?.length ?? 0));
+            });
+          }),
+          cancel: jest.fn(() => {
+            cancelledTransferCount += 1;
+            finish(new Error('LIBUSB_TRANSFER_CANCELLED'));
+          }),
+        };
+      }
+    ),
+  };
+
+  const performOutTransfer = (data: Buffer, callback: (error?: Error) => void) => {
+    const seq = data[6];
+    sentSeqs.push(seq);
+    if (writeError) {
+      const error = writeError;
+      writeError = undefined;
+      callback(error);
+      return;
+    }
+    responseQueue.push(
+      Buffer.from(
+        ProtocolV2.encodeFrame(
+          schemas,
+          'Success',
+          { message: 'ok' },
+          { router: PROTOCOL_V2_CHANNEL_USB, seq }
+        )
+      )
+    );
+    callback();
   };
 
   const epOut = {
@@ -101,33 +157,40 @@ const createHarness = () => {
     address: 0x01,
     timeout: 30_000,
     transfer: jest.fn((data: Buffer, callback: (error?: Error) => void) => {
-      const seq = data[6];
-      sentSeqs.push(seq);
-      if (writeError) {
-        const error = writeError;
-        writeError = undefined;
-        callback(error);
-        return;
-      }
-      responseQueue.push(
-        Buffer.from(
-          ProtocolV2.encodeFrame(
-            schemas,
-            'Success',
-            { message: 'ok' },
-            { router: PROTOCOL_V2_CHANNEL_USB, seq }
-          )
-        )
-      );
-      callback();
+      performOutTransfer(data, callback);
     }),
+    makeTransfer: jest.fn(
+      (
+        _timeout: number,
+        callback: (error: Error | undefined, data: Buffer, actualLength: number) => void
+      ) => {
+        let settled = false;
+        const finish = (error: Error | undefined, data: Buffer) => {
+          if (settled) return;
+          settled = true;
+          callback(error, data, data.length);
+        };
+        return {
+          submit: jest.fn((data: Buffer) => {
+            performOutTransfer(data, error => finish(error, data));
+          }),
+          cancel: jest.fn(() => {
+            cancelledTransferCount += 1;
+            finish(new Error('LIBUSB_TRANSFER_CANCELLED'), Buffer.alloc(0));
+          }),
+        };
+      }
+    ),
   };
 
   const iface = {
     descriptor: { bInterfaceClass: 0xff, bInterfaceNumber: 0 },
     endpoints: [epIn, epOut],
     claim: jest.fn(),
-    release: jest.fn((callback: () => void) => callback()),
+    release: jest.fn((closeEndpointsOrCallback: boolean | (() => void), callback?: () => void) => {
+      if (typeof closeEndpointsOrCallback === 'function') closeEndpointsOrCallback();
+      else callback?.();
+    }),
     isKernelDriverActive: jest.fn(() => false),
     detachKernelDriver: jest.fn(),
   };
@@ -164,6 +227,7 @@ const createHarness = () => {
     epIn,
     epOut,
     sentSeqs,
+    getCancelledTransferCount: () => cancelledTransferCount,
     async acquire() {
       await transport.enumerate();
       await transport.acquire({ path, expectedProtocol: 'V2' });
@@ -189,7 +253,108 @@ const createHarness = () => {
 };
 
 describe('NodeUsbTransport Protocol V2 link lifecycle', () => {
-  test('keeps seq across probe, call and reacquire', async () => {
+  test('falls back to Protocol V2 when a cached V1 hint is stale', async () => {
+    const transport = new NodeUsbTransport() as any;
+    const events: string[] = [];
+    transport.probeProtocolV1 = jest.fn().mockImplementation(() => {
+      events.push('probe-v1');
+      return Promise.resolve(false);
+    });
+    transport.resetConnectionAfterProbe = jest.fn().mockImplementation(() => {
+      events.push('reset');
+      return Promise.resolve();
+    });
+    transport.probeProtocolV2 = jest.fn().mockImplementation(() => {
+      events.push('probe-v2');
+      return Promise.resolve(true);
+    });
+
+    await expect(transport.detectProtocol('pro-usb', undefined, 'V1')).resolves.toBe('V2');
+
+    expect(events).toEqual(['probe-v1', 'reset', 'probe-v2']);
+    expect(transport.getProtocolType('pro-usb')).toBe('V2');
+  });
+
+  test('keeps active links when the Protocol V2 schema is configured repeatedly', () => {
+    const transport = new NodeUsbTransport() as any;
+    transport.invalidateAllProtocolV2UsbLinks = jest.fn().mockResolvedValue(undefined);
+    const schemaSource = JSON.stringify(protocolV2Schema);
+
+    transport.configureProtocolV2(schemaSource);
+    transport.configureProtocolV2(schemaSource);
+
+    expect(transport.invalidateAllProtocolV2UsbLinks).not.toHaveBeenCalled();
+  });
+
+  test('does not retry a native transfer cancelled by probe cleanup', () => {
+    const { transport } = createHarness();
+
+    expect((transport as any).isRetryableError(new Error('LIBUSB_TRANSFER_CANCELLED'))).toBe(false);
+  });
+
+  test('cancels pending native transfers before closing a timed-out protocol probe', async () => {
+    const harness = createHarness();
+    const { transport, path } = harness;
+    await harness.acquire();
+    const cancelActiveTransfers = jest.spyOn(transport as any, 'cancelActiveTransfers');
+    const closeOpenDevice = jest.spyOn(transport as any, 'closeOpenDevice');
+
+    await (transport as any).resetConnectionAfterProbe(path);
+
+    expect(cancelActiveTransfers).toHaveBeenCalledWith(path);
+    expect(closeOpenDevice).toHaveBeenCalledWith(path);
+    expect(cancelActiveTransfers.mock.invocationCallOrder[0]).toBeLessThan(
+      closeOpenDevice.mock.invocationCallOrder[0]
+    );
+  });
+
+  test('releases the USB interface when protocol detection rejects acquire', async () => {
+    const harness = createHarness();
+    const { transport, path, device, iface } = harness;
+    await transport.enumerate();
+    device.close.mockClear();
+    iface.release.mockClear();
+    jest
+      .spyOn(transport as any, 'detectProtocol')
+      .mockRejectedValueOnce(new Error('terminal protocol probe failure'));
+
+    await expect(transport.acquire({ path })).rejects.toMatchObject({
+      errorCode: expect.any(Number),
+    });
+
+    expect(iface.release).toHaveBeenCalledTimes(1);
+    expect(device.close).toHaveBeenCalledTimes(1);
+    expect((transport as any).openDevices.has(path)).toBe(false);
+  });
+
+  test('stop releases an acquired USB interface even before a Protocol V2 call', async () => {
+    const harness = createHarness();
+    const { transport, path, device, iface } = harness;
+    await transport.enumerate();
+    await transport.acquire({ path, expectedProtocol: 'V2' });
+    device.close.mockClear();
+    iface.release.mockClear();
+
+    await transport.stop();
+
+    expect(iface.release).toHaveBeenCalledTimes(1);
+    expect(device.close).toHaveBeenCalledTimes(1);
+    expect(transport.getProtocolType(path)).toBeUndefined();
+  });
+
+  test('actively probes explicit Protocol V2 during bootloader reconnect', async () => {
+    const harness = createHarness();
+    const { transport, path, epOut } = harness;
+
+    await transport.enumerate();
+    await transport.acquire({ path, expectedProtocol: 'V2' });
+
+    expect(epOut.makeTransfer).toHaveBeenCalledTimes(1);
+    expect(transport.getProtocolType(path)).toBe('V2');
+    await transport.release(path);
+  });
+
+  test('keeps seq across calls and actively probed reacquire', async () => {
     const harness = createHarness();
     const { transport, path, sentSeqs } = harness;
 
@@ -207,14 +372,14 @@ describe('NodeUsbTransport Protocol V2 link lifecycle', () => {
     const harness = createHarness();
     const { transport, path, epOut } = harness;
     await harness.acquire();
-    epOut.transfer.mockClear();
+    epOut.makeTransfer.mockClear();
     harness.failNextWrite(new Error('LIBUSB_ERROR_IO'));
 
     await expect(transport.call(path, 'Ping', { message: 'write-failure' })).rejects.toThrow(
       'LIBUSB_ERROR_IO'
     );
 
-    expect(epOut.transfer).toHaveBeenCalledTimes(1);
+    expect(epOut.makeTransfer).toHaveBeenCalledTimes(1);
   });
 
   test('rejects a pending read when release invalidates the link', async () => {
@@ -241,6 +406,20 @@ describe('NodeUsbTransport Protocol V2 link lifecycle', () => {
     expect(settled).not.toBe('still pending');
   });
 
+  test('stop cancels an in-flight native USB transfer before releasing the interface', async () => {
+    const harness = createHarness();
+    const { transport, path } = harness;
+    await harness.acquire();
+    const pendingRead = harness.holdRead();
+
+    const call = transport.call(path, 'Ping', { message: 'pending' }, { timeoutMs: 5000 });
+    await pendingRead.started;
+    await transport.stop();
+
+    await expect(call).rejects.toThrow();
+    expect(harness.getCancelledTransferCount()).toBe(1);
+  });
+
   test('keeps the cursor after a response timeout rebuilds the USB connection', async () => {
     const harness = createHarness();
     const { transport, path, sentSeqs } = harness;

package/dist/index.d.ts

@@ -2,48 +2,119 @@ import * as transport from '@onekeyfe/hd-transport';
 import transport__default, { ProtocolV2UsbTransportBase, OneKeyDeviceInfo, AcquireInput, TransportCallOptions, ProtocolV2Schemas, ProtocolV2CallContext, ProtocolType } from '@onekeyfe/hd-transport';
 import EventEmitter from 'events';
 
+/**
+ * Node.js USB Transport — complete transport implementation using libusb.
+ *
+ * Unlike the old UsbPlugin (which was a LowlevelTransportSharedPlugin piped
+ * through LowlevelTransport), this class is a standalone transport that handles
+ * both protocol encoding/decoding and USB I/O directly.
+ *
+ * Modeled after WebUsbTransport.
+ */
 declare class NodeUsbTransport extends ProtocolV2UsbTransportBase<string> {
     messages: ReturnType<typeof transport__default.parseConfigure> | undefined;
+    /** Protobuf schema for Protocol V2 transports. */
     messagesV2: ReturnType<typeof transport__default.parseConfigure> | undefined;
+    private protocolV2SchemaSource;
     name: string;
     version: string;
     configured: boolean;
     isOutdated: boolean;
     Log?: any;
     emitter?: EventEmitter;
+    /** serial → bus id, built during enumerate */
     private serialToBusId;
+    /** path → opened device state */
     private openDevices;
+    /** Per-path protocol type detected by active wire-level probe. */
     private deviceProtocol;
+    /** per-path reconnect lock to prevent concurrent reconnects */
     private reconnectLocks;
+    /**
+     * 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;
+    /** set to true when cancel() is called; checked by retry loops */
     private cancelled;
     constructor();
+    /**
+     * Initialize transport.
+     * Signature matches the Transport.init interface (logger, emitter).
+     */
     init(logger: any, emitter?: EventEmitter): Promise<string>;
     configure(signedData: any): Promise<void>;
     configureProtocolV2(signedData: any): void;
     listen(): void;
-    stop(): void;
+    stop(): Promise<void>;
+    /**
+     * Low-level post (send only, no response). Not used by NodeUsbTransport
+     * since call() handles the full send+receive cycle, but required by the Transport interface.
+     */
     post(path: string, name: string, data: Record<string, unknown>): Promise<void>;
+    /**
+     * Low-level read (receive only). Not used by NodeUsbTransport
+     * since call() handles the full send+receive cycle, but required by the Transport interface.
+     */
     read(path: string): Promise<{
         message: {
             [key: string]: any;
         };
         type: string;
     }>;
+    /**
+     * Enumerate connected OneKey USB devices.
+     * Opens each device briefly to read its serial number (used as `path`),
+     * then closes it. acquire() re-opens from a fresh getDeviceList().
+     */
     enumerate(): Promise<OneKeyDeviceInfo[]>;
+    /**
+     * Acquire device — open USB device, claim interface, return path (string).
+     */
     acquire(input: AcquireInput): Promise<string>;
+    /**
+     * Release device — release interface and close.
+     */
     release(path: string, _onclose?: boolean): Promise<void>;
+    private cancelActiveTransfers;
+    private createTrackedTransfer;
+    private transferInOnce;
+    private transferOutOnce;
     private closeOpenDevice;
+    /**
+     * Call device method — encode protobuf, send packets, receive response.
+     * This is the core method that replaces LowlevelTransport's call + UsbPlugin's send/receive.
+     */
     call(path: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<transport.MessageFromOneKey>;
     private callProtocolV1;
     cancel(): void;
+    /**
+     * Get the current open device for a path, re-resolving from the map
+     * so callers always use a fresh reference after reconnect.
+     */
     private getOpenDevice;
     private getErrorMessage;
     private isRetryableError;
     private isUsbTransferTimeout;
     private getDeviceInterface;
+    /**
+     * Reconnect device before retrying a failed transfer (aligned with WebUsbTransport).
+     * Uses per-path lock to prevent concurrent reconnects to the same device.
+     */
     private reconnectForRetry;
+    /**
+     * Send all encoded chunks to the device with retry.
+     * If a chunk fails and triggers reconnect, the entire sequence restarts
+     * from chunk 0 because the device resets protocol state on reconnect.
+     */
     private sendAllChunksWithRetry;
+    /**
+     * USB IN transfer with retry and reconnect (aligned with WebUsbTransport).
+     */
     private transferInWithRetry;
+    /**
+     * Open a USB device by path (serial number), claim interface, cache endpoints.
+     */
     private openDevice;
     private drainStaleInput;
     private createProtocolMismatchError;
@@ -61,6 +132,10 @@ declare class NodeUsbTransport extends ProtocolV2UsbTransportBase<string> {
     protected onProtocolV2UsbLinkInvalidated(path: string, reason: string): void;
     protected createProtocolV2UsbTimeoutError(name: string, timeoutMs: number): Error;
     private callProtocolV2;
+    /**
+     * Receive a complete protobuf response from the device.
+     * Reads 64-byte packets, strips 0x3F marker, reassembles into hex string.
+     */
     private receiveData;
     getProtocolType(path: string): ProtocolType | undefined;
 }

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -59,14 +59,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const HIGH_VOLUME_CALLS = new Set(['FileWrite', 'FilesystemFileWrite', 'EmmcFileWrite']);
-function shouldSuppressHighVolumeCallLog(name) {
-    return HIGH_VOLUME_CALLS.has(name);
-}
-function createTransportCallLog(name, protocol) {
-    return { name, protocol };
-}
-
 const { parseConfigure, ProtocolV1, check } = transport__default["default"];
 const PACKET_SIZE = transport.PROTOCOL_V1_USB_PACKET_SIZE;
 const REPORT_ID = transport.PROTOCOL_V1_REPORT_ID;
@@ -140,26 +132,6 @@ function readSerialNumber(dev, openDevices) {
         }
     });
 }
-function transferInOnce(ep, length) {
-    return new Promise((resolve, reject) => {
-        ep.transfer(length, (err, data) => {
-            if (err)
-                return reject(err);
-            if (!data || data.length === 0)
-                return reject(new Error('Empty USB transfer'));
-            resolve(data);
-        });
-    });
-}
-function transferOutOnce(ep, data) {
-    return new Promise((resolve, reject) => {
-        ep.transfer(data, (err) => {
-            if (err)
-                return reject(err);
-            resolve();
-        });
-    });
-}
 function skipReportByte(packet) {
     if (packet[0] === REPORT_ID) {
         return packet.subarray(1);
@@ -184,6 +156,7 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
         this.openDevices = new Map();
         this.deviceProtocol = new Map();
         this.reconnectLocks = new Map();
+        this.activeTransfers = new Map();
         this.cancelled = false;
     }
     init(logger, emitter) {
@@ -198,19 +171,49 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
         return Promise.resolve();
     }
     configureProtocolV2(signedData) {
+        var _a;
+        const schemaSource = typeof signedData === 'string'
+            ? signedData
+            : (_a = JSON.stringify(signedData)) !== null && _a !== void 0 ? _a : String(signedData);
+        if (schemaSource === this.protocolV2SchemaSource)
+            return;
+        const hadProtocolV2Schema = this.protocolV2SchemaSource !== undefined;
         this.messagesV2 = parseConfigure(signedData);
+        this.protocolV2SchemaSource = schemaSource;
+        if (!hadProtocolV2Schema)
+            return;
         this.invalidateAllProtocolV2UsbLinks('Protocol V2 schema reconfigured').catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] schema link cleanup failed:', error); });
     }
     listen() {
     }
     stop() {
-        this.disposeProtocolV2UsbLinks('Node USB transport stopped').catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] stop link cleanup failed:', error); });
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cancelled = true;
+            yield this.cancelActiveTransfers();
+            try {
+                yield this.disposeProtocolV2UsbLinks('Node USB transport stopped');
+            }
+            catch (error) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] stop link cleanup failed:', error);
+            }
+            yield Promise.allSettled(this.reconnectLocks.values());
+            yield this.cancelActiveTransfers();
+            yield Promise.all(Array.from(this.openDevices.keys(), path => this.closeOpenDevice(path)));
+            this.reconnectLocks.clear();
+            this.deviceProtocol.clear();
+            this.serialToBusId.clear();
+        });
     }
     post(path, name, data) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
+            if (this.deviceProtocol.get(path) === 'V2') {
+                yield this.sendProtocolV2UsbFlowControl(path, name, data);
+                return;
+            }
             const encodeBuffers = ProtocolV1.encodeMessageChunks(this.messages, name, data);
             yield this.sendAllChunksWithRetry(path, encodeBuffers);
         });
@@ -254,7 +257,7 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
         });
     }
     acquire(input) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             this.cancelled = false;
             const path = (_a = input.path) !== null && _a !== void 0 ? _a : '';
@@ -265,22 +268,104 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 yield this.rotateProtocolV2UsbGeneration(path, 'Node USB transport acquired');
                 yield this.closeOpenDevice(path);
                 yield this.openDevice(path);
-                yield this.detectProtocol(path, input.expectedProtocol);
+                const descriptor = this.getOpenDevice(path).device.deviceDescriptor;
+                const protocolHint = input.expectedProtocol
+                    ? undefined
+                    : (_b = input.protocolHint) !== null && _b !== void 0 ? _b : hdShared.inferProtocolHintFromUsbId(descriptor.idVendor, descriptor.idProduct);
+                yield this.detectProtocol(path, input.expectedProtocol, protocolHint);
                 return path;
             }
             catch (error) {
-                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('NodeUsbTransport acquire error: ', error);
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, (_c = error.message) !== null && _c !== void 0 ? _c : String(error));
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('NodeUsbTransport acquire error: ', error);
+                try {
+                    yield this.release(path);
+                }
+                catch (cleanupError) {
+                    (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('NodeUsbTransport acquire cleanup error: ', cleanupError);
+                }
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, (_e = error.message) !== null && _e !== void 0 ? _e : String(error));
             }
         });
     }
     release(path, _onclose) {
         return __awaiter(this, void 0, void 0, function* () {
+            yield this.cancelActiveTransfers(path);
             yield this.invalidateProtocolV2UsbLink(path, 'Node USB transport released');
             yield this.closeOpenDevice(path);
             this.deviceProtocol.delete(path);
         });
     }
+    cancelActiveTransfers(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transfers = Array.from(this.activeTransfers.entries()).filter(([, active]) => path === undefined || active.path === path);
+            transfers.forEach(([transfer]) => {
+                try {
+                    transfer.cancel();
+                }
+                catch (_a) {
+                }
+            });
+            yield Promise.allSettled(transfers.map(([, active]) => active.settled));
+        });
+    }
+    createTrackedTransfer(path, endpoint, callback) {
+        let resolveSettled = () => undefined;
+        const settled = new Promise(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;
+    }
+    transferInOnce(path, ep, length) {
+        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 === null || active === void 0 ? void 0 : active.resolveSettled();
+                reject(error);
+            }
+        });
+    }
+    transferOutOnce(path, ep, data) {
+        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 === null || active === void 0 ? void 0 : active.resolveSettled();
+                reject(error);
+            }
+        });
+    }
     closeOpenDevice(path) {
         return __awaiter(this, void 0, void 0, function* () {
             const openDev = this.openDevices.get(path);
@@ -309,7 +394,6 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
         });
     }
     call(path, name, data, options) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.cancelled = false;
             if (!this.messages) {
@@ -322,9 +406,6 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${path}`);
             }
-            if (!shouldSuppressHighVolumeCallLog(name)) {
-                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('transport call', createTransportCallLog(name, protocol));
-            }
             if (protocol === 'V2') {
                 return this.callProtocolV2(path, name, data, options);
             }
@@ -370,6 +451,9 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
     }
     isRetryableError(error) {
         const message = this.getErrorMessage(error).toLowerCase();
+        if (message.includes('cancelled') || message.includes('canceled')) {
+            return false;
+        }
         return (message.includes('libusb') ||
             message.includes('transfer') ||
             message.includes('disconnected') ||
@@ -438,7 +522,7 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
                         const packet = new Uint8Array(PACKET_SIZE);
                         packet[0] = REPORT_ID;
                         packet.set(new Uint8Array(buffer), 1);
-                        yield transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(packet));
+                        yield this.transferOutOnce(path, this.getOpenDevice(path).epOut, Buffer.from(packet));
                     }
                     return;
                 }
@@ -471,7 +555,7 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
                 }
                 try {
-                    return yield transferInOnce(currentDev.epIn, length);
+                    return yield this.transferInOnce(path, currentDev.epIn, length);
                 }
                 catch (error) {
                     lastError = error;
@@ -530,7 +614,7 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
                 }
                 epIn.timeout = TRANSFER_TIMEOUT_MS;
                 epOut.timeout = TRANSFER_TIMEOUT_MS;
-                yield this.drainStaleInput(epIn);
+                yield this.drainStaleInput(path, epIn);
                 this.openDevices.set(path, { device: dev, iface, epIn, epOut });
             }
             catch (err) {
@@ -543,14 +627,14 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
             }
         });
     }
-    drainStaleInput(epIn) {
+    drainStaleInput(path, epIn) {
         return __awaiter(this, void 0, void 0, function* () {
             const originalTimeout = epIn.timeout;
             epIn.timeout = 50;
             try {
                 for (let index = 0; index < 16; index += 1) {
                     try {
-                        yield transferInOnce(epIn, PACKET_SIZE);
+                        yield this.transferInOnce(path, epIn, PACKET_SIZE);
                     }
                     catch (_a) {
                         break;
@@ -568,33 +652,34 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
     createProtocolDetectionError() {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Unable to detect USB protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping');
     }
-    detectProtocol(path, expectedProtocol) {
+    detectProtocol(path, expectedProtocol, protocolHint) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (expectedProtocol === 'V1') {
-                if (yield this.probeProtocolV1(path)) {
-                    this.deviceProtocol.set(path, 'V1');
-                    return 'V1';
-                }
-                throw this.createProtocolMismatchError(expectedProtocol);
-            }
             if (expectedProtocol === 'V2') {
                 if (yield this.probeProtocolV2(path)) {
                     this.deviceProtocol.set(path, 'V2');
+                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2 (expected)`);
                     return 'V2';
                 }
                 throw this.createProtocolMismatchError(expectedProtocol);
             }
-            if (this.deviceProtocol.get(path) === 'V2' && (yield this.probeProtocolV2(path))) {
-                this.deviceProtocol.set(path, 'V2');
-                return 'V2';
-            }
-            if (yield this.probeProtocolV1(path)) {
-                this.deviceProtocol.set(path, 'V1');
-                return 'V1';
+            if (expectedProtocol === 'V1') {
+                if (yield this.probeProtocolV1(path)) {
+                    this.deviceProtocol.set(path, 'V1');
+                    return 'V1';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
             }
-            if (yield this.probeProtocolV2(path)) {
-                this.deviceProtocol.set(path, 'V2');
-                return 'V2';
+            const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(path) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
+            for (const [index, protocol] of probeOrder.entries()) {
+                if (index > 0) {
+                    yield this.resetConnectionAfterProbe(path);
+                }
+                const detected = protocol === 'V1' ? yield this.probeProtocolV1(path) : yield this.probeProtocolV2(path);
+                if (detected) {
+                    this.deviceProtocol.set(path, protocol);
+                    return protocol;
+                }
             }
             this.deviceProtocol.delete(path);
             throw this.createProtocolDetectionError();
@@ -605,6 +690,7 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.rotateProtocolV2UsbGeneration(path, 'Node USB protocol probe reset');
             try {
+                yield this.cancelActiveTransfers(path);
                 yield this.closeOpenDevice(path);
             }
             catch (error) {
@@ -696,7 +782,7 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
             if (this.cancelled) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
             }
-            yield transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(frame));
+            yield this.transferOutOnce(path, this.getOpenDevice(path).epOut, Buffer.from(frame));
         });
     }
     readProtocolV2UsbPacket(path, _context) {
@@ -706,7 +792,7 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
                 }
                 try {
-                    const packet = yield transferInOnce(this.getOpenDevice(path).epIn, transport.PROTOCOL_V2_FRAME_MAX_BYTES);
+                    const packet = yield this.transferInOnce(path, this.getOpenDevice(path).epIn, transport.PROTOCOL_V2_FRAME_MAX_BYTES);
                     return new Uint8Array(packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength));
                 }
                 catch (error) {
@@ -719,6 +805,7 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
     }
     resetProtocolV2UsbNativeLink(path, _reason) {
         return __awaiter(this, void 0, void 0, function* () {
+            yield this.cancelActiveTransfers(path);
             yield this.closeOpenDevice(path);
         });
     }
@@ -728,7 +815,7 @@ class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
         (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] Protocol V2 link invalidated: ${path}`, reason);
     }
     createProtocolV2UsbTimeoutError(name, timeoutMs) {
-        return new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${name}`);
+        return new transport.ProtocolV2LinkError('response-timeout', `Protocol V2 response timeout after ${timeoutMs}ms for ${name}`);
     }
     callProtocolV2(path, name, data, options) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/transportLog.d.ts

@@ -1,7 +1,2 @@
-import type { ProtocolType } from '@onekeyfe/hd-transport';
-export declare function shouldSuppressHighVolumeCallLog(name: string): boolean;
-export declare function createTransportCallLog(name: string, protocol: ProtocolType): {
-    name: string;
-    protocol: ProtocolType;
-};
+export { createTransportCallLog, shouldSuppressHighVolumeCallLog } from '@onekeyfe/hd-transport';
 //# sourceMappingURL=transportLog.d.ts.map

package/dist/transportLog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transportLog.d.ts","sourceRoot":"","sources":["../src/transportLog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAI3D,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,WAE3D;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY;;;EAE1E"}
+{"version":3,"file":"transportLog.d.ts","sourceRoot":"","sources":["../src/transportLog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAC"}

package/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: '../../jest.config.js',
+  testEnvironment: 'node',
+  modulePathIgnorePatterns: ['node_modules', '<rootDir>/dist'],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-usb",
-  "version": "1.2.0-alpha.15",
+  "version": "1.2.0-alpha.151",
   "description": "OneKey hardware wallet direct USB transport plugin (libusb)",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -16,14 +16,15 @@
   "scripts": {
     "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
     "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "test": "jest",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.15",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.15",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.151",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.151",
     "bytebuffer": "^5.0.1",
     "usb": "^2.14.0"
   },
-  "gitHead": "06dd8f9cba892bb66242e5a51038a7103fb05f09"
+  "gitHead": "d1fa81c92deb1bfa3903e3963a82edd6384d568a"
 }

package/src/index.ts

@@ -7,12 +7,17 @@ import transport, {
   PROTOCOL_V1_USB_PACKET_SIZE,
   PROTOCOL_V2_CHANNEL_USB,
   PROTOCOL_V2_FRAME_MAX_BYTES,
+  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 {
+  ERRORS,
+  HardwareErrorCode,
+  ONEKEY_WEBUSB_FILTER,
+  inferProtocolHintFromUsbId,
+  wait,
+} from '@onekeyfe/hd-shared';
 
 import type EventEmitter from 'events';
 import type {
@@ -131,31 +136,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.
  */
@@ -188,6 +168,8 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
   /** Protobuf schema for Protocol V2 transports. */
   messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
 
+  private protocolV2SchemaSource: string | undefined;
+
   name = 'NodeUsbTransport';
 
   version = '';
@@ -212,6 +194,15 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
   /** 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;
 
@@ -241,7 +232,17 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
   }
 
   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.protocolV2SchemaSource = schemaSource;
+    if (!hadProtocolV2Schema) return;
+
     this.invalidateAllProtocolV2UsbLinks('Protocol V2 schema reconfigured').catch(error =>
       this.Log?.debug('[NodeUsbTransport] schema link cleanup failed:', error)
     );
@@ -251,10 +252,27 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
     // empty — could add hotplug events via usb.on('attach'/'detach')
   }
 
-  stop() {
-    this.disposeProtocolV2UsbLinks('Node USB transport stopped').catch(error =>
-      this.Log?.debug('[NodeUsbTransport] stop link cleanup failed:', error)
-    );
+  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();
   }
 
   /**
@@ -265,6 +283,10 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
     if (!this.messages) {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
+    if (this.deviceProtocol.get(path) === 'V2') {
+      await this.sendProtocolV2UsbFlowControl(path, name, data);
+      return;
+    }
     const encodeBuffers = ProtocolV1.encodeMessageChunks(this.messages, name, data);
     await this.sendAllChunksWithRetry(path, encodeBuffers);
   }
@@ -332,10 +354,20 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
       await this.rotateProtocolV2UsbGeneration(path, 'Node USB transport acquired');
       await this.closeOpenDevice(path);
       await this.openDevice(path);
-      await this.detectProtocol(path, input.expectedProtocol);
+      const descriptor = this.getOpenDevice(path).device.deviceDescriptor;
+      const protocolHint = input.expectedProtocol
+        ? undefined
+        : input.protocolHint ??
+          inferProtocolHintFromUsbId(descriptor.idVendor, descriptor.idProduct);
+      await this.detectProtocol(path, input.expectedProtocol, 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));
     }
   }
@@ -344,11 +376,93 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
    * 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);
   }
 
+  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> {
     const openDev = this.openDevices.get(path);
     if (!openDev) return;
@@ -401,10 +515,6 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
         `Device protocol has not been detected for ${path}`
       );
     }
-    if (!shouldSuppressHighVolumeCallLog(name)) {
-      this.Log?.debug('transport call', createTransportCallLog(name, protocol));
-    }
-
     if (protocol === 'V2') {
       return this.callProtocolV2(path, name, data, options);
     }
@@ -468,6 +578,12 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
 
   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') ||
@@ -572,7 +688,7 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
           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) {
@@ -615,7 +731,7 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
         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)) {
@@ -695,7 +811,7 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
       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) {
@@ -708,14 +824,14 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
     }
   }
 
-  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;
         }
@@ -741,37 +857,39 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
 
   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');
-        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');
-      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');
-      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');
-      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);
@@ -782,6 +900,10 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
     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);
@@ -882,7 +1004,7 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
     if (this.cancelled) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
     }
-    await transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(frame));
+    await this.transferOutOnce(path, this.getOpenDevice(path).epOut, Buffer.from(frame));
   }
 
   protected async readProtocolV2UsbPacket(
@@ -894,7 +1016,8 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
         throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
       }
       try {
-        const packet = await transferInOnce(
+        const packet = await this.transferInOnce(
+          path,
           this.getOpenDevice(path).epIn,
           PROTOCOL_V2_FRAME_MAX_BYTES
         );
@@ -910,6 +1033,7 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
   }
 
   protected async resetProtocolV2UsbNativeLink(path: string, _reason: string): Promise<void> {
+    await this.cancelActiveTransfers(path);
     await this.closeOpenDevice(path);
   }
 
@@ -919,7 +1043,10 @@ export default class NodeUsbTransport extends ProtocolV2UsbTransportBase<string>
   }
 
   protected createProtocolV2UsbTimeoutError(name: string, timeoutMs: number): Error {
-    return new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${name}`);
+    return new ProtocolV2LinkError(
+      'response-timeout',
+      `Protocol V2 response timeout after ${timeoutMs}ms for ${name}`
+    );
   }
 
   private async callProtocolV2(

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';