@onekeyfe/hd-transport-usb 1.1.26-alpha.0 → 1.1.26-alpha.10

package/dist/index.d.ts

@@ -7,19 +7,37 @@ declare const PACKET_SIZE = 64;
 declare class NodeUsbTransport {
     messages: ReturnType<typeof transport__default.parseConfigure> | undefined;
     name: string;
+    version: string;
     configured: boolean;
+    isOutdated: boolean;
     Log?: any;
     emitter?: EventEmitter;
     private serialToBusId;
     private openDevices;
-    init(logger: any, emitter?: EventEmitter): void;
-    configure(signedData: any): void;
+    private reconnectLocks;
+    private cancelled;
+    init(logger: any, emitter?: EventEmitter): Promise<string>;
+    configure(signedData: any): Promise<void>;
     listen(): void;
+    stop(): void;
+    post(path: string, name: string, data: Record<string, unknown>): Promise<void>;
+    read(path: string): Promise<{
+        message: {
+            [key: string]: any;
+        };
+        type: string;
+    }>;
     enumerate(): Promise<OneKeyDeviceInfo[]>;
     acquire(input: AcquireInput): Promise<string>;
     release(path: string, _onclose?: boolean): Promise<void>;
     call(path: string, name: string, data: Record<string, unknown>): Promise<transport.MessageFromOneKey>;
     cancel(): void;
+    private getOpenDevice;
+    private getErrorMessage;
+    private isRetryableError;
+    private reconnectForRetry;
+    private sendAllChunksWithRetry;
+    private transferInWithRetry;
     private openDevice;
     private receiveData;
 }

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"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;AA6K7E,MAAM,CAAC,OAAO,OAAO,gBAAgB;IACnC,QAAQ,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAElE,IAAI,SAAsB;IAE1B,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAGvB,OAAO,CAAC,aAAa,CAA6B;IAGlD,OAAO,CAAC,WAAW,CAAiC;IAMpD,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,YAAY;IAKxC,SAAS,CAAC,UAAU,EAAE,GAAG;IAMzB,MAAM;IASA,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IA8BxC,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAkB7C,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;IAqCpE,MAAM;YAUQ,UAAU;YAuDV,WAAW;CAiC1B;AAED,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}
+{"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

@@ -71,6 +71,7 @@ const INTERFACE_NUMBER = 0;
 const ENDPOINT_IN = 0x81;
 const ENDPOINT_OUT = 0x01;
 const TRANSFER_TIMEOUT_MS = 30000;
+const SERIAL_READ_TIMEOUT_MS = 5000;
 const PACKET_IO_MAX_RETRIES = 3;
 const PACKET_IO_RETRY_DELAY = 300;
 function getBusId(dev) {
@@ -89,29 +90,47 @@ function readSerialNumber(dev, openDevices) {
         }
     }
     return new Promise(resolve => {
+        let settled = false;
+        const settle = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(value);
+        };
+        const timer = setTimeout(() => {
+            try {
+                dev.close();
+            }
+            catch (_a) {
+            }
+            settle(busId);
+        }, SERIAL_READ_TIMEOUT_MS);
         try {
             dev.open();
             try {
                 dev.getStringDescriptor(iSerialNumber, (_err, data) => {
+                    clearTimeout(timer);
                     try {
                         dev.close();
                     }
                     catch (_a) {
                     }
-                    resolve(data || busId);
+                    settle(data || busId);
                 });
             }
             catch (_a) {
+                clearTimeout(timer);
                 try {
                     dev.close();
                 }
                 catch (_b) {
                 }
-                resolve(busId);
+                settle(busId);
             }
         }
         catch (_c) {
-            resolve(busId);
+            clearTimeout(timer);
+            settle(busId);
         }
     });
 }
@@ -135,45 +154,6 @@ function transferOutOnce(ep, data) {
         });
     });
 }
-function wait(ms) {
-    return new Promise(resolve => {
-        setTimeout(resolve, ms);
-    });
-}
-function transferIn(ep, length) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let lastError;
-        for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
-            try {
-                return yield transferInOnce(ep, length);
-            }
-            catch (err) {
-                lastError = err;
-                if (attempt < PACKET_IO_MAX_RETRIES) {
-                    yield wait(attempt * PACKET_IO_RETRY_DELAY);
-                }
-            }
-        }
-        throw lastError;
-    });
-}
-function transferOut(ep, data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let lastError;
-        for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
-            try {
-                return yield transferOutOnce(ep, data);
-            }
-            catch (err) {
-                lastError = err;
-                if (attempt < PACKET_IO_MAX_RETRIES) {
-                    yield wait(attempt * PACKET_IO_RETRY_DELAY);
-                }
-            }
-        }
-        throw lastError;
-    });
-}
 function skipReportByte(packet) {
     if (packet[0] === REPORT_ID) {
         return packet.subarray(1);
@@ -186,21 +166,51 @@ function toArrayBuffer(buf) {
 class NodeUsbTransport {
     constructor() {
         this.name = 'NodeUsbTransport';
+        this.version = '';
         this.configured = false;
+        this.isOutdated = false;
         this.serialToBusId = new Map();
         this.openDevices = new Map();
+        this.reconnectLocks = new Map();
+        this.cancelled = false;
     }
     init(logger, emitter) {
         this.Log = logger;
         this.emitter = emitter;
+        return Promise.resolve('');
     }
     configure(signedData) {
         const messages = parseConfigure(signedData);
         this.configured = true;
         this.messages = messages;
+        return Promise.resolve();
     }
     listen() {
     }
+    stop() {
+    }
+    post(path, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.messages) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const encodeBuffers = buildEncodeBuffers(this.messages, name, data);
+            yield this.sendAllChunksWithRetry(path, encodeBuffers);
+        });
+    }
+    read(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dev = this.getOpenDevice(path);
+            const resData = yield this.receiveData(path, dev);
+            if (typeof resData !== 'string') {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, 'Returning data is not string.');
+            }
+            if (!this.messages) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            return receiveOne(this.messages, resData);
+        });
+    }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
             const allDevices = usb__namespace.getDeviceList();
@@ -228,20 +238,18 @@ class NodeUsbTransport {
     }
     acquire(input) {
         var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            const path = (_a = input.path) !== null && _a !== void 0 ? _a : '';
-            if (!path) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'No device path provided');
-            }
-            try {
-                yield this.openDevice(path);
-                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* () {
@@ -273,11 +281,11 @@ class NodeUsbTransport {
     call(path, name, data) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            this.cancelled = false;
             if (!this.messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            const openDev = this.openDevices.get(path);
-            if (!openDev) {
+            if (!this.openDevices.get(path)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device not acquired: ${path}`);
             }
             const { messages } = this;
@@ -288,13 +296,8 @@ class NodeUsbTransport {
                 (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('NodeUsbTransport call-', ' name: ', name, ' data: ', data);
             }
             const encodeBuffers = buildEncodeBuffers(messages, name, data);
-            for (const buffer of encodeBuffers) {
-                const packet = new Uint8Array(PACKET_SIZE);
-                packet[0] = REPORT_ID;
-                packet.set(new Uint8Array(buffer), 1);
-                yield transferOut(openDev.epOut, Buffer.from(packet));
-            }
-            const resData = yield this.receiveData(openDev);
+            yield this.sendAllChunksWithRetry(path, encodeBuffers);
+            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.');
             }
@@ -305,20 +308,147 @@ class NodeUsbTransport {
     cancel() {
         var _a;
         (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('NodeUsbTransport cancel');
+        this.cancelled = true;
     }
-    openDevice(path) {
+    getOpenDevice(path) {
+        const dev = this.openDevices.get(path);
+        if (!dev) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device not acquired: ${path}`);
+        }
+        return dev;
+    }
+    getErrorMessage(error) {
+        if (!error)
+            return '';
+        if (typeof error === 'string')
+            return error;
+        if (typeof error === 'object' && 'message' in error) {
+            const { message } = error;
+            return typeof message === 'string' ? message : String(message !== null && message !== void 0 ? message : '');
+        }
+        return String(error);
+    }
+    isRetryableError(error) {
+        const message = this.getErrorMessage(error).toLowerCase();
+        return (message.includes('libusb') ||
+            message.includes('transfer') ||
+            message.includes('disconnected') ||
+            message.includes('device not found') ||
+            message.includes('busy') ||
+            message.includes('pipe') ||
+            message.includes('empty usb transfer') ||
+            message.includes('network') ||
+            message.includes('timeout') ||
+            message.includes('interrupt'));
+    }
+    reconnectForRetry(path, direction, attempt, error) {
+        const existing = this.reconnectLocks.get(path);
+        if (existing)
+            return existing;
+        const doReconnect = () => __awaiter(this, void 0, void 0, function* () {
+            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);
+            try {
+                yield this.release(path);
+            }
+            catch (releaseError) {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[NodeUsbTransport] release before retry error:', releaseError);
+            }
+            yield this.enumerate();
+            this.openDevice(path);
+            const openDev = this.openDevices.get(path);
+            if (!openDev) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device not found after reconnect: ${path}`);
+            }
+            return openDev;
+        });
+        const promise = doReconnect().finally(() => {
+            this.reconnectLocks.delete(path);
+        });
+        this.reconnectLocks.set(path, promise);
+        return promise;
+    }
+    sendAllChunksWithRetry(path, encodeBuffers) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const existing = this.openDevices.get(path);
-            if (existing)
-                return;
-            const busId = (_a = this.serialToBusId.get(path)) !== null && _a !== void 0 ? _a : path;
-            const allDevices = usb__namespace.getDeviceList();
-            const dev = allDevices.find(d => getBusId(d) === busId);
-            if (!dev) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `USB device not found: ${path}`);
+            let lastError;
+            for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
+                if (this.cancelled) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
+                }
+                try {
+                    for (const buffer of encodeBuffers) {
+                        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));
+                    }
+                    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] reconnect failed on send retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(reconnectError)}`);
+                        break;
+                    }
+                }
             }
-            dev.open();
+            throw lastError;
+        });
+    }
+    transferInWithRetry(path, openDev, length) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            let lastError;
+            let currentDev = openDev;
+            for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
+                if (this.cancelled) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
+                }
+                try {
+                    return yield transferInOnce(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);
+                    }
+                    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;
+                    }
+                }
+            }
+            throw lastError;
+        });
+    }
+    openDevice(path) {
+        var _a;
+        const existing = this.openDevices.get(path);
+        if (existing)
+            return;
+        const busId = (_a = this.serialToBusId.get(path)) !== null && _a !== void 0 ? _a : path;
+        const allDevices = usb__namespace.getDeviceList();
+        const dev = allDevices.find(d => getBusId(d) === busId);
+        if (!dev) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `USB device not found: ${path}`);
+        }
+        dev.open();
+        try {
             dev.timeout = TRANSFER_TIMEOUT_MS;
             const iface = dev.interface(INTERFACE_NUMBER);
             if (process.platform === 'linux') {
@@ -334,17 +464,24 @@ class NodeUsbTransport {
             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) {
-                dev.close();
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'USB endpoints not found (expected IN 0x81, OUT 0x01)');
             }
             epIn.timeout = TRANSFER_TIMEOUT_MS;
             epOut.timeout = TRANSFER_TIMEOUT_MS;
             this.openDevices.set(path, { device: dev, iface, epIn, epOut });
-        });
+        }
+        catch (err) {
+            try {
+                dev.close();
+            }
+            catch (_c) {
+            }
+            throw err;
+        }
     }
-    receiveData(dev) {
+    receiveData(path, dev) {
         return __awaiter(this, void 0, void 0, function* () {
-            const firstPacket = yield transferIn(dev.epIn, PACKET_SIZE);
+            const firstPacket = yield this.transferInWithRetry(path, dev, PACKET_SIZE);
             const firstData = skipReportByte(firstPacket);
             const { length, typeId, restBuffer } = decodeProtocol.decodeChunked(toArrayBuffer(firstData));
             const lengthWithHeader = Number(length) + HEADER_LENGTH;
@@ -355,7 +492,7 @@ class NodeUsbTransport {
                 decoded.append(restBuffer);
             }
             while (decoded.offset < lengthWithHeader) {
-                const packet = yield transferIn(dev.epIn, PACKET_SIZE);
+                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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-usb",
-  "version": "1.1.26-alpha.0",
+  "version": "1.1.26-alpha.10",
   "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.26-alpha.0",
-    "@onekeyfe/hd-transport": "1.1.26-alpha.0",
+    "@onekeyfe/hd-shared": "1.1.26-alpha.10",
+    "@onekeyfe/hd-transport": "1.1.26-alpha.10",
     "bytebuffer": "^5.0.1",
     "usb": "^2.14.0"
   },
-  "gitHead": "8d3072a406b0672c9d20e2f58e25cef94a9759fb"
+  "gitHead": "4cab4ba97dee894aa87145ced1e629c06f0ab8b7"
 }

package/src/index.ts

@@ -1,7 +1,7 @@
 import ByteBuffer from 'bytebuffer';
 import * as usb from 'usb';
 import transport, { LogBlockCommand } from '@onekeyfe/hd-transport';
-import { ERRORS, HardwareErrorCode, ONEKEY_WEBUSB_FILTER } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode, ONEKEY_WEBUSB_FILTER, wait } from '@onekeyfe/hd-shared';
 
 import { HEADER_LENGTH, PACKET_SIZE, PAYLOAD_SIZE, REPORT_ID } from './constants';
 
@@ -19,6 +19,9 @@ const ENDPOINT_OUT = 0x01;
 /** Transfer timeout in milliseconds */
 const TRANSFER_TIMEOUT_MS = 30000;
 
+/** Timeout for reading serial number descriptor during enumeration */
+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;
@@ -59,29 +62,49 @@ function readSerialNumber(dev: usb.Device, openDevices?: Map<string, OpenDevice>
     }
   }
 
-  return new Promise(resolve => {
+  return new Promise<string>(resolve => {
+    let settled = false;
+    const settle = (value: string) => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+
+    // Guard against getStringDescriptor never calling back
+    const timer = setTimeout(() => {
+      try {
+        dev.close();
+      } catch {
+        /* ignore */
+      }
+      settle(busId);
+    }, SERIAL_READ_TIMEOUT_MS);
+
     try {
       dev.open();
       try {
         dev.getStringDescriptor(iSerialNumber, (_err: Error | undefined, data?: string) => {
+          clearTimeout(timer);
           try {
             dev.close();
           } catch {
             /* ignore */
           }
-          resolve(data || busId);
+          settle(data || busId);
         });
       } catch {
+        clearTimeout(timer);
         try {
           dev.close();
         } catch {
           /* ignore */
         }
-        resolve(busId);
+        settle(busId);
       }
     } catch {
       // dev.open() failed (e.g. LIBUSB_ERROR_BUSY if already open elsewhere)
-      resolve(busId);
+      clearTimeout(timer);
+      settle(busId);
     }
   });
 }
@@ -111,48 +134,6 @@ function transferOutOnce(ep: usb.OutEndpoint, data: Buffer): Promise<void> {
   });
 }
 
-function wait(ms: number): Promise<void> {
-  return new Promise(resolve => {
-    setTimeout(resolve, ms);
-  });
-}
-
-/**
- * USB IN transfer with retry.
- */
-async function transferIn(ep: usb.InEndpoint, length: number): Promise<Buffer> {
-  let lastError: unknown;
-  for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
-    try {
-      return await transferInOnce(ep, length);
-    } catch (err) {
-      lastError = err;
-      if (attempt < PACKET_IO_MAX_RETRIES) {
-        await wait(attempt * PACKET_IO_RETRY_DELAY);
-      }
-    }
-  }
-  throw lastError;
-}
-
-/**
- * USB OUT transfer with retry.
- */
-async function transferOut(ep: usb.OutEndpoint, data: Buffer): Promise<void> {
-  let lastError: unknown;
-  for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
-    try {
-      return await transferOutOnce(ep, data);
-    } catch (err) {
-      lastError = err;
-      if (attempt < PACKET_IO_MAX_RETRIES) {
-        await wait(attempt * PACKET_IO_RETRY_DELAY);
-      }
-    }
-  }
-  throw lastError;
-}
-
 /**
  * Skip the 0x3F protocol marker byte from a USB packet.
  */
@@ -184,8 +165,12 @@ export default class NodeUsbTransport {
 
   name = 'NodeUsbTransport';
 
+  version = '';
+
   configured = false;
 
+  isOutdated = false;
+
   Log?: any;
 
   emitter?: EventEmitter;
@@ -196,6 +181,12 @@ export default class NodeUsbTransport {
   /** path → opened device state */
   private openDevices = new Map<string, OpenDevice>();
 
+  /** 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;
+
   /**
    * Initialize transport.
    * Signature matches the Transport.init interface (logger, emitter).
@@ -203,18 +194,52 @@ export default class NodeUsbTransport {
   init(logger: any, emitter?: EventEmitter) {
     this.Log = logger;
     this.emitter = emitter;
+    return Promise.resolve('');
   }
 
   configure(signedData: any) {
     const messages = parseConfigure(signedData);
     this.configured = true;
     this.messages = messages;
+    return Promise.resolve();
   }
 
   listen() {
     // empty — could add hotplug events via usb.on('attach'/'detach')
   }
 
+  stop() {
+    // Placeholder — no background listeners to tear down
+  }
+
+  /**
+   * Low-level post (send only, no response). Not used by NodeUsbTransport
+   * since call() handles the full send+receive cycle, but required by the Transport interface.
+   */
+  async post(path: string, name: string, data: Record<string, unknown>): Promise<void> {
+    if (!this.messages) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+    const encodeBuffers = buildEncodeBuffers(this.messages, name, data);
+    await this.sendAllChunksWithRetry(path, encodeBuffers);
+  }
+
+  /**
+   * Low-level read (receive only). Not used by NodeUsbTransport
+   * since call() handles the full send+receive cycle, but required by the Transport interface.
+   */
+  async read(path: string) {
+    const dev = this.getOpenDevice(path);
+    const resData = await this.receiveData(path, dev);
+    if (typeof resData !== 'string') {
+      throw ERRORS.TypedError(HardwareErrorCode.NetworkError, 'Returning data is not string.');
+    }
+    if (!this.messages) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+    return receiveOne(this.messages, resData);
+  }
+
   /**
    * Enumerate connected OneKey USB devices.
    * Opens each device briefly to read its serial number (used as `path`),
@@ -250,15 +275,15 @@ export default class NodeUsbTransport {
   /**
    * Acquire device — open USB device, claim interface, return path (string).
    */
-  async acquire(input: AcquireInput): Promise<string> {
+  acquire(input: AcquireInput): Promise<string> {
     const path = input.path ?? '';
     if (!path) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, 'No device path provided');
     }
 
     try {
-      await this.openDevice(path);
-      return path;
+      this.openDevice(path);
+      return Promise.resolve(path);
     } catch (error: any) {
       this.Log?.debug('NodeUsbTransport acquire error: ', error);
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, error.message ?? String(error));
@@ -298,12 +323,13 @@ export default class NodeUsbTransport {
    * This is the core method that replaces LowlevelTransport's call + UsbPlugin's send/receive.
    */
   async call(path: string, name: string, data: Record<string, unknown>) {
+    this.cancelled = false;
+
     if (!this.messages) {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    const openDev = this.openDevices.get(path);
-    if (!openDev) {
+    if (!this.openDevices.get(path)) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, `Device not acquired: ${path}`);
     }
 
@@ -317,16 +343,12 @@ export default class NodeUsbTransport {
     // Encode protobuf message into 63-byte chunks (same as WebUsbTransport)
     const encodeBuffers = buildEncodeBuffers(messages, name, data);
 
-    // Send each chunk with 0x3F report ID prefix
-    for (const buffer of encodeBuffers) {
-      const packet = new Uint8Array(PACKET_SIZE);
-      packet[0] = REPORT_ID;
-      packet.set(new Uint8Array(buffer), 1);
-      await transferOut(openDev.epOut, Buffer.from(packet));
-    }
+    // 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
-    const resData = await this.receiveData(openDev);
+    // Receive response — re-resolve in case reconnect happened during send
+    const resData = await this.receiveData(path, this.getOpenDevice(path));
     if (typeof resData !== 'string') {
       throw ERRORS.TypedError(HardwareErrorCode.NetworkError, 'Returning data is not string.');
     }
@@ -336,15 +358,184 @@ export default class NodeUsbTransport {
 
   cancel() {
     this.Log?.debug('NodeUsbTransport cancel');
+    this.cancelled = true;
   }
 
   // --- Private helpers ---
 
+  /**
+   * Get the current open device for a path, re-resolving from the map
+   * so callers always use a fresh reference after reconnect.
+   */
+  private getOpenDevice(path: string): OpenDevice {
+    const dev = this.openDevices.get(path);
+    if (!dev) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, `Device not acquired: ${path}`);
+    }
+    return dev;
+  }
+
+  private getErrorMessage(error: unknown): string {
+    if (!error) return '';
+    if (typeof error === 'string') return error;
+    if (typeof error === 'object' && 'message' in error) {
+      const { message } = error as { message?: unknown };
+      return typeof message === 'string' ? message : String(message ?? '');
+    }
+    return String(error);
+  }
+
+  private isRetryableError(error: unknown): boolean {
+    const message = this.getErrorMessage(error).toLowerCase();
+    return (
+      message.includes('libusb') ||
+      message.includes('transfer') ||
+      message.includes('disconnected') ||
+      message.includes('device not found') ||
+      message.includes('busy') ||
+      message.includes('pipe') ||
+      message.includes('empty usb transfer') ||
+      message.includes('network') ||
+      message.includes('timeout') ||
+      message.includes('interrupt')
+    );
+  }
+
+  /**
+   * Reconnect device before retrying a failed transfer (aligned with WebUsbTransport).
+   * Uses per-path lock to prevent concurrent reconnects to the same device.
+   */
+  private reconnectForRetry(
+    path: string,
+    direction: 'in' | 'out',
+    attempt: number,
+    error: unknown
+  ): Promise<OpenDevice> {
+    // If a reconnect is already in progress for this path, reuse it
+    const existing = this.reconnectLocks.get(path);
+    if (existing) return existing;
+
+    const doReconnect = async (): Promise<OpenDevice> => {
+      this.Log?.debug(
+        `[NodeUsbTransport] transfer${direction} failed, retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(
+          error
+        )}`
+      );
+      await wait(attempt * PACKET_IO_RETRY_DELAY);
+
+      // Close the existing device
+      try {
+        await this.release(path);
+      } catch (releaseError) {
+        this.Log?.debug('[NodeUsbTransport] release before retry error:', releaseError);
+      }
+
+      // Re-enumerate to refresh device list, then re-open
+      await this.enumerate();
+      this.openDevice(path);
+
+      const openDev = this.openDevices.get(path);
+      if (!openDev) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.DeviceNotFound,
+          `Device not found after reconnect: ${path}`
+        );
+      }
+      return openDev;
+    };
+
+    const promise = doReconnect().finally(() => {
+      this.reconnectLocks.delete(path);
+    });
+    this.reconnectLocks.set(path, promise);
+    return promise;
+  }
+
+  /**
+   * Send all encoded chunks to the device with retry.
+   * If a chunk fails and triggers reconnect, the entire sequence restarts
+   * from chunk 0 because the device resets protocol state on reconnect.
+   */
+  private async sendAllChunksWithRetry(path: string, encodeBuffers: ArrayBuffer[]): Promise<void> {
+    let lastError: unknown;
+    for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
+      if (this.cancelled) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
+      }
+      try {
+        for (const buffer of encodeBuffers) {
+          const packet = new Uint8Array(PACKET_SIZE);
+          packet[0] = REPORT_ID;
+          packet.set(new Uint8Array(buffer), 1);
+          await transferOutOnce(this.getOpenDevice(path).epOut, Buffer.from(packet));
+        }
+        return; // all chunks sent successfully
+      } 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);
+          // Reconnected — loop will restart from chunk 0
+        } catch (reconnectError) {
+          lastError = reconnectError;
+          this.Log?.debug(
+            `[NodeUsbTransport] reconnect failed on send retry ${attempt}/${PACKET_IO_MAX_RETRIES}: ${this.getErrorMessage(
+              reconnectError
+            )}`
+          );
+          // Reconnect failed — no point retrying with a dead device
+          break;
+        }
+      }
+    }
+    throw lastError;
+  }
+
+  /**
+   * USB IN transfer with retry and reconnect (aligned with WebUsbTransport).
+   */
+  private async transferInWithRetry(
+    path: string,
+    openDev: OpenDevice,
+    length: number
+  ): Promise<Buffer> {
+    let lastError: unknown;
+    let currentDev = openDev;
+    for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt++) {
+      if (this.cancelled) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside, 'Cancelled');
+      }
+      try {
+        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;
+        }
+      }
+    }
+    throw lastError;
+  }
+
   /**
    * Open a USB device by path (serial number), claim interface, cache endpoints.
    */
-  // eslint-disable-next-line @typescript-eslint/require-await
-  private async openDevice(path: string): Promise<void> {
+  private openDevice(path: string): void {
     const existing = this.openDevices.get(path);
     if (existing) return;
 
@@ -357,51 +548,60 @@ export default class NodeUsbTransport {
     }
 
     dev.open();
-    dev.timeout = TRANSFER_TIMEOUT_MS;
 
-    const iface = dev.interface(INTERFACE_NUMBER);
+    try {
+      dev.timeout = TRANSFER_TIMEOUT_MS;
 
-    // On Linux, detach kernel driver if active
-    if (process.platform === 'linux') {
-      try {
-        if (iface.isKernelDriverActive()) {
-          iface.detachKernelDriver();
+      const iface = dev.interface(INTERFACE_NUMBER);
+
+      // On Linux, detach kernel driver if active
+      if (process.platform === 'linux') {
+        try {
+          if (iface.isKernelDriverActive()) {
+            iface.detachKernelDriver();
+          }
+        } catch {
+          // May not be supported — continue
         }
-      } catch {
-        // May not be supported — continue
       }
-    }
-
-    iface.claim();
 
-    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
-    );
+      iface.claim();
 
-    if (!epIn || !epOut) {
-      dev.close();
-      throw ERRORS.TypedError(
-        HardwareErrorCode.DeviceNotFound,
-        'USB endpoints not found (expected IN 0x81, OUT 0x01)'
+      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
       );
-    }
 
-    epIn.timeout = TRANSFER_TIMEOUT_MS;
-    epOut.timeout = TRANSFER_TIMEOUT_MS;
+      if (!epIn || !epOut) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.DeviceNotFound,
+          'USB endpoints not found (expected IN 0x81, OUT 0x01)'
+        );
+      }
+
+      epIn.timeout = TRANSFER_TIMEOUT_MS;
+      epOut.timeout = TRANSFER_TIMEOUT_MS;
 
-    this.openDevices.set(path, { device: dev, iface, epIn, epOut });
+      this.openDevices.set(path, { device: dev, iface, epIn, epOut });
+    } catch (err) {
+      try {
+        dev.close();
+      } catch {
+        // ignore close errors during cleanup
+      }
+      throw err;
+    }
   }
 
   /**
    * Receive a complete protobuf response from the device.
    * Reads 64-byte packets, strips 0x3F marker, reassembles into hex string.
    */
-  private async receiveData(dev: OpenDevice): Promise<string> {
+  private async receiveData(path: string, dev: OpenDevice): Promise<string> {
     // Read first packet, skip report byte
-    const firstPacket = await transferIn(dev.epIn, PACKET_SIZE);
+    const firstPacket = await this.transferInWithRetry(path, dev, PACKET_SIZE);
     const firstData = skipReportByte(firstPacket);
 
     // Decode header: ## marker → { typeId, length, restBuffer }
@@ -417,8 +617,9 @@ 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 transferIn(dev.epIn, PACKET_SIZE);
+      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) {