@onekeyfe/hd-transport-usb 1.2.0-alpha.3 → 1.2.0-alpha.30

package/dist/index.js

@@ -59,6 +59,14 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+const HIGH_VOLUME_CALLS = new Set(['FileWrite', 'FilesystemFileWrite', 'EmmcFileWrite']);
+function shouldSuppressHighVolumeCallLog(name) {
+    return HIGH_VOLUME_CALLS.has(name);
+}
+function createTransportCallLog(name, protocol) {
+    return { name, protocol };
+}
+
 const { parseConfigure, ProtocolV1, check } = transport__default["default"];
 const PACKET_SIZE = transport.PROTOCOL_V1_USB_PACKET_SIZE;
 const REPORT_ID = transport.PROTOCOL_V1_REPORT_ID;
@@ -71,7 +79,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}`;
 }
@@ -132,46 +140,6 @@ function readSerialNumber(dev, openDevices) {
         }
     });
 }
-function transferInOnce(ep, length) {
-    return new Promise((resolve, reject) => {
-        ep.transfer(length, (err, data) => {
-            if (err)
-                return reject(err);
-            if (!data || data.length === 0)
-                return reject(new Error('Empty USB transfer'));
-            resolve(data);
-        });
-    });
-}
-function transferOutOnce(ep, data) {
-    return new Promise((resolve, reject) => {
-        ep.transfer(data, (err) => {
-            if (err)
-                return reject(err);
-            resolve();
-        });
-    });
-}
-function 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 +149,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,10 +163,8 @@ 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.activeTransfers = new Map();
         this.cancelled = false;
     }
     init(logger, emitter) {
@@ -209,14 +180,38 @@ class NodeUsbTransport {
     }
     configureProtocolV2(signedData) {
         var _a;
+        const schemaSource = typeof signedData === 'string'
+            ? signedData
+            : (_a = JSON.stringify(signedData)) !== null && _a !== void 0 ? _a : String(signedData);
+        if (schemaSource === this.protocolV2SchemaSource)
+            return;
+        const hadProtocolV2Schema = this.protocolV2SchemaSource !== undefined;
         this.messagesV2 = parseConfigure(signedData);
-        this.protocolV2Sessions.clear();
-        this.protocolV2ReadTimeouts.clear();
-        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] Protocol V2 schema configured');
+        this.protocolV2SchemaSource = schemaSource;
+        if (!hadProtocolV2Schema)
+            return;
+        this.invalidateAllProtocolV2UsbLinks('Protocol V2 schema reconfigured').catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] schema link cleanup failed:', error); });
     }
     listen() {
     }
     stop() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cancelled = true;
+            yield this.cancelActiveTransfers();
+            try {
+                yield this.disposeProtocolV2UsbLinks('Node USB transport stopped');
+            }
+            catch (error) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[NodeUsbTransport] stop link cleanup failed:', error);
+            }
+            yield Promise.allSettled(this.reconnectLocks.values());
+            yield this.cancelActiveTransfers();
+            yield Promise.all(Array.from(this.openDevices.keys(), path => this.closeOpenDevice(path)));
+            this.reconnectLocks.clear();
+            this.deviceProtocol.clear();
+            this.serialToBusId.clear();
+        });
     }
     post(path, name, data) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -274,6 +269,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 +283,81 @@ class NodeUsbTransport {
     }
     release(path, _onclose) {
         return __awaiter(this, void 0, void 0, function* () {
+            yield this.cancelActiveTransfers(path);
+            yield this.invalidateProtocolV2UsbLink(path, 'Node USB transport released');
             yield this.closeOpenDevice(path);
             this.deviceProtocol.delete(path);
-            this.protocolV2Assemblers.delete(path);
+        });
+    }
+    cancelActiveTransfers(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transfers = Array.from(this.activeTransfers.entries()).filter(([, active]) => path === undefined || active.path === path);
+            transfers.forEach(([transfer]) => {
+                try {
+                    transfer.cancel();
+                }
+                catch (_a) {
+                }
+            });
+            yield Promise.allSettled(transfers.map(([, active]) => active.settled));
+        });
+    }
+    createTrackedTransfer(path, endpoint, callback) {
+        let resolveSettled = () => undefined;
+        const settled = new Promise(resolve => {
+            resolveSettled = resolve;
+        });
+        const transfer = endpoint.makeTransfer(endpoint.timeout, (error, buffer, actualLength) => {
+            this.activeTransfers.delete(transfer);
+            resolveSettled();
+            callback(error, buffer, actualLength);
+        });
+        this.activeTransfers.set(transfer, { path, settled, resolveSettled });
+        return transfer;
+    }
+    transferInOnce(path, ep, length) {
+        return new Promise((resolve, reject) => {
+            const buffer = Buffer.alloc(length);
+            const transfer = this.createTrackedTransfer(path, ep, (error, _submittedBuffer, actualLength) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                if (actualLength <= 0) {
+                    reject(new Error('Empty USB transfer'));
+                    return;
+                }
+                resolve(buffer.subarray(0, actualLength));
+            });
+            try {
+                transfer.submit(buffer);
+            }
+            catch (error) {
+                const active = this.activeTransfers.get(transfer);
+                this.activeTransfers.delete(transfer);
+                active === null || active === void 0 ? void 0 : active.resolveSettled();
+                reject(error);
+            }
+        });
+    }
+    transferOutOnce(path, ep, data) {
+        return new Promise((resolve, reject) => {
+            const transfer = this.createTrackedTransfer(path, ep, error => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+            try {
+                transfer.submit(data);
+            }
+            catch (error) {
+                const active = this.activeTransfers.get(transfer);
+                this.activeTransfers.delete(transfer);
+                active === null || active === void 0 ? void 0 : active.resolveSettled();
+                reject(error);
+            }
         });
     }
     closeOpenDevice(path) {
@@ -320,7 +388,7 @@ class NodeUsbTransport {
         });
     }
     call(path, name, data, options) {
-        var _a, _b;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.cancelled = false;
             if (!this.messages) {
@@ -333,11 +401,8 @@ class NodeUsbTransport {
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${path}`);
             }
-            if (transport.LogBlockCommand.has(name)) {
-                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('NodeUsbTransport call-', ' name: ', name, ' protocol: ', protocol);
-            }
-            else {
-                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('NodeUsbTransport call-', ' name: ', name, ' data: ', data, ' protocol: ', protocol);
+            if (!shouldSuppressHighVolumeCallLog(name)) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('transport call', createTransportCallLog(name, protocol));
             }
             if (protocol === 'V2') {
                 return this.callProtocolV2(path, name, data, options);
@@ -362,8 +427,6 @@ class NodeUsbTransport {
         });
     }
     cancel() {
-        var _a;
-        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('NodeUsbTransport cancel');
         this.cancelled = true;
     }
     getOpenDevice(path) {
@@ -386,6 +449,9 @@ class NodeUsbTransport {
     }
     isRetryableError(error) {
         const message = this.getErrorMessage(error).toLowerCase();
+        if (message.includes('cancelled') || message.includes('canceled')) {
+            return false;
+        }
         return (message.includes('libusb') ||
             message.includes('transfer') ||
             message.includes('disconnected') ||
@@ -397,6 +463,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 +486,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);
             }
@@ -449,7 +520,7 @@ class NodeUsbTransport {
                         const packet = new Uint8Array(PACKET_SIZE);
                         packet[0] = REPORT_ID;
                         packet.set(new Uint8Array(buffer), 1);
-                        yield transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(packet));
+                        yield this.transferOutOnce(path, this.getOpenDevice(path).epOut, Buffer.from(packet));
                     }
                     return;
                 }
@@ -472,7 +543,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;
@@ -482,21 +553,26 @@ class NodeUsbTransport {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
                 }
                 try {
-                    return yield transferInOnce(currentDev.epIn, length);
+                    return yield this.transferInOnce(path, currentDev.epIn, length);
                 }
                 catch (error) {
                     lastError = error;
-                    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 +594,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 +601,7 @@ class NodeUsbTransport {
                             iface.detachKernelDriver();
                         }
                     }
-                    catch (_e) {
+                    catch (_d) {
                     }
                 }
                 iface.claim();
@@ -543,29 +612,27 @@ class NodeUsbTransport {
                 }
                 epIn.timeout = TRANSFER_TIMEOUT_MS;
                 epOut.timeout = TRANSFER_TIMEOUT_MS;
-                yield clearEndpointHalt(epIn);
-                yield clearEndpointHalt(epOut);
-                yield this.drainStaleInput(epIn);
+                yield this.drainStaleInput(path, epIn);
                 this.openDevices.set(path, { device: dev, iface, epIn, epOut });
             }
             catch (err) {
                 try {
                     dev.close();
                 }
-                catch (_f) {
+                catch (_e) {
                 }
                 throw err;
             }
         });
     }
-    drainStaleInput(epIn) {
+    drainStaleInput(path, epIn) {
         return __awaiter(this, void 0, void 0, function* () {
             const originalTimeout = epIn.timeout;
             epIn.timeout = 50;
             try {
                 for (let index = 0; index < 16; index += 1) {
                     try {
-                        yield transferInOnce(epIn, PACKET_SIZE);
+                        yield this.transferInOnce(path, epIn, PACKET_SIZE);
                     }
                     catch (_a) {
                         break;
@@ -584,37 +651,33 @@ class NodeUsbTransport {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Unable to detect USB protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping');
     }
     detectProtocol(path, expectedProtocol) {
-        var _a, _b, _c, _d, _e;
+        var _a;
         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)`);
+                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2 (expected)`);
                     return 'V2';
                 }
                 throw this.createProtocolMismatchError(expectedProtocol);
             }
+            if (expectedProtocol === 'V1') {
+                if (yield this.probeProtocolV1(path)) {
+                    this.deviceProtocol.set(path, 'V1');
+                    return 'V1';
+                }
+                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';
             }
             if (yield this.probeProtocolV1(path)) {
                 this.deviceProtocol.set(path, 'V1');
-                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V1`);
                 return 'V1';
             }
             if (yield this.probeProtocolV2(path)) {
                 this.deviceProtocol.set(path, 'V2');
-                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug(`[NodeUsbTransport] detectProtocol: path=${path} -> V2`);
                 return 'V2';
             }
             this.deviceProtocol.delete(path);
@@ -622,16 +685,15 @@ 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.cancelActiveTransfers(path);
                 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);
@@ -675,7 +737,6 @@ class NodeUsbTransport {
         });
     }
     probeProtocolV1(path) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.messages) {
                 return false;
@@ -684,8 +745,7 @@ class NodeUsbTransport {
                 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);
+            catch (_error) {
                 return false;
             }
         });
@@ -704,96 +764,61 @@ 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 this.transferOutOnce(path, 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 this.transferInOnce(path, this.getOpenDevice(path).epIn, transport.PROTOCOL_V2_FRAME_MAX_BYTES);
+                    return new Uint8Array(packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength));
                 }
                 catch (error) {
-                    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.cancelActiveTransfers(path);
+            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 transport.ProtocolV2LinkError('response-timeout', `Protocol V2 response timeout after ${timeoutMs}ms for ${name}`);
+    }
+    callProtocolV2(path, name, data, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            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/dist/transportLog.d.ts

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

package/dist/transportLog.d.ts.map

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

package/jest.config.js

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

package/package.json

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