@onekeyfe/hd-transport-usb 1.2.0-alpha.1 → 1.2.0-alpha.11

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

@@ -0,0 +1,260 @@
+import transportPackage, { PROTOCOL_V2_CHANNEL_USB, ProtocolV2 } from '@onekeyfe/hd-transport';
+
+import NodeUsbTransport from '../src';
+
+let mockUsbDevices: any[] = [];
+
+jest.mock('usb', () => ({
+  getDeviceList: jest.fn(() => mockUsbDevices),
+}));
+
+const { parseConfigure } = transportPackage;
+
+const protocolV1Schema = {
+  nested: {
+    Initialize: { fields: {} },
+    Success: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Initialize: 1,
+        MessageType_Success: 2,
+      },
+    },
+  },
+};
+
+const protocolV2Schema = {
+  nested: {
+    Ping: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    Success: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+      },
+    },
+  },
+};
+
+const schemas = {
+  protocolV1: parseConfigure(protocolV1Schema),
+  protocolV2: parseConfigure(protocolV2Schema),
+};
+
+type PendingRead = {
+  started: Promise<void>;
+  fail: (error?: Error) => void;
+};
+
+const createHarness = () => {
+  const path = '6136';
+  const responseQueue: Buffer[] = [];
+  const sentSeqs: number[] = [];
+  let writeError: Error | undefined;
+  let holdNextRead:
+    | {
+        markStarted: () => void;
+        started: Promise<void>;
+        callback?: (error?: Error, data?: Buffer) => void;
+      }
+    | undefined;
+
+  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);
+    }),
+  };
+
+  const epOut = {
+    direction: 'out',
+    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();
+    }),
+  };
+
+  const iface = {
+    descriptor: { bInterfaceClass: 0xff, bInterfaceNumber: 0 },
+    endpoints: [epIn, epOut],
+    claim: jest.fn(),
+    release: jest.fn((callback: () => void) => callback()),
+    isKernelDriverActive: jest.fn(() => false),
+    detachKernelDriver: jest.fn(),
+  };
+
+  const device = {
+    busNumber: 1,
+    deviceAddress: 2,
+    timeout: 30_000,
+    deviceDescriptor: {
+      idVendor: 0x1209,
+      idProduct: 0x4f4a,
+      iSerialNumber: 1,
+    },
+    interfaces: [iface],
+    open: jest.fn(),
+    close: jest.fn(),
+    getStringDescriptor: jest.fn(
+      (_index: number, callback: (error?: Error, value?: string) => void) =>
+        callback(undefined, path)
+    ),
+  };
+
+  mockUsbDevices = [device];
+  const transport = new NodeUsbTransport();
+  transport.init({ debug: jest.fn(), error: jest.fn() });
+  transport.configure(protocolV1Schema);
+  transport.configureProtocolV2(protocolV2Schema);
+
+  return {
+    transport,
+    path,
+    device,
+    iface,
+    epIn,
+    epOut,
+    sentSeqs,
+    async acquire() {
+      await transport.enumerate();
+      await transport.acquire({ path, expectedProtocol: 'V2' });
+    },
+    failNextWrite(error: Error) {
+      writeError = error;
+    },
+    holdRead(): PendingRead {
+      let markStarted: () => void = () => undefined;
+      const started = new Promise<void>(resolve => {
+        markStarted = resolve;
+      });
+      const pending = { markStarted, started, callback: undefined };
+      holdNextRead = pending;
+      return {
+        started,
+        fail(error = new Error('read released after test')) {
+          pending.callback?.(error);
+        },
+      };
+    },
+  };
+};
+
+describe('NodeUsbTransport Protocol V2 link lifecycle', () => {
+  test('keeps seq across probe, call and reacquire', async () => {
+    const harness = createHarness();
+    const { transport, path, sentSeqs } = harness;
+
+    await harness.acquire();
+    await transport.call(path, 'Ping', { message: 'first' });
+    await transport.release(path);
+    await harness.acquire();
+    await transport.call(path, 'Ping', { message: 'second' });
+
+    expect(sentSeqs).toEqual([1, 2, 3, 4]);
+    await transport.release(path);
+  });
+
+  test('does not resend a Protocol V2 frame after transferOut fails', async () => {
+    const harness = createHarness();
+    const { transport, path, epOut } = harness;
+    await harness.acquire();
+    epOut.transfer.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);
+  });
+
+  test('rejects a pending read when release invalidates the link', 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 });
+    const outcome = call.then(
+      () => 'resolved',
+      error => error.message
+    );
+    await pendingRead.started;
+    await transport.release(path);
+    const settled = await Promise.race([
+      outcome,
+      new Promise<string>(resolve => {
+        setTimeout(() => resolve('still pending'), 50);
+      }),
+    ]);
+    pendingRead.fail();
+
+    expect(settled).not.toBe('still pending');
+  });
+
+  test('keeps the cursor after a response timeout rebuilds the USB connection', async () => {
+    const harness = createHarness();
+    const { transport, path, sentSeqs } = harness;
+    await harness.acquire();
+    const pendingRead = harness.holdRead();
+
+    await expect(
+      transport.call(path, 'Ping', { message: 'timeout' }, { timeoutMs: 20 })
+    ).rejects.toThrow('20ms');
+    pendingRead.fail();
+    await harness.acquire();
+    await transport.call(path, 'Ping', { message: 'after-timeout' });
+
+    expect(sentSeqs).toEqual([1, 2, 3, 4]);
+    await transport.release(path);
+  });
+});

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as transport from '@onekeyfe/hd-transport';
-import transport__default, { OneKeyDeviceInfo, AcquireInput, TransportCallOptions, ProtocolType } from '@onekeyfe/hd-transport';
+import transport__default, { ProtocolV2UsbTransportBase, OneKeyDeviceInfo, AcquireInput, TransportCallOptions, ProtocolV2Schemas, ProtocolV2CallContext, ProtocolType } from '@onekeyfe/hd-transport';
 import EventEmitter from 'events';
 
-declare class NodeUsbTransport {
+declare class NodeUsbTransport extends ProtocolV2UsbTransportBase<string> {
     messages: ReturnType<typeof transport__default.parseConfigure> | undefined;
     messagesV2: ReturnType<typeof transport__default.parseConfigure> | undefined;
     name: string;
@@ -14,11 +14,9 @@ declare class NodeUsbTransport {
     private serialToBusId;
     private openDevices;
     private deviceProtocol;
-    private protocolV2Assemblers;
-    private protocolV2Sessions;
-    private protocolV2ReadTimeouts;
     private reconnectLocks;
     private cancelled;
+    constructor();
     init(logger: any, emitter?: EventEmitter): Promise<string>;
     configure(signedData: any): Promise<void>;
     configureProtocolV2(signedData: any): void;
@@ -41,6 +39,7 @@ declare class NodeUsbTransport {
     private getOpenDevice;
     private getErrorMessage;
     private isRetryableError;
+    private isUsbTransferTimeout;
     private getDeviceInterface;
     private reconnectForRetry;
     private sendAllChunksWithRetry;
@@ -54,8 +53,13 @@ declare class NodeUsbTransport {
     private withProtocolReadTimeout;
     private probeProtocolV1;
     private probeProtocolV2;
-    private writeProtocolV2Frame;
-    private receiveProtocolV2Frame;
+    protected getProtocolV2UsbSchemas(): ProtocolV2Schemas;
+    protected getProtocolV2UsbLogger(): any;
+    protected writeProtocolV2UsbPacket(path: string, frame: Uint8Array, _context: ProtocolV2CallContext): Promise<void>;
+    protected readProtocolV2UsbPacket(path: string, _context: ProtocolV2CallContext): Promise<Uint8Array>;
+    protected resetProtocolV2UsbNativeLink(path: string, _reason: string): Promise<void>;
+    protected onProtocolV2UsbLinkInvalidated(path: string, reason: string): void;
+    protected createProtocolV2UsbTimeoutError(name: string, timeoutMs: number): Error;
     private callProtocolV2;
     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":";AAEA,OAAO,SAWN,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AA0LhC,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,QAAQ,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAGlE,UAAU,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEpE,IAAI,SAAsB;IAE1B,OAAO,SAAM;IAEb,UAAU,UAAS;IAEnB,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAGvB,OAAO,CAAC,aAAa,CAA6B;IAGlD,OAAO,CAAC,WAAW,CAAiC;IAGpD,OAAO,CAAC,cAAc,CAAwC;IAG9D,OAAO,CAAC,oBAAoB,CAAoD;IAGhF,OAAO,CAAC,kBAAkB,CAA6C;IAGvE,OAAO,CAAC,sBAAsB,CAA8C;IAG5E,OAAO,CAAC,cAAc,CAA0C;IAGhE,OAAO,CAAC,SAAS,CAAS;IAM1B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAMxC,SAAS,CAAC,UAAU,EAAE,GAAG;IAOzB,mBAAmB,CAAC,UAAU,EAAE,GAAG;IAOnC,MAAM;IAIN,IAAI;IAQE,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9E,IAAI,CAAC,IAAI,EAAE,MAAM;;;;;;IAiBjB,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA8BxC,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAsB7C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;YAMhD,eAAe;IA6BvB,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;YAwClB,cAAc;IA0B5B,MAAM;IAWN,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,gBAAgB;IAgBxB,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,iBAAiB;YAmDX,sBAAsB;YAyCtB,mBAAmB;YAsCnB,UAAU;YA0EV,eAAe;IAiB7B,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,4BAA4B;YAOtB,cAAc;YA4Cd,yBAAyB;YAezB,uBAAuB;YA0CvB,eAAe;YAcf,eAAe;YAcf,oBAAoB;YA+BpB,sBAAsB;YAuCtB,cAAc;YAgDd,WAAW;IA6CzB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAGxD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -71,7 +71,7 @@ const TRANSFER_TIMEOUT_MS = 30000;
 const SERIAL_READ_TIMEOUT_MS = 5000;
 const PACKET_IO_MAX_RETRIES = 3;
 const PACKET_IO_RETRY_DELAY = 300;
-const PROTOCOL_PROBE_TIMEOUT = 1000;
+const PROTOCOL_PROBE_TIMEOUT = 5000;
 function getBusId(dev) {
     return `usb:${dev.busNumber}:${dev.deviceAddress}`;
 }
@@ -152,26 +152,6 @@ function transferOutOnce(ep, data) {
         });
     });
 }
-function resetUsbDevice(dev) {
-    return new Promise(resolve => {
-        const reset = dev.reset;
-        if (typeof reset !== 'function') {
-            resolve();
-            return;
-        }
-        reset.call(dev, () => resolve());
-    });
-}
-function clearEndpointHalt(ep) {
-    return new Promise(resolve => {
-        const clearHalt = ep.clearHalt;
-        if (typeof clearHalt !== 'function') {
-            resolve();
-            return;
-        }
-        clearHalt.call(ep, () => resolve());
-    });
-}
 function skipReportByte(packet) {
     if (packet[0] === REPORT_ID) {
         return packet.subarray(1);
@@ -181,8 +161,13 @@ function skipReportByte(packet) {
 function toArrayBuffer(buf) {
     return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
 }
-class NodeUsbTransport {
+class NodeUsbTransport extends transport.ProtocolV2UsbTransportBase {
     constructor() {
+        super({
+            router: transport.PROTOCOL_V2_CHANNEL_USB,
+            maxFrameBytes: transport.PROTOCOL_V2_FRAME_MAX_BYTES,
+            logPrefix: 'ProtocolV2 NodeUSB',
+        });
         this.name = 'NodeUsbTransport';
         this.version = '';
         this.configured = false;
@@ -190,9 +175,6 @@ class NodeUsbTransport {
         this.serialToBusId = new Map();
         this.openDevices = new Map();
         this.deviceProtocol = new Map();
-        this.protocolV2Assemblers = new Map();
-        this.protocolV2Sessions = new Map();
-        this.protocolV2ReadTimeouts = new Map();
         this.reconnectLocks = new Map();
         this.cancelled = false;
     }
@@ -210,13 +192,13 @@ class NodeUsbTransport {
     configureProtocolV2(signedData) {
         var _a;
         this.messagesV2 = parseConfigure(signedData);
-        this.protocolV2Sessions.clear();
-        this.protocolV2ReadTimeouts.clear();
+        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); });
         (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] Protocol V2 schema configured');
     }
     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); });
     }
     post(path, name, data) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -274,6 +256,7 @@ class NodeUsbTransport {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'No device path provided');
             }
             try {
+                yield this.rotateProtocolV2UsbGeneration(path, 'Node USB transport acquired');
                 yield this.closeOpenDevice(path);
                 yield this.openDevice(path);
                 yield this.detectProtocol(path, input.expectedProtocol);
@@ -287,9 +270,9 @@ class NodeUsbTransport {
     }
     release(path, _onclose) {
         return __awaiter(this, void 0, void 0, function* () {
+            yield this.invalidateProtocolV2UsbLink(path, 'Node USB transport released');
             yield this.closeOpenDevice(path);
             this.deviceProtocol.delete(path);
-            this.protocolV2Assemblers.delete(path);
         });
     }
     closeOpenDevice(path) {
@@ -397,6 +380,10 @@ class NodeUsbTransport {
             message.includes('timeout') ||
             message.includes('interrupt'));
     }
+    isUsbTransferTimeout(error) {
+        const message = this.getErrorMessage(error).toLowerCase();
+        return message.includes('timeout') || message.includes('timed_out');
+    }
     getDeviceInterface(dev) {
         var _a;
         const { interfaces } = dev;
@@ -416,6 +403,7 @@ class NodeUsbTransport {
             var _a, _b;
             (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] transfer${direction} failed, retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(error)}`);
             yield hdShared.wait(attempt * PACKET_IO_RETRY_DELAY);
+            yield this.rotateProtocolV2UsbGeneration(path, `Node USB Protocol V1 ${direction} reconnect attempt ${attempt}`);
             try {
                 yield this.closeOpenDevice(path);
             }
@@ -472,7 +460,7 @@ class NodeUsbTransport {
             throw lastError;
         });
     }
-    transferInWithRetry(path, openDev, length) {
+    transferInWithRetry(path, openDev, length, options) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             let lastError;
@@ -486,17 +474,22 @@ class NodeUsbTransport {
                 }
                 catch (error) {
                     lastError = error;
-                    const shouldRetry = attempt < PACKET_IO_MAX_RETRIES && this.isRetryableError(error);
-                    if (!shouldRetry) {
-                        throw error;
-                    }
-                    try {
-                        currentDev = yield this.reconnectForRetry(path, 'in', attempt, error);
+                    if ((options === null || options === void 0 ? void 0 : options.waitIndefinitelyOnTimeout) && this.isUsbTransferTimeout(error)) {
+                        attempt -= 1;
                     }
-                    catch (reconnectError) {
-                        lastError = reconnectError;
-                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.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 = yield this.reconnectForRetry(path, 'in', attempt, error);
+                        }
+                        catch (reconnectError) {
+                            lastError = reconnectError;
+                            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(reconnectError)}`);
+                            break;
+                        }
                     }
                 }
             }
@@ -518,13 +511,6 @@ class NodeUsbTransport {
             try {
                 dev.open();
                 dev.timeout = TRANSFER_TIMEOUT_MS;
-                yield resetUsbDevice(dev);
-                try {
-                    dev.open();
-                }
-                catch (_d) {
-                }
-                dev.timeout = TRANSFER_TIMEOUT_MS;
                 const iface = this.getDeviceInterface(dev);
                 if (process.platform === 'linux') {
                     try {
@@ -532,7 +518,7 @@ class NodeUsbTransport {
                             iface.detachKernelDriver();
                         }
                     }
-                    catch (_e) {
+                    catch (_d) {
                     }
                 }
                 iface.claim();
@@ -543,8 +529,6 @@ class NodeUsbTransport {
                 }
                 epIn.timeout = TRANSFER_TIMEOUT_MS;
                 epOut.timeout = TRANSFER_TIMEOUT_MS;
-                yield clearEndpointHalt(epIn);
-                yield clearEndpointHalt(epOut);
                 yield this.drainStaleInput(epIn);
                 this.openDevices.set(path, { device: dev, iface, epIn, epOut });
             }
@@ -552,7 +536,7 @@ class NodeUsbTransport {
                 try {
                     dev.close();
                 }
-                catch (_f) {
+                catch (_e) {
                 }
                 throw err;
             }
@@ -622,16 +606,14 @@ class NodeUsbTransport {
         });
     }
     resetConnectionAfterProbe(path) {
-        var _a, _b;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
-            this.protocolV2Sessions.delete(path);
-            this.protocolV2ReadTimeouts.delete(path);
+            yield this.rotateProtocolV2UsbGeneration(path, 'Node USB protocol probe reset');
             try {
                 yield this.closeOpenDevice(path);
             }
             catch (error) {
-                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[NodeUsbTransport] close after protocol probe error:', error);
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] close after protocol probe error:', error);
             }
             yield this.enumerate();
             yield this.openDevice(path);
@@ -704,96 +686,60 @@ class NodeUsbTransport {
             });
         });
     }
-    writeProtocolV2Frame(path, frame) {
-        var _a;
+    getProtocolV2UsbSchemas() {
+        if (!this.messages || !this.messagesV2) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+        }
+        return {
+            protocolV1: this.messages,
+            protocolV2: this.messagesV2,
+        };
+    }
+    getProtocolV2UsbLogger() {
+        return this.Log;
+    }
+    writeProtocolV2UsbPacket(path, frame, _context) {
         return __awaiter(this, void 0, void 0, function* () {
-            let lastError;
-            for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
+            if (this.cancelled) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
+            }
+            yield transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(frame));
+        });
+    }
+    readProtocolV2UsbPacket(path, _context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (;;) {
                 if (this.cancelled) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
                 }
                 try {
-                    yield transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(frame));
-                    return;
+                    const packet = yield transferInOnce(this.getOpenDevice(path).epIn, transport.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 {
-                        yield this.reconnectForRetry(path, 'out', attempt, error);
-                    }
-                    catch (reconnectError) {
-                        lastError = reconnectError;
-                        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] Protocol V2 write reconnect failed on retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(reconnectError)}`);
-                        break;
-                    }
                 }
             }
-            throw lastError;
         });
     }
-    receiveProtocolV2Frame(path, timeoutMs) {
+    resetProtocolV2UsbNativeLink(path, _reason) {
         return __awaiter(this, void 0, void 0, function* () {
-            let assembler = this.protocolV2Assemblers.get(path);
-            if (!assembler) {
-                assembler = new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_FRAME_MAX_BYTES);
-                this.protocolV2Assemblers.set(path, assembler);
-            }
-            let frame = assembler.push(new Uint8Array(0));
-            const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
-            while (!frame) {
-                const transferIn = this.transferInWithRetry(path, this.getOpenDevice(path), transport.PROTOCOL_V2_FRAME_MAX_BYTES);
-                const packet = deadline
-                    ? yield this.withProtocolReadTimeout(path, transferIn, Math.max(deadline - Date.now(), 1), 'V2')
-                    : yield transferIn;
-                const bytes = new Uint8Array(packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength));
-                try {
-                    frame = assembler.push(bytes);
-                }
-                catch (error) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, error instanceof Error ? error.message : String(error));
-                }
-            }
-            return frame;
+            yield this.closeOpenDevice(path);
         });
     }
-    callProtocolV2(path, name, data, options) {
+    onProtocolV2UsbLinkInvalidated(path, reason) {
         var _a;
+        this.deviceProtocol.delete(path);
+        (_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}`);
+    }
+    callProtocolV2(path, name, data, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const protocolV1Messages = this.messages;
-            if (!this.messagesV2) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Protocol V2 schema not configured');
-            }
-            if (!protocolV1Messages) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
-            }
-            let session = this.protocolV2Sessions.get(path);
-            if (!session) {
-                session = new transport.ProtocolV2Session({
-                    schemas: {
-                        protocolV1: protocolV1Messages,
-                        protocolV2: this.messagesV2,
-                    },
-                    router: transport.PROTOCOL_V2_CHANNEL_USB,
-                    writeFrame: (frame) => this.writeProtocolV2Frame(path, frame),
-                    readFrame: () => this.receiveProtocolV2Frame(path, this.protocolV2ReadTimeouts.get(path)),
-                    logger: this.Log,
-                    logPrefix: 'ProtocolV2 NodeUSB',
-                    createTimeoutError: (messageName, timeoutMs) => new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${messageName}`),
-                });
-                this.protocolV2Sessions.set(path, session);
-            }
-            this.protocolV2ReadTimeouts.set(path, options === null || options === void 0 ? void 0 : options.timeoutMs);
-            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
-            try {
-                return yield session.call(name, data, options);
-            }
-            finally {
-                this.protocolV2ReadTimeouts.delete(path);
-            }
+            return this.callProtocolV2Usb(path, name, data, options);
         });
     }
     receiveData(path, dev, timeoutMs) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-usb",
-  "version": "1.2.0-alpha.1",
+  "version": "1.2.0-alpha.11",
   "description": "OneKey hardware wallet direct USB transport plugin (libusb)",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -20,10 +20,10 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.1",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.1",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.11",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.11",
     "bytebuffer": "^5.0.1",
     "usb": "^2.14.0"
   },
-  "gitHead": "4f4aae3a47be7bd54b4db4a10c400056784e01bd"
+  "gitHead": "05d3421ec00e07e99f6665e6436a612503e32dfc"
 }

package/src/index.ts

@@ -8,8 +8,7 @@ import transport, {
   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';
@@ -19,6 +18,8 @@ import type {
   AcquireInput,
   OneKeyDeviceInfo,
   ProtocolType,
+  ProtocolV2CallContext,
+  ProtocolV2Schemas,
   TransportCallOptions,
 } from '@onekeyfe/hd-transport';
 
@@ -44,7 +45,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.
@@ -154,32 +155,6 @@ function transferOutOnce(ep: usb.OutEndpoint, data: Buffer): Promise<void> {
   });
 }
 
-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 +181,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 +208,20 @@ 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>>();
 
   /** 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,8 +241,9 @@ export default class NodeUsbTransport {
 
   configureProtocolV2(signedData: any) {
     this.messagesV2 = parseConfigure(signedData);
-    this.protocolV2Sessions.clear();
-    this.protocolV2ReadTimeouts.clear();
+    this.invalidateAllProtocolV2UsbLinks('Protocol V2 schema reconfigured').catch(error =>
+      this.Log?.debug('[NodeUsbTransport] schema link cleanup failed:', error)
+    );
     this.Log?.debug('[NodeUsbTransport] Protocol V2 schema configured');
   }
 
@@ -277,7 +252,9 @@ export default class NodeUsbTransport {
   }
 
   stop() {
-    // Placeholder — no background listeners to tear down
+    this.disposeProtocolV2UsbLinks('Node USB transport stopped').catch(error =>
+      this.Log?.debug('[NodeUsbTransport] stop link cleanup failed:', error)
+    );
   }
 
   /**
@@ -352,6 +329,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 +344,9 @@ export default class NodeUsbTransport {
    * Release device — release interface and close.
    */
   async release(path: string, _onclose?: boolean): Promise<void> {
+    await this.invalidateProtocolV2UsbLink(path, 'Node USB transport released');
     await this.closeOpenDevice(path);
     this.deviceProtocol.delete(path);
-    this.protocolV2Assemblers.delete(path);
   }
 
   private async closeOpenDevice(path: string): Promise<void> {
@@ -515,6 +493,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 +535,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);
@@ -629,7 +616,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;
@@ -641,20 +629,24 @@ export default class NodeUsbTransport {
         return await transferInOnce(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 +672,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,8 +706,6 @@ export default class NodeUsbTransport {
       epIn.timeout = TRANSFER_TIMEOUT_MS;
       epOut.timeout = TRANSFER_TIMEOUT_MS;
 
-      await clearEndpointHalt(epIn);
-      await clearEndpointHalt(epOut);
       await this.drainStaleInput(epIn);
 
       this.openDevices.set(path, { device: dev, iface, epIn, epOut });
@@ -814,9 +795,7 @@ 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 {
       await this.closeOpenDevice(path);
@@ -898,74 +877,66 @@ 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 transferOutOnce(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 transferInOnce(
+          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.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 +945,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);
   }
 
   /**