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

package/dist/constants.d.ts

@@ -1,4 +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

@@ -1 +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,aAAa,IAAI,CAAC"}
+{"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,7 +1,45 @@
-import { LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
+import * as transport from '@onekeyfe/hd-transport';
+import transport__default, { OneKeyDeviceInfo, AcquireInput } from '@onekeyfe/hd-transport';
+import EventEmitter from 'events';
 
 declare const PACKET_SIZE = 64;
 
-declare const UsbPlugin: LowlevelTransportSharedPlugin;
+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;
+    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;
+}
 
-export { PACKET_SIZE, UsbPlugin, UsbPlugin 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":"AAOA,OAAO,KAAK,EAAkB,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAoG5F,eAAO,MAAM,SAAS,EAAE,6BA+JvB,CAAC;AAEF,eAAe,SAAS,CAAC;AACzB,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

@@ -63,19 +63,78 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 
 const PACKET_SIZE = 64;
 const REPORT_ID = 0x3f;
+const PAYLOAD_SIZE = PACKET_SIZE - 1;
 const HEADER_LENGTH = 6;
 
-const { decodeProtocol } = transport__default["default"];
+const { parseConfigure, buildEncodeBuffers, decodeProtocol, receiveOne, check } = transport__default["default"];
 const INTERFACE_NUMBER = 0;
 const ENDPOINT_IN = 0x81;
 const ENDPOINT_OUT = 0x01;
 const TRANSFER_TIMEOUT_MS = 30000;
-let activeDevice = null;
-const openDevices = new Map();
-function getDeviceId(dev) {
+const SERIAL_READ_TIMEOUT_MS = 5000;
+const PACKET_IO_MAX_RETRIES = 3;
+const PACKET_IO_RETRY_DELAY = 300;
+function getBusId(dev) {
     return `usb:${dev.busNumber}:${dev.deviceAddress}`;
 }
-function transferIn(ep, length) {
+function readSerialNumber(dev, openDevices) {
+    const { iSerialNumber } = dev.deviceDescriptor;
+    if (!iSerialNumber)
+        return Promise.resolve(getBusId(dev));
+    const busId = getBusId(dev);
+    if (openDevices) {
+        for (const [serial, od] of openDevices) {
+            if (od.device === dev || getBusId(od.device) === busId) {
+                return Promise.resolve(serial);
+            }
+        }
+    }
+    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) {
+                    }
+                    settle(data || busId);
+                });
+            }
+            catch (_a) {
+                clearTimeout(timer);
+                try {
+                    dev.close();
+                }
+                catch (_b) {
+                }
+                settle(busId);
+            }
+        }
+        catch (_c) {
+            clearTimeout(timer);
+            settle(busId);
+        }
+    });
+}
+function transferInOnce(ep, length) {
     return new Promise((resolve, reject) => {
         ep.transfer(length, (err, data) => {
             if (err)
@@ -86,7 +145,7 @@ function transferIn(ep, length) {
         });
     });
 }
-function transferOut(ep, data) {
+function transferOutOnce(ep, data) {
     return new Promise((resolve, reject) => {
         ep.transfer(data, (err) => {
             if (err)
@@ -95,11 +154,6 @@ function transferOut(ep, data) {
         });
     });
 }
-function readPacket(dev) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return transferIn(dev.epIn, PACKET_SIZE);
-    });
-}
 function skipReportByte(packet) {
     if (packet[0] === REPORT_ID) {
         return packet.subarray(1);
@@ -109,12 +163,54 @@ function skipReportByte(packet) {
 function toArrayBuffer(buf) {
     return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
 }
-const UsbPlugin = {
-    version: '1.0.0',
-    init() {
+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();
@@ -122,26 +218,237 @@ const UsbPlugin = {
                 const { idVendor, idProduct } = d.deviceDescriptor;
                 return hdShared.ONEKEY_WEBUSB_FILTER.some(f => idVendor === f.vendorId && idProduct === f.productId);
             });
-            return onekeyDevices.map(d => ({
-                id: getDeviceId(d),
-                name: 'OneKey',
-                commType: 'usb',
-            }));
+            const newSerialToBusId = new Map();
+            const results = [];
+            for (const d of onekeyDevices) {
+                const busId = getBusId(d);
+                const serial = yield readSerialNumber(d, this.openDevices);
+                newSerialToBusId.set(serial, busId);
+                results.push({
+                    path: serial,
+                    id: serial,
+                    name: 'OneKey',
+                    commType: 'usb',
+                    debug: false,
+                });
+            }
+            this.serialToBusId = newSerialToBusId;
+            return results;
         });
-    },
-    connect(uuid) {
+    }
+    acquire(input) {
+        var _a, _b, _c;
+        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* () {
-            const existing = openDevices.get(uuid);
-            if (existing) {
-                activeDevice = existing;
+            const openDev = this.openDevices.get(path);
+            if (!openDev)
                 return;
+            try {
+                yield new Promise(resolve => {
+                    openDev.iface.release(() => {
+                        try {
+                            openDev.device.close();
+                        }
+                        catch (_a) {
+                        }
+                        resolve();
+                    });
+                });
             }
-            const allDevices = usb__namespace.getDeviceList();
-            const dev = allDevices.find(d => getDeviceId(d) === uuid);
-            if (!dev) {
-                throw new Error(`USB device not found: ${uuid}`);
+            catch (_a) {
+                try {
+                    openDev.device.close();
+                }
+                catch (_b) {
+                }
             }
-            dev.open();
+            this.openDevices.delete(path);
+        });
+    }
+    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);
+            }
+            if (!this.openDevices.get(path)) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device not acquired: ${path}`);
+            }
+            const { messages } = this;
+            if (transport.LogBlockCommand.has(name)) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('NodeUsbTransport call-', ' name: ', name);
+            }
+            else {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('NodeUsbTransport call-', ' name: ', name, ' data: ', data);
+            }
+            const encodeBuffers = buildEncodeBuffers(messages, name, data);
+            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.');
+            }
+            const jsonData = receiveOne(messages, resData);
+            return check.call(jsonData);
+        });
+    }
+    cancel() {
+        var _a;
+        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('NodeUsbTransport cancel');
+        this.cancelled = true;
+    }
+    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* () {
+            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;
+                    }
+                }
+            }
+            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') {
@@ -150,68 +457,31 @@ const UsbPlugin = {
                         iface.detachKernelDriver();
                     }
                 }
-                catch (_a) {
+                catch (_b) {
                 }
             }
             iface.claim();
             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 new Error('USB endpoints not found (expected IN 0x81, OUT 0x01)');
+                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;
-            const openDev = { device: dev, iface, epIn, epOut };
-            openDevices.set(uuid, openDev);
-            activeDevice = openDev;
-        });
-    },
-    disconnect(uuid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const openDev = openDevices.get(uuid);
-            if (openDev) {
-                try {
-                    openDev.iface.release(() => {
-                        try {
-                            openDev.device.close();
-                        }
-                        catch (_a) {
-                        }
-                    });
-                }
-                catch (_a) {
-                    try {
-                        openDev.device.close();
-                    }
-                    catch (_b) {
-                    }
-                }
-                openDevices.delete(uuid);
-                if (activeDevice === openDev) {
-                    activeDevice = null;
-                }
+            this.openDevices.set(path, { device: dev, iface, epIn, epOut });
+        }
+        catch (err) {
+            try {
+                dev.close();
             }
-        });
-    },
-    send(uuid, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const openDev = openDevices.get(uuid);
-            if (!openDev) {
-                throw new Error(`Device not connected: ${uuid}`);
+            catch (_c) {
             }
-            activeDevice = openDev;
-            const dataBuffer = Buffer.from(data, 'hex');
-            yield transferOut(openDev.epOut, dataBuffer);
-        });
-    },
-    receive() {
+            throw err;
+        }
+    }
+    receiveData(path, dev) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!activeDevice) {
-                throw new Error('No active device for receive');
-            }
-            const dev = activeDevice;
-            const firstPacket = yield readPacket(dev);
+            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;
@@ -222,10 +492,10 @@ const UsbPlugin = {
                 decoded.append(restBuffer);
             }
             while (decoded.offset < lengthWithHeader) {
-                const packet = yield readPacket(dev);
+                const packet = yield this.transferInWithRetry(path, this.getOpenDevice(path), PACKET_SIZE);
                 const pktData = skipReportByte(packet);
                 const buf = toArrayBuffer(pktData);
-                if (lengthWithHeader - decoded.offset >= PACKET_SIZE) {
+                if (lengthWithHeader - decoded.offset >= PAYLOAD_SIZE) {
                     decoded.append(buf);
                 }
                 else {
@@ -236,9 +506,8 @@ const UsbPlugin = {
             const result = decoded.toBuffer();
             return Buffer.from(result).toString('hex');
         });
-    },
-};
+    }
+}
 
 exports.PACKET_SIZE = PACKET_SIZE;
-exports.UsbPlugin = UsbPlugin;
-exports["default"] = UsbPlugin;
+exports["default"] = NodeUsbTransport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-usb",
-  "version": "1.1.25",
+  "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.25",
-    "@onekeyfe/hd-transport": "1.1.25",
+    "@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": "6110417c47363db38190076610ea4de0e8508924"
+  "gitHead": "4cab4ba97dee894aa87145ced1e629c06f0ab8b7"
 }

package/src/constants.ts

@@ -4,5 +4,8 @@ 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;