@onekeyfe/hd-transport-usb 1.1.27-alpha.34 → 1.1.27-alpha.4

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const PACKET_SIZE = 64;
+export declare const REPORT_ID = 63;
+export declare const PAYLOAD_SIZE: number;
+export declare const HEADER_LENGTH = 6;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,WAAW,KAAK,CAAC;AAG9B,eAAO,MAAM,SAAS,KAAO,CAAC;AAG9B,eAAO,MAAM,YAAY,QAAkB,CAAC;AAG5C,eAAO,MAAM,aAAa,IAAI,CAAC"}

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 import * as transport from '@onekeyfe/hd-transport';
-import transport__default, { OneKeyDeviceInfo, AcquireInput, TransportCallOptions, ProtocolType } from '@onekeyfe/hd-transport';
+import transport__default, { OneKeyDeviceInfo, AcquireInput } from '@onekeyfe/hd-transport';
 import EventEmitter from 'events';
 
+declare const PACKET_SIZE = 64;
+
 declare class NodeUsbTransport {
     messages: ReturnType<typeof transport__default.parseConfigure> | undefined;
-    messagesV2: ReturnType<typeof transport__default.parseConfigure> | undefined;
     name: string;
     version: string;
     configured: boolean;
@@ -13,13 +14,10 @@ declare class NodeUsbTransport {
     emitter?: EventEmitter;
     private serialToBusId;
     private openDevices;
-    private deviceProtocol;
-    private protocolV2Assemblers;
     private reconnectLocks;
     private cancelled;
     init(logger: any, emitter?: EventEmitter): Promise<string>;
     configure(signedData: any): Promise<void>;
-    configureProtocolV2(signedData: any): void;
     listen(): void;
     stop(): void;
     post(path: string, name: string, data: Record<string, unknown>): Promise<void>;
@@ -32,29 +30,16 @@ declare class NodeUsbTransport {
     enumerate(): Promise<OneKeyDeviceInfo[]>;
     acquire(input: AcquireInput): Promise<string>;
     release(path: string, _onclose?: boolean): Promise<void>;
-    private closeOpenDevice;
-    call(path: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<transport.MessageFromOneKey>;
-    private callProtocolV1;
+    call(path: string, name: string, data: Record<string, unknown>): Promise<transport.MessageFromOneKey>;
     cancel(): void;
     private getOpenDevice;
     private getErrorMessage;
     private isRetryableError;
-    private getDeviceInterface;
     private reconnectForRetry;
     private sendAllChunksWithRetry;
     private transferInWithRetry;
     private openDevice;
-    private createProtocolMismatchError;
-    private detectProtocol;
-    private resetConnectionAfterProbe;
-    private withProtocolReadTimeout;
-    private probeProtocolV1;
-    private probeProtocolV2;
-    private writeProtocolV2Frame;
-    private receiveProtocolV2Frame;
-    private callProtocolV2;
     private receiveData;
-    getProtocolType(path: string): ProtocolType;
 }
 
-export { NodeUsbTransport as default };
+export { PACKET_SIZE, NodeUsbTransport as default };

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;AAgKhC,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,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;IAKnC,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;IAqB7C,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;YAkClB,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;IAsCjC,OAAO,CAAC,UAAU;IA8DlB,OAAO,CAAC,2BAA2B;YAOrB,cAAc;YAqCd,yBAAyB;YAazB,uBAAuB;YA0CvB,eAAe;YAcf,eAAe;YAcf,oBAAoB;YA+BpB,sBAAsB;YAuCtB,cAAc;YAuCd,WAAW;IA6CzB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY;CAG5C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,OAAO,SAA8B,MAAM,wBAAwB,CAAC;AAKpE,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AA0J7E,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,QAAQ,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAElE,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,CAA0C;IAGhE,OAAO,CAAC,SAAS,CAAS;IAM1B,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAMxC,SAAS,CAAC,UAAU,EAAE,GAAG;IAOzB,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;IA8B9C,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAkBvC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BxD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAkCpE,MAAM;IAWN,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,gBAAgB;IAoBxB,OAAO,CAAC,iBAAiB;YAmDX,sBAAsB;YAyCtB,mBAAmB;IAsCjC,OAAO,CAAC,UAAU;YAgEJ,WAAW;CAkC1B;AAED,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var ByteBuffer = require('bytebuffer');
 var usb = require('usb');
 var transport = require('@onekeyfe/hd-transport');
@@ -59,11 +61,12 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const { parseConfigure, ProtocolV1, check } = transport__default["default"];
-const PACKET_SIZE = transport.PROTOCOL_V1_USB_PACKET_SIZE;
-const REPORT_ID = transport.PROTOCOL_V1_REPORT_ID;
-const PAYLOAD_SIZE = transport.PROTOCOL_V1_CHUNK_PAYLOAD_SIZE;
-const HEADER_LENGTH = transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE;
+const PACKET_SIZE = 64;
+const REPORT_ID = 0x3f;
+const PAYLOAD_SIZE = PACKET_SIZE - 1;
+const HEADER_LENGTH = 6;
+
+const { parseConfigure, buildEncodeBuffers, decodeProtocol, receiveOne, check } = transport__default["default"];
 const INTERFACE_NUMBER = 0;
 const ENDPOINT_IN = 0x81;
 const ENDPOINT_OUT = 0x01;
@@ -71,7 +74,6 @@ 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;
 function getBusId(dev) {
     return `usb:${dev.busNumber}:${dev.deviceAddress}`;
 }
@@ -169,8 +171,6 @@ class NodeUsbTransport {
         this.isOutdated = false;
         this.serialToBusId = new Map();
         this.openDevices = new Map();
-        this.deviceProtocol = new Map();
-        this.protocolV2Assemblers = new Map();
         this.reconnectLocks = new Map();
         this.cancelled = false;
     }
@@ -185,11 +185,6 @@ class NodeUsbTransport {
         this.messages = messages;
         return Promise.resolve();
     }
-    configureProtocolV2(signedData) {
-        var _a;
-        this.messagesV2 = parseConfigure(signedData);
-        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] Protocol V2 schema configured');
-    }
     listen() {
     }
     stop() {
@@ -199,7 +194,7 @@ class NodeUsbTransport {
             if (!this.messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            const encodeBuffers = ProtocolV1.encodeMessageChunks(this.messages, name, data);
+            const encodeBuffers = buildEncodeBuffers(this.messages, name, data);
             yield this.sendAllChunksWithRetry(path, encodeBuffers);
         });
     }
@@ -213,7 +208,7 @@ class NodeUsbTransport {
             if (!this.messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            return ProtocolV1.decodeMessage(this.messages, resData);
+            return receiveOne(this.messages, resData);
         });
     }
     enumerate() {
@@ -243,31 +238,20 @@ class NodeUsbTransport {
     }
     acquire(input) {
         var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            this.cancelled = false;
-            const path = (_a = input.path) !== null && _a !== void 0 ? _a : '';
-            if (!path) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'No device path provided');
-            }
-            try {
-                this.openDevice(path);
-                yield this.detectProtocol(path, input.expectedProtocol);
-                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));
-            }
-        });
+        const path = (_a = input.path) !== null && _a !== void 0 ? _a : '';
+        if (!path) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'No device path provided');
+        }
+        try {
+            this.openDevice(path);
+            return Promise.resolve(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));
+        }
     }
     release(path, _onclose) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.closeOpenDevice(path);
-            this.deviceProtocol.delete(path);
-            this.protocolV2Assemblers.delete(path);
-        });
-    }
-    closeOpenDevice(path) {
         return __awaiter(this, void 0, void 0, function* () {
             const openDev = this.openDevices.get(path);
             if (!openDev)
@@ -294,8 +278,8 @@ class NodeUsbTransport {
             this.openDevices.delete(path);
         });
     }
-    call(path, name, data, options) {
-        var _a, _b, _c;
+    call(path, name, data) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             this.cancelled = false;
             if (!this.messages) {
@@ -304,32 +288,20 @@ class NodeUsbTransport {
             if (!this.openDevices.get(path)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device not acquired: ${path}`);
             }
-            const protocol = (_a = this.deviceProtocol.get(path)) !== null && _a !== void 0 ? _a : 'V1';
+            const { messages } = this;
             if (transport.LogBlockCommand.has(name)) {
-                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('NodeUsbTransport call-', ' name: ', name, ' protocol: ', protocol);
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('NodeUsbTransport call-', ' name: ', name);
             }
             else {
-                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('NodeUsbTransport call-', ' name: ', name, ' data: ', data, ' protocol: ', protocol);
-            }
-            if (protocol === 'V2') {
-                return this.callProtocolV2(path, name, data, options);
-            }
-            return this.callProtocolV1(path, name, data, options);
-        });
-    }
-    callProtocolV1(path, name, data, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { messages } = this;
-            if (!messages) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('NodeUsbTransport call-', ' name: ', name, ' data: ', data);
             }
-            const encodeBuffers = ProtocolV1.encodeMessageChunks(messages, name, data);
+            const encodeBuffers = buildEncodeBuffers(messages, name, data);
             yield this.sendAllChunksWithRetry(path, encodeBuffers);
-            const resData = yield this.receiveData(path, this.getOpenDevice(path), options === null || options === void 0 ? void 0 : options.timeoutMs);
+            const resData = yield this.receiveData(path, this.getOpenDevice(path));
             if (typeof resData !== 'string') {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, 'Returning data is not string.');
             }
-            const jsonData = ProtocolV1.decodeMessage(messages, resData);
+            const jsonData = receiveOne(messages, resData);
             return check.call(jsonData);
         });
     }
@@ -369,17 +341,6 @@ class NodeUsbTransport {
             message.includes('timeout') ||
             message.includes('interrupt'));
     }
-    getDeviceInterface(dev) {
-        var _a;
-        const { interfaces } = dev;
-        if (!(interfaces === null || interfaces === void 0 ? void 0 : interfaces.length)) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'USB interface not found');
-        }
-        const vendorInterface = interfaces.find(iface => iface.descriptor.bInterfaceClass === 0xff);
-        const defaultInterface = interfaces.find(iface => iface.descriptor.bInterfaceNumber === INTERFACE_NUMBER);
-        const iface = (_a = vendorInterface !== null && vendorInterface !== void 0 ? vendorInterface : defaultInterface) !== null && _a !== void 0 ? _a : interfaces[0];
-        return iface;
-    }
     reconnectForRetry(path, direction, attempt, error) {
         const existing = this.reconnectLocks.get(path);
         if (existing)
@@ -389,7 +350,7 @@ class NodeUsbTransport {
             (_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);
             try {
-                yield this.closeOpenDevice(path);
+                yield this.release(path);
             }
             catch (releaseError) {
                 (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[NodeUsbTransport] release before retry error:', releaseError);
@@ -476,7 +437,7 @@ class NodeUsbTransport {
         });
     }
     openDevice(path) {
-        var _a, _b, _c;
+        var _a;
         const existing = this.openDevices.get(path);
         if (existing)
             return;
@@ -489,19 +450,19 @@ class NodeUsbTransport {
         dev.open();
         try {
             dev.timeout = TRANSFER_TIMEOUT_MS;
-            const iface = this.getDeviceInterface(dev);
+            const iface = dev.interface(INTERFACE_NUMBER);
             if (process.platform === 'linux') {
                 try {
                     if (iface.isKernelDriverActive()) {
                         iface.detachKernelDriver();
                     }
                 }
-                catch (_d) {
+                catch (_b) {
                 }
             }
             iface.claim();
-            const epIn = (_b = iface.endpoints.find((e) => e.direction === 'in' && e.address === ENDPOINT_IN)) !== null && _b !== void 0 ? _b : iface.endpoints.find((e) => e.direction === 'in');
-            const epOut = (_c = iface.endpoints.find((e) => e.direction === 'out' && e.address === ENDPOINT_OUT)) !== null && _c !== void 0 ? _c : iface.endpoints.find((e) => e.direction === 'out');
+            const epIn = iface.endpoints.find((e) => e.direction === 'in' && e.address === ENDPOINT_IN);
+            const epOut = iface.endpoints.find((e) => e.direction === 'out' && e.address === ENDPOINT_OUT);
             if (!epIn || !epOut) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'USB endpoints not found (expected IN 0x81, OUT 0x01)');
             }
@@ -513,224 +474,16 @@ class NodeUsbTransport {
             try {
                 dev.close();
             }
-            catch (_e) {
+            catch (_c) {
             }
             throw err;
         }
     }
-    createProtocolMismatchError(expected) {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
-    }
-    detectProtocol(path, expectedProtocol) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (expectedProtocol === 'V1') {
-                if (yield this.probeProtocolV1(path)) {
-                    this.deviceProtocol.set(path, 'V1');
-                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V1 (expected)`);
-                    return 'V1';
-                }
-                throw this.createProtocolMismatchError(expectedProtocol);
-            }
-            if (expectedProtocol === 'V2') {
-                if (yield this.probeProtocolV2(path)) {
-                    this.deviceProtocol.set(path, 'V2');
-                    (_b = this.Log) === null || _b === void 0 ? void 0 : _b.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');
-                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2 (cached)`);
-                return 'V2';
-            }
-            let protocol = 'V1';
-            if (!(yield this.probeProtocolV1(path)) && (yield this.probeProtocolV2(path))) {
-                protocol = 'V2';
-            }
-            this.deviceProtocol.set(path, protocol);
-            (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> ${protocol}`);
-            return protocol;
-        });
-    }
-    resetConnectionAfterProbe(path) {
-        var _a, _b;
+    receiveData(path, dev) {
         return __awaiter(this, void 0, void 0, function* () {
-            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.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);
-            }
-            yield this.enumerate();
-            this.openDevice(path);
-        });
-    }
-    withProtocolReadTimeout(path, promise, timeoutMs, protocol) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let timer;
-            let timedOut = false;
-            const waitForeverAfterTimeout = () => new Promise(() => { });
-            const guardedPromise = promise.then(value => (timedOut ? waitForeverAfterTimeout() : value), error => {
-                if (timedOut) {
-                    return waitForeverAfterTimeout();
-                }
-                throw error;
-            });
-            try {
-                return yield Promise.race([
-                    guardedPromise,
-                    new Promise((_, reject) => {
-                        timer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                            var _a;
-                            timedOut = true;
-                            try {
-                                yield this.resetConnectionAfterProbe(path);
-                            }
-                            catch (error) {
-                                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] reset after Protocol ${protocol} timeout failed:`, error);
-                            }
-                            finally {
-                                reject(new Error(`Protocol ${protocol} read timeout after ${timeoutMs}ms`));
-                            }
-                        }), timeoutMs);
-                    }),
-                ]);
-            }
-            finally {
-                if (timer)
-                    clearTimeout(timer);
-            }
-        });
-    }
-    probeProtocolV1(path) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.messages) {
-                return false;
-            }
-            try {
-                yield this.callProtocolV1(path, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT });
-                return true;
-            }
-            catch (error) {
-                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] Protocol V1 Initialize probe failed:', error);
-                return false;
-            }
-        });
-    }
-    probeProtocolV2(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.messages || !this.messagesV2) {
-                return false;
-            }
-            return transport.probeProtocolV2({
-                call: (name, data, options) => this.callProtocolV2(path, name, data, options),
-                timeoutMs: PROTOCOL_PROBE_TIMEOUT,
-                logger: this.Log,
-                logPrefix: 'ProtocolV2 NodeUSB',
-                onProbeFailed: () => this.resetConnectionAfterProbe(path),
-            });
-        });
-    }
-    writeProtocolV2Frame(path, frame) {
-        var _a;
-        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');
-                }
-                try {
-                    yield transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(frame));
-                    return;
-                }
-                catch (error) {
-                    lastError = error;
-                    const shouldRetry = attempt < PACKET_IO_MAX_RETRIES && this.isRetryableError(error);
-                    if (!shouldRetry) {
-                        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) {
-        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;
-        });
-    }
-    callProtocolV2(path, name, data, options) {
-        var _a;
-        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);
-            }
-            const 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, options === null || options === void 0 ? void 0 : options.timeoutMs),
-                logger: this.Log,
-                logPrefix: 'ProtocolV2 NodeUSB',
-                createTimeoutError: (_messageName, timeoutMs) => new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${name}`),
-            });
-            (_a = this.protocolV2Assemblers.get(path)) === null || _a === void 0 ? void 0 : _a.reset();
-            return session.call(name, data, options);
-        });
-    }
-    receiveData(path, dev, timeoutMs) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
-            const readPacket = () => __awaiter(this, void 0, void 0, function* () {
-                const transferIn = this.transferInWithRetry(path, this.getOpenDevice(path), PACKET_SIZE);
-                return deadline
-                    ? this.withProtocolReadTimeout(path, transferIn, Math.max(deadline - Date.now(), 1), 'V1')
-                    : transferIn;
-            });
-            const firstPacket = timeoutMs
-                ? yield readPacket()
-                : yield this.transferInWithRetry(path, dev, PACKET_SIZE);
+            const firstPacket = yield this.transferInWithRetry(path, dev, PACKET_SIZE);
             const firstData = skipReportByte(firstPacket);
-            const { length, typeId, restBuffer } = ProtocolV1.decodeFirstChunk(toArrayBuffer(firstData));
+            const { length, typeId, restBuffer } = decodeProtocol.decodeChunked(toArrayBuffer(firstData));
             const lengthWithHeader = Number(length) + HEADER_LENGTH;
             const decoded = new ByteBuffer__default["default"](lengthWithHeader);
             decoded.writeUint16(typeId);
@@ -739,7 +492,7 @@ class NodeUsbTransport {
                 decoded.append(restBuffer);
             }
             while (decoded.offset < lengthWithHeader) {
-                const packet = yield readPacket();
+                const packet = yield this.transferInWithRetry(path, this.getOpenDevice(path), PACKET_SIZE);
                 const pktData = skipReportByte(packet);
                 const buf = toArrayBuffer(pktData);
                 if (lengthWithHeader - decoded.offset >= PAYLOAD_SIZE) {
@@ -754,10 +507,7 @@ class NodeUsbTransport {
             return Buffer.from(result).toString('hex');
         });
     }
-    getProtocolType(path) {
-        var _a;
-        return (_a = this.deviceProtocol.get(path)) !== null && _a !== void 0 ? _a : 'V1';
-    }
 }
 
-module.exports = NodeUsbTransport;
+exports.PACKET_SIZE = PACKET_SIZE;
+exports["default"] = NodeUsbTransport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-usb",
-  "version": "1.1.27-alpha.34",
+  "version": "1.1.27-alpha.4",
   "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.1.27-alpha.34",
-    "@onekeyfe/hd-transport": "1.1.27-alpha.34",
+    "@onekeyfe/hd-shared": "1.1.27-alpha.4",
+    "@onekeyfe/hd-transport": "1.1.27-alpha.4",
     "bytebuffer": "^5.0.1",
     "usb": "^2.14.0"
   },
-  "gitHead": "ff1863a1ff300ada1314b7315e5ab827663d9f4c"
+  "gitHead": "93d0e7734f8c3a6380be10f74de203f0ba785bb8"
 }

package/src/constants.ts

@@ -0,0 +1,11 @@
+/** USB packet size in bytes */
+export const PACKET_SIZE = 64;
+
+/** Protocol marker byte (0x3F = '?') — first byte of every packet */
+export const REPORT_ID = 0x3f;
+
+/** Usable payload per packet after stripping the 0x3F report byte */
+export const PAYLOAD_SIZE = PACKET_SIZE - 1;
+
+/** Protocol header length: typeId (2 bytes) + length (4 bytes) */
+export const HEADER_LENGTH = 6;

package/src/index.ts

@@ -1,33 +1,14 @@
 import ByteBuffer from 'bytebuffer';
 import * as usb from 'usb';
-import transport, {
-  LogBlockCommand,
-  PROTOCOL_V1_CHUNK_PAYLOAD_SIZE,
-  PROTOCOL_V1_MESSAGE_HEADER_SIZE,
-  PROTOCOL_V1_REPORT_ID,
-  PROTOCOL_V1_USB_PACKET_SIZE,
-  PROTOCOL_V2_CHANNEL_USB,
-  PROTOCOL_V2_FRAME_MAX_BYTES,
-  ProtocolV2FrameAssembler,
-  ProtocolV2Session,
-  probeProtocolV2 as probeProtocolV2Helper,
-} from '@onekeyfe/hd-transport';
+import transport, { LogBlockCommand } from '@onekeyfe/hd-transport';
 import { ERRORS, HardwareErrorCode, ONEKEY_WEBUSB_FILTER, wait } from '@onekeyfe/hd-shared';
 
-import type EventEmitter from 'events';
-import type {
-  AcquireInput,
-  OneKeyDeviceInfo,
-  ProtocolType,
-  TransportCallOptions,
-} from '@onekeyfe/hd-transport';
+import { HEADER_LENGTH, PACKET_SIZE, PAYLOAD_SIZE, REPORT_ID } from './constants';
 
-const { parseConfigure, ProtocolV1, check } = transport;
+import type EventEmitter from 'events';
+import type { AcquireInput, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
 
-const PACKET_SIZE = PROTOCOL_V1_USB_PACKET_SIZE;
-const REPORT_ID = PROTOCOL_V1_REPORT_ID;
-const PAYLOAD_SIZE = PROTOCOL_V1_CHUNK_PAYLOAD_SIZE;
-const HEADER_LENGTH = PROTOCOL_V1_MESSAGE_HEADER_SIZE;
+const { parseConfigure, buildEncodeBuffers, decodeProtocol, receiveOne, check } = transport;
 
 /** USB interface number for vendor-specific communication */
 const INTERFACE_NUMBER = 0;
@@ -44,7 +25,6 @@ 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;
 
 /**
  * Opened device state — holds the USB device, claimed interface, and endpoints.
@@ -183,9 +163,6 @@ function toArrayBuffer(buf: Buffer): ArrayBuffer {
 export default class NodeUsbTransport {
   messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
-  /** Protobuf schema for Protocol V2 transports. */
-  messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
-
   name = 'NodeUsbTransport';
 
   version = '';
@@ -204,12 +181,6 @@ export default class NodeUsbTransport {
   /** path → opened device state */
   private openDevices = new Map<string, OpenDevice>();
 
-  /** 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 reconnect lock to prevent concurrent reconnects */
   private reconnectLocks = new Map<string, Promise<OpenDevice>>();
 
@@ -233,11 +204,6 @@ export default class NodeUsbTransport {
     return Promise.resolve();
   }
 
-  configureProtocolV2(signedData: any) {
-    this.messagesV2 = parseConfigure(signedData);
-    this.Log?.debug('[NodeUsbTransport] Protocol V2 schema configured');
-  }
-
   listen() {
     // empty — could add hotplug events via usb.on('attach'/'detach')
   }
@@ -254,7 +220,7 @@ export default class NodeUsbTransport {
     if (!this.messages) {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
-    const encodeBuffers = ProtocolV1.encodeMessageChunks(this.messages, name, data);
+    const encodeBuffers = buildEncodeBuffers(this.messages, name, data);
     await this.sendAllChunksWithRetry(path, encodeBuffers);
   }
 
@@ -271,7 +237,7 @@ export default class NodeUsbTransport {
     if (!this.messages) {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
-    return ProtocolV1.decodeMessage(this.messages, resData);
+    return receiveOne(this.messages, resData);
   }
 
   /**
@@ -309,9 +275,7 @@ export default class NodeUsbTransport {
   /**
    * Acquire device — open USB device, claim interface, return path (string).
    */
-  async acquire(input: AcquireInput): Promise<string> {
-    this.cancelled = false;
-
+  acquire(input: AcquireInput): Promise<string> {
     const path = input.path ?? '';
     if (!path) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, 'No device path provided');
@@ -319,8 +283,7 @@ export default class NodeUsbTransport {
 
     try {
       this.openDevice(path);
-      await this.detectProtocol(path, input.expectedProtocol);
-      return path;
+      return Promise.resolve(path);
     } catch (error: any) {
       this.Log?.debug('NodeUsbTransport acquire error: ', error);
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, error.message ?? String(error));
@@ -331,12 +294,6 @@ export default class NodeUsbTransport {
    * Release device — release interface and close.
    */
   async release(path: string, _onclose?: boolean): Promise<void> {
-    await this.closeOpenDevice(path);
-    this.deviceProtocol.delete(path);
-    this.protocolV2Assemblers.delete(path);
-  }
-
-  private async closeOpenDevice(path: string): Promise<void> {
     const openDev = this.openDevices.get(path);
     if (!openDev) return;
 
@@ -365,12 +322,7 @@ export default class NodeUsbTransport {
    * Call device method — encode protobuf, send packets, receive response.
    * This is the core method that replaces LowlevelTransport's call + UsbPlugin's send/receive.
    */
-  async call(
-    path: string,
-    name: string,
-    data: Record<string, unknown>,
-    options?: TransportCallOptions
-  ) {
+  async call(path: string, name: string, data: Record<string, unknown>) {
     this.cancelled = false;
 
     if (!this.messages) {
@@ -381,51 +333,26 @@ export default class NodeUsbTransport {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, `Device not acquired: ${path}`);
     }
 
-    const protocol = this.deviceProtocol.get(path) ?? 'V1';
+    const { messages } = this;
     if (LogBlockCommand.has(name)) {
-      this.Log?.debug('NodeUsbTransport call-', ' name: ', name, ' protocol: ', protocol);
+      this.Log?.debug('NodeUsbTransport call-', ' name: ', name);
     } else {
-      this.Log?.debug(
-        'NodeUsbTransport call-',
-        ' name: ',
-        name,
-        ' data: ',
-        data,
-        ' protocol: ',
-        protocol
-      );
-    }
-
-    if (protocol === 'V2') {
-      return this.callProtocolV2(path, name, data, options);
+      this.Log?.debug('NodeUsbTransport call-', ' name: ', name, ' data: ', data);
     }
 
-    return this.callProtocolV1(path, name, data, options);
-  }
-
-  private async callProtocolV1(
-    path: string,
-    name: string,
-    data: Record<string, unknown>,
-    options?: TransportCallOptions
-  ) {
-    const { messages } = this;
-    if (!messages) {
-      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
-    }
     // Encode protobuf message into 63-byte chunks (same as WebUsbTransport)
-    const encodeBuffers = ProtocolV1.encodeMessageChunks(messages, name, data);
+    const encodeBuffers = buildEncodeBuffers(messages, name, data);
 
     // Send all chunks with retry — if any chunk fails and reconnects,
     // restart the entire send sequence from chunk 0 (device resets state on reconnect)
     await this.sendAllChunksWithRetry(path, encodeBuffers);
 
     // Receive response — re-resolve in case reconnect happened during send
-    const resData = await this.receiveData(path, this.getOpenDevice(path), options?.timeoutMs);
+    const resData = await this.receiveData(path, this.getOpenDevice(path));
     if (typeof resData !== 'string') {
       throw ERRORS.TypedError(HardwareErrorCode.NetworkError, 'Returning data is not string.');
     }
-    const jsonData = ProtocolV1.decodeMessage(messages, resData);
+    const jsonData = receiveOne(messages, resData);
     return check.call(jsonData);
   }
 
@@ -474,21 +401,6 @@ export default class NodeUsbTransport {
     );
   }
 
-  private getDeviceInterface(dev: usb.Device): usb.Interface {
-    const { interfaces } = dev;
-    if (!interfaces?.length) {
-      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, 'USB interface not found');
-    }
-
-    const vendorInterface = interfaces.find(iface => iface.descriptor.bInterfaceClass === 0xff);
-    const defaultInterface = interfaces.find(
-      iface => iface.descriptor.bInterfaceNumber === INTERFACE_NUMBER
-    );
-    const iface = vendorInterface ?? defaultInterface ?? interfaces[0];
-
-    return iface;
-  }
-
   /**
    * Reconnect device before retrying a failed transfer (aligned with WebUsbTransport).
    * Uses per-path lock to prevent concurrent reconnects to the same device.
@@ -511,9 +423,9 @@ export default class NodeUsbTransport {
       );
       await wait(attempt * PACKET_IO_RETRY_DELAY);
 
-      // Close the existing device without clearing the detected protocol cache.
+      // Close the existing device
       try {
-        await this.closeOpenDevice(path);
+        await this.release(path);
       } catch (releaseError) {
         this.Log?.debug('[NodeUsbTransport] release before retry error:', releaseError);
       }
@@ -640,7 +552,7 @@ export default class NodeUsbTransport {
     try {
       dev.timeout = TRANSFER_TIMEOUT_MS;
 
-      const iface = this.getDeviceInterface(dev);
+      const iface = dev.interface(INTERFACE_NUMBER);
 
       // On Linux, detach kernel driver if active
       if (process.platform === 'linux') {
@@ -655,14 +567,12 @@ export default class NodeUsbTransport {
 
       iface.claim();
 
-      const epIn =
-        iface.endpoints.find(
-          (e): e is usb.InEndpoint => e.direction === 'in' && e.address === ENDPOINT_IN
-        ) ?? iface.endpoints.find((e): e is usb.InEndpoint => e.direction === 'in');
-      const epOut =
-        iface.endpoints.find(
-          (e): e is usb.OutEndpoint => e.direction === 'out' && e.address === ENDPOINT_OUT
-        ) ?? iface.endpoints.find((e): e is usb.OutEndpoint => e.direction === 'out');
+      const epIn = iface.endpoints.find(
+        (e): e is usb.InEndpoint => e.direction === 'in' && e.address === ENDPOINT_IN
+      );
+      const epOut = iface.endpoints.find(
+        (e): e is usb.OutEndpoint => e.direction === 'out' && e.address === ENDPOINT_OUT
+      );
 
       if (!epIn || !epOut) {
         throw ERRORS.TypedError(
@@ -685,259 +595,17 @@ export default class NodeUsbTransport {
     }
   }
 
-  private createProtocolMismatchError(expected: ProtocolType) {
-    return ERRORS.TypedError(
-      HardwareErrorCode.RuntimeError,
-      `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`
-    );
-  }
-
-  private async detectProtocol(
-    path: string,
-    expectedProtocol?: ProtocolType
-  ): Promise<ProtocolType> {
-    if (expectedProtocol === 'V1') {
-      if (await this.probeProtocolV1(path)) {
-        this.deviceProtocol.set(path, 'V1');
-        this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V1 (expected)`);
-        return 'V1';
-      }
-      throw this.createProtocolMismatchError(expectedProtocol);
-    }
-
-    if (expectedProtocol === 'V2') {
-      if (await this.probeProtocolV2(path)) {
-        this.deviceProtocol.set(path, 'V2');
-        this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2 (expected)`);
-        return 'V2';
-      }
-      throw this.createProtocolMismatchError(expectedProtocol);
-    }
-
-    if (this.deviceProtocol.get(path) === 'V2' && (await this.probeProtocolV2(path))) {
-      this.deviceProtocol.set(path, 'V2');
-      this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2 (cached)`);
-      return 'V2';
-    }
-
-    let protocol: ProtocolType = 'V1';
-    if (!(await this.probeProtocolV1(path)) && (await this.probeProtocolV2(path))) {
-      protocol = 'V2';
-    }
-    this.deviceProtocol.set(path, protocol);
-    this.Log?.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> ${protocol}`);
-    return protocol;
-  }
-
-  private async resetConnectionAfterProbe(path: string) {
-    this.protocolV2Assemblers.get(path)?.reset();
-
-    try {
-      await this.closeOpenDevice(path);
-    } catch (error) {
-      this.Log?.debug('[NodeUsbTransport] close after protocol probe error:', error);
-    }
-
-    await this.enumerate();
-    this.openDevice(path);
-  }
-
-  private async withProtocolReadTimeout<T>(
-    path: string,
-    promise: Promise<T>,
-    timeoutMs: number,
-    protocol: ProtocolType
-  ): Promise<T> {
-    let timer: ReturnType<typeof setTimeout> | undefined;
-    let timedOut = false;
-    const waitForeverAfterTimeout = () => new Promise<never>(() => {});
-    const guardedPromise = promise.then(
-      value => (timedOut ? waitForeverAfterTimeout() : value),
-      error => {
-        if (timedOut) {
-          return waitForeverAfterTimeout();
-        }
-        throw error;
-      }
-    );
-    try {
-      return await Promise.race([
-        guardedPromise,
-        new Promise<never>((_, reject) => {
-          timer = setTimeout(async () => {
-            timedOut = true;
-            try {
-              await this.resetConnectionAfterProbe(path);
-            } catch (error) {
-              this.Log?.debug(
-                `[NodeUsbTransport] reset after Protocol ${protocol} timeout failed:`,
-                error
-              );
-            } finally {
-              reject(new Error(`Protocol ${protocol} read timeout after ${timeoutMs}ms`));
-            }
-          }, timeoutMs);
-        }),
-      ]);
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-  }
-
-  private async probeProtocolV1(path: string) {
-    if (!this.messages) {
-      return false;
-    }
-
-    try {
-      await this.callProtocolV1(path, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT });
-      return true;
-    } catch (error) {
-      this.Log?.debug('[NodeUsbTransport] Protocol V1 Initialize probe failed:', error);
-      return false;
-    }
-  }
-
-  private async probeProtocolV2(path: string) {
-    if (!this.messages || !this.messagesV2) {
-      return false;
-    }
-
-    return probeProtocolV2Helper({
-      call: (name, data, options) => this.callProtocolV2(path, name, data, options),
-      timeoutMs: PROTOCOL_PROBE_TIMEOUT,
-      logger: this.Log,
-      logPrefix: 'ProtocolV2 NodeUSB',
-      onProbeFailed: () => this.resetConnectionAfterProbe(path),
-    });
-  }
-
-  private async writeProtocolV2Frame(path: string, frame: Uint8Array) {
-    let lastError: unknown;
-    for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
-      if (this.cancelled) {
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
-      }
-      try {
-        await transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(frame));
-        return;
-      } catch (error) {
-        lastError = error;
-        const shouldRetry = attempt < PACKET_IO_MAX_RETRIES && this.isRetryableError(error);
-        if (!shouldRetry) {
-          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);
-    }
-
-    let frame: Uint8Array | undefined = assembler.push(new Uint8Array(0));
-    const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
-
-    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;
-  }
-
-  private async callProtocolV2(
-    path: string,
-    name: string,
-    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);
-    }
-
-    const 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, options?.timeoutMs),
-      logger: this.Log,
-      logPrefix: 'ProtocolV2 NodeUSB',
-      createTimeoutError: (_messageName: string, timeoutMs: number) =>
-        new Error(`Protocol V2 response timeout after ${timeoutMs}ms for ${name}`),
-    });
-
-    this.protocolV2Assemblers.get(path)?.reset();
-    return session.call(name, data, options);
-  }
-
   /**
    * Receive a complete protobuf response from the device.
    * Reads 64-byte packets, strips 0x3F marker, reassembles into hex string.
    */
-  private async receiveData(path: string, dev: OpenDevice, timeoutMs?: number): Promise<string> {
-    const deadline = timeoutMs ? Date.now() + timeoutMs : undefined;
-    const readPacket = async () => {
-      const transferIn = this.transferInWithRetry(path, this.getOpenDevice(path), PACKET_SIZE);
-      return deadline
-        ? this.withProtocolReadTimeout(path, transferIn, Math.max(deadline - Date.now(), 1), 'V1')
-        : transferIn;
-    };
-
+  private async receiveData(path: string, dev: OpenDevice): Promise<string> {
     // Read first packet, skip report byte
-    const firstPacket = timeoutMs
-      ? await readPacket()
-      : await this.transferInWithRetry(path, dev, PACKET_SIZE);
+    const firstPacket = await this.transferInWithRetry(path, dev, PACKET_SIZE);
     const firstData = skipReportByte(firstPacket);
 
     // Decode header: ## marker → { typeId, length, restBuffer }
-    const { length, typeId, restBuffer } = ProtocolV1.decodeFirstChunk(toArrayBuffer(firstData));
+    const { length, typeId, restBuffer } = decodeProtocol.decodeChunked(toArrayBuffer(firstData));
 
     // Allocate result: typeId(2) + length(4) + payload(length)
     const lengthWithHeader = Number(length) + HEADER_LENGTH;
@@ -951,7 +619,7 @@ export default class NodeUsbTransport {
     // Read subsequent packets until complete
     // Re-resolve device on each iteration so we use a fresh handle after any reconnect
     while (decoded.offset < lengthWithHeader) {
-      const packet = await readPacket();
+      const packet = await this.transferInWithRetry(path, this.getOpenDevice(path), PACKET_SIZE);
       const pktData = skipReportByte(packet);
       const buf = toArrayBuffer(pktData);
       if (lengthWithHeader - decoded.offset >= PAYLOAD_SIZE) {
@@ -965,8 +633,6 @@ export default class NodeUsbTransport {
     const result = decoded.toBuffer();
     return Buffer.from(result as unknown as ArrayBuffer).toString('hex');
   }
-
-  getProtocolType(path: string): ProtocolType {
-    return this.deviceProtocol.get(path) ?? 'V1';
-  }
 }
+
+export { PACKET_SIZE } from './constants';