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

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,27 @@
-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;
+    configured: boolean;
+    Log?: any;
+    emitter?: EventEmitter;
+    private serialToBusId;
+    private openDevices;
+    init(logger: any, emitter?: EventEmitter): void;
+    configure(signedData: any): void;
+    listen(): void;
+    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 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;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"}

package/dist/index.js

@@ -63,19 +63,59 @@ 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 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 => {
+        try {
+            dev.open();
+            try {
+                dev.getStringDescriptor(iSerialNumber, (_err, data) => {
+                    try {
+                        dev.close();
+                    }
+                    catch (_a) {
+                    }
+                    resolve(data || busId);
+                });
+            }
+            catch (_a) {
+                try {
+                    dev.close();
+                }
+                catch (_b) {
+                }
+                resolve(busId);
+            }
+        }
+        catch (_c) {
+            resolve(busId);
+        }
+    });
+}
+function transferInOnce(ep, length) {
     return new Promise((resolve, reject) => {
         ep.transfer(length, (err, data) => {
             if (err)
@@ -86,7 +126,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,9 +135,43 @@ function transferOut(ep, data) {
         });
     });
 }
-function readPacket(dev) {
+function wait(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}
+function transferIn(ep, length) {
     return __awaiter(this, void 0, void 0, function* () {
-        return transferIn(dev.epIn, PACKET_SIZE);
+        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) {
@@ -109,12 +183,24 @@ function skipReportByte(packet) {
 function toArrayBuffer(buf) {
     return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
 }
-const UsbPlugin = {
-    version: '1.0.0',
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-        });
-    },
+class NodeUsbTransport {
+    constructor() {
+        this.name = 'NodeUsbTransport';
+        this.configured = false;
+        this.serialToBusId = new Map();
+        this.openDevices = new Map();
+    }
+    init(logger, emitter) {
+        this.Log = logger;
+        this.emitter = emitter;
+    }
+    configure(signedData) {
+        const messages = parseConfigure(signedData);
+        this.configured = true;
+        this.messages = messages;
+    }
+    listen() {
+    }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
             const allDevices = usb__namespace.getDeviceList();
@@ -122,24 +208,115 @@ 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;
+        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));
+            }
+        });
+    }
+    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();
+                    });
+                });
+            }
+            catch (_a) {
+                try {
+                    openDev.device.close();
+                }
+                catch (_b) {
+                }
+            }
+            this.openDevices.delete(path);
+        });
+    }
+    call(path, name, data) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.messages) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+            }
+            const openDev = this.openDevices.get(path);
+            if (!openDev) {
+                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);
+            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);
+            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');
+    }
+    openDevice(path) {
+        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 => getDeviceId(d) === uuid);
+            const dev = allDevices.find(d => getBusId(d) === busId);
             if (!dev) {
-                throw new Error(`USB device not found: ${uuid}`);
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `USB device not found: ${path}`);
             }
             dev.open();
             dev.timeout = TRANSFER_TIMEOUT_MS;
@@ -150,7 +327,7 @@ const UsbPlugin = {
                         iface.detachKernelDriver();
                     }
                 }
-                catch (_a) {
+                catch (_b) {
                 }
             }
             iface.claim();
@@ -158,60 +335,16 @@ const UsbPlugin = {
             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;
-                }
-            }
-        });
-    },
-    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}`);
-            }
-            activeDevice = openDev;
-            const dataBuffer = Buffer.from(data, 'hex');
-            yield transferOut(openDev.epOut, dataBuffer);
+            this.openDevices.set(path, { device: dev, iface, epIn, epOut });
         });
-    },
-    receive() {
+    }
+    receiveData(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 transferIn(dev.epIn, PACKET_SIZE);
             const firstData = skipReportByte(firstPacket);
             const { length, typeId, restBuffer } = decodeProtocol.decodeChunked(toArrayBuffer(firstData));
             const lengthWithHeader = Number(length) + HEADER_LENGTH;
@@ -222,10 +355,10 @@ const UsbPlugin = {
                 decoded.append(restBuffer);
             }
             while (decoded.offset < lengthWithHeader) {
-                const packet = yield readPacket(dev);
+                const packet = yield transferIn(dev.epIn, 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 +369,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-alpha.1",
+  "version": "1.1.26-alpha.0",
   "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-alpha.1",
-    "@onekeyfe/hd-transport": "1.1.25-alpha.1",
+    "@onekeyfe/hd-shared": "1.1.26-alpha.0",
+    "@onekeyfe/hd-transport": "1.1.26-alpha.0",
     "bytebuffer": "^5.0.1",
     "usb": "^2.14.0"
   },
-  "gitHead": "38f1168a599c32919939102d6d40e6be7dd06cf7"
+  "gitHead": "8d3072a406b0672c9d20e2f58e25cef94a9759fb"
 }

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;

package/src/index.ts

@@ -1,13 +1,14 @@
 import ByteBuffer from 'bytebuffer';
 import * as usb from 'usb';
-import transport from '@onekeyfe/hd-transport';
-import { ONEKEY_WEBUSB_FILTER } from '@onekeyfe/hd-shared';
+import transport, { LogBlockCommand } from '@onekeyfe/hd-transport';
+import { ERRORS, HardwareErrorCode, ONEKEY_WEBUSB_FILTER } from '@onekeyfe/hd-shared';
 
-import { HEADER_LENGTH, PACKET_SIZE, REPORT_ID } from './constants';
+import { HEADER_LENGTH, PACKET_SIZE, PAYLOAD_SIZE, REPORT_ID } from './constants';
 
-import type { LowLevelDevice, LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
+import type EventEmitter from 'events';
+import type { AcquireInput, OneKeyDeviceInfo } from '@onekeyfe/hd-transport';
 
-const { decodeProtocol } = transport;
+const { parseConfigure, buildEncodeBuffers, decodeProtocol, receiveOne, check } = transport;
 
 /** USB interface number for vendor-specific communication */
 const INTERFACE_NUMBER = 0;
@@ -18,6 +19,10 @@ const ENDPOINT_OUT = 0x01;
 /** Transfer timeout in milliseconds */
 const TRANSFER_TIMEOUT_MS = 30000;
 
+/** Packet I/O retry configuration (matches WebUsbTransport) */
+const PACKET_IO_MAX_RETRIES = 3;
+const PACKET_IO_RETRY_DELAY = 300;
+
 /**
  * Opened device state — holds the USB device, claimed interface, and endpoints.
  */
@@ -29,26 +34,62 @@ interface OpenDevice {
 }
 
 /**
- * The currently active device — used by receive() since
- * LowlevelTransportSharedPlugin.receive() takes no uuid parameter.
+ * Fallback identifier using bus topology (unstable across re-plugs).
  */
-let activeDevice: OpenDevice | null = null;
-
-/** Map of uuid → open device state */
-const openDevices = new Map<string, OpenDevice>();
+function getBusId(dev: usb.Device): string {
+  return `usb:${dev.busNumber}:${dev.deviceAddress}`;
+}
 
 /**
- * Build a unique identifier for a USB device.
- * Uses bus number + device address which is stable within a session.
+ * Read USB string descriptor serial number from a device.
+ * Opens device briefly, reads serial, then closes.
+ * Falls back to bus path if serial cannot be read.
  */
-function getDeviceId(dev: usb.Device): string {
-  return `usb:${dev.busNumber}:${dev.deviceAddress}`;
+function readSerialNumber(dev: usb.Device, openDevices?: Map<string, OpenDevice>): Promise<string> {
+  const { iSerialNumber } = dev.deviceDescriptor;
+  if (!iSerialNumber) return Promise.resolve(getBusId(dev));
+
+  // If the device is already open (acquired), read serial without open/close
+  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 => {
+    try {
+      dev.open();
+      try {
+        dev.getStringDescriptor(iSerialNumber, (_err: Error | undefined, data?: string) => {
+          try {
+            dev.close();
+          } catch {
+            /* ignore */
+          }
+          resolve(data || busId);
+        });
+      } catch {
+        try {
+          dev.close();
+        } catch {
+          /* ignore */
+        }
+        resolve(busId);
+      }
+    } catch {
+      // dev.open() failed (e.g. LIBUSB_ERROR_BUSY if already open elsewhere)
+      resolve(busId);
+    }
+  });
 }
 
 /**
- * Promisified USB IN transfer.
+ * Promisified USB IN transfer (single attempt).
  */
-function transferIn(ep: usb.InEndpoint, length: number): Promise<Buffer> {
+function transferInOnce(ep: usb.InEndpoint, length: number): Promise<Buffer> {
   return new Promise((resolve, reject) => {
     ep.transfer(length, (err: Error | undefined, data: Buffer | undefined) => {
       if (err) return reject(err);
@@ -59,9 +100,9 @@ function transferIn(ep: usb.InEndpoint, length: number): Promise<Buffer> {
 }
 
 /**
- * Promisified USB OUT transfer.
+ * Promisified USB OUT transfer (single attempt).
  */
-function transferOut(ep: usb.OutEndpoint, data: Buffer): Promise<void> {
+function transferOutOnce(ep: usb.OutEndpoint, data: Buffer): Promise<void> {
   return new Promise((resolve, reject) => {
     ep.transfer(data, (err: Error | undefined) => {
       if (err) return reject(err);
@@ -70,16 +111,50 @@ function transferOut(ep: usb.OutEndpoint, data: Buffer): Promise<void> {
   });
 }
 
+function wait(ms: number): Promise<void> {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+}
+
 /**
- * Read a single 64-byte packet from the device via libusb bulk/interrupt transfer.
+ * USB IN transfer with retry.
  */
-async function readPacket(dev: OpenDevice): Promise<Buffer> {
-  return transferIn(dev.epIn, PACKET_SIZE);
+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.
- * The device sends 0x3F as the first byte of every response packet.
  */
 function skipReportByte(packet: Buffer): Buffer {
   if (packet[0] === REPORT_ID) {
@@ -96,24 +171,56 @@ function toArrayBuffer(buf: Buffer): ArrayBuffer {
 }
 
 /**
- * Node.js USB plugin for LowlevelTransport.
+ * Node.js USB Transport — complete transport implementation using libusb.
  *
- * Implements the 6-method LowlevelTransportSharedPlugin interface
- * using the `usb` (libusb) library for direct USB communication
- * with OneKey hardware wallets.
+ * Unlike the old UsbPlugin (which was a LowlevelTransportSharedPlugin piped
+ * through LowlevelTransport), this class is a standalone transport that handles
+ * both protocol encoding/decoding and USB I/O directly.
  *
- * Uses libusb to access the vendor-specific interface (class 255)
- * which is NOT visible to the HID framework on macOS.
+ * Modeled after WebUsbTransport.
  */
-export const UsbPlugin: LowlevelTransportSharedPlugin = {
-  version: '1.0.0',
+export default class NodeUsbTransport {
+  messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
-  async init(): Promise<void> {
-    // libusb requires no global initialization
-  },
+  name = 'NodeUsbTransport';
 
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async enumerate(): Promise<LowLevelDevice[]> {
+  configured = false;
+
+  Log?: any;
+
+  emitter?: EventEmitter;
+
+  /** serial → bus id, built during enumerate */
+  private serialToBusId = new Map<string, string>();
+
+  /** path → opened device state */
+  private openDevices = new Map<string, OpenDevice>();
+
+  /**
+   * Initialize transport.
+   * Signature matches the Transport.init interface (logger, emitter).
+   */
+  init(logger: any, emitter?: EventEmitter) {
+    this.Log = logger;
+    this.emitter = emitter;
+  }
+
+  configure(signedData: any) {
+    const messages = parseConfigure(signedData);
+    this.configured = true;
+    this.messages = messages;
+  }
+
+  listen() {
+    // empty — could add hotplug events via usb.on('attach'/'detach')
+  }
+
+  /**
+   * Enumerate connected OneKey USB devices.
+   * Opens each device briefly to read its serial number (used as `path`),
+   * then closes it. acquire() re-opens from a fresh getDeviceList().
+   */
+  async enumerate(): Promise<OneKeyDeviceInfo[]> {
     const allDevices = usb.getDeviceList();
 
     const onekeyDevices = allDevices.filter(d => {
@@ -121,26 +228,132 @@ export const UsbPlugin: LowlevelTransportSharedPlugin = {
       return ONEKEY_WEBUSB_FILTER.some(f => idVendor === f.vendorId && idProduct === f.productId);
     });
 
-    return onekeyDevices.map(d => ({
-      id: getDeviceId(d),
-      name: 'OneKey',
-      commType: 'usb' as const,
-    }));
-  },
+    const newSerialToBusId = new Map<string, string>();
+    const results: OneKeyDeviceInfo[] = [];
+    for (const d of onekeyDevices) {
+      const busId = getBusId(d);
+      const serial = await readSerialNumber(d, this.openDevices);
+      newSerialToBusId.set(serial, busId);
+      results.push({
+        path: serial,
+        id: serial,
+        name: 'OneKey',
+        commType: 'usb',
+        debug: false,
+      });
+    }
+    // Atomic swap — concurrent acquire() always sees a complete map
+    this.serialToBusId = newSerialToBusId;
+    return results;
+  }
+
+  /**
+   * Acquire device — open USB device, claim interface, return path (string).
+   */
+  async acquire(input: AcquireInput): Promise<string> {
+    const path = input.path ?? '';
+    if (!path) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, 'No device path provided');
+    }
 
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async connect(uuid: string): Promise<void> {
-    const existing = openDevices.get(uuid);
-    if (existing) {
-      activeDevice = existing;
-      return;
+    try {
+      await this.openDevice(path);
+      return path;
+    } catch (error: any) {
+      this.Log?.debug('NodeUsbTransport acquire error: ', error);
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, error.message ?? String(error));
+    }
+  }
+
+  /**
+   * Release device — release interface and close.
+   */
+  async release(path: string, _onclose?: boolean): Promise<void> {
+    const openDev = this.openDevices.get(path);
+    if (!openDev) return;
+
+    try {
+      await new Promise<void>(resolve => {
+        openDev.iface.release(() => {
+          try {
+            openDev.device.close();
+          } catch {
+            /* ignore */
+          }
+          resolve();
+        });
+      });
+    } catch {
+      try {
+        openDev.device.close();
+      } catch {
+        /* ignore */
+      }
     }
+    this.openDevices.delete(path);
+  }
+
+  /**
+   * Call device method — encode protobuf, send packets, receive response.
+   * This is the core method that replaces LowlevelTransport's call + UsbPlugin's send/receive.
+   */
+  async call(path: string, name: string, data: Record<string, unknown>) {
+    if (!this.messages) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+
+    const openDev = this.openDevices.get(path);
+    if (!openDev) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, `Device not acquired: ${path}`);
+    }
+
+    const { messages } = this;
+    if (LogBlockCommand.has(name)) {
+      this.Log?.debug('NodeUsbTransport call-', ' name: ', name);
+    } else {
+      this.Log?.debug('NodeUsbTransport call-', ' name: ', name, ' data: ', data);
+    }
+
+    // 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));
+    }
+
+    // Receive response
+    const resData = await this.receiveData(openDev);
+    if (typeof resData !== 'string') {
+      throw ERRORS.TypedError(HardwareErrorCode.NetworkError, 'Returning data is not string.');
+    }
+    const jsonData = receiveOne(messages, resData);
+    return check.call(jsonData);
+  }
+
+  cancel() {
+    this.Log?.debug('NodeUsbTransport cancel');
+  }
+
+  // --- Private helpers ---
+
+  /**
+   * 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> {
+    const existing = this.openDevices.get(path);
+    if (existing) return;
 
-    // Find the device by our uuid (bus:address)
+    // Resolve serial → bus id, then find a fresh device object
+    const busId = this.serialToBusId.get(path) ?? path;
     const allDevices = usb.getDeviceList();
-    const dev = allDevices.find(d => getDeviceId(d) === uuid);
+    const dev = allDevices.find(d => getBusId(d) === busId);
     if (!dev) {
-      throw new Error(`USB device not found: ${uuid}`);
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, `USB device not found: ${path}`);
     }
 
     dev.open();
@@ -161,7 +374,6 @@ export const UsbPlugin: LowlevelTransportSharedPlugin = {
 
     iface.claim();
 
-    // Find IN and OUT endpoints
     const epIn = iface.endpoints.find(
       (e): e is usb.InEndpoint => e.direction === 'in' && e.address === ENDPOINT_IN
     );
@@ -171,74 +383,31 @@ export const UsbPlugin: LowlevelTransportSharedPlugin = {
 
     if (!epIn || !epOut) {
       dev.close();
-      throw new Error('USB endpoints not found (expected IN 0x81, OUT 0x01)');
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceNotFound,
+        'USB endpoints not found (expected IN 0x81, OUT 0x01)'
+      );
     }
 
     epIn.timeout = TRANSFER_TIMEOUT_MS;
     epOut.timeout = TRANSFER_TIMEOUT_MS;
 
-    const openDev: OpenDevice = { device: dev, iface, epIn, epOut };
-    openDevices.set(uuid, openDev);
-    activeDevice = openDev;
-  },
-
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async disconnect(uuid: string): Promise<void> {
-    const openDev = openDevices.get(uuid);
-    if (openDev) {
-      try {
-        openDev.iface.release(() => {
-          try {
-            openDev.device.close();
-          } catch {
-            /* ignore */
-          }
-        });
-      } catch {
-        try {
-          openDev.device.close();
-        } catch {
-          /* ignore */
-        }
-      }
-      openDevices.delete(uuid);
-      if (activeDevice === openDev) {
-        activeDevice = null;
-      }
-    }
-  },
-
-  async send(uuid: string, data: string): Promise<void> {
-    const openDev = openDevices.get(uuid);
-    if (!openDev) {
-      throw new Error(`Device not connected: ${uuid}`);
-    }
-    activeDevice = openDev;
-
-    // data is a hex string of a 64-byte packet (0x3F + 63 bytes payload),
-    // already framed by LowlevelTransport's buildBuffers().
-    const dataBuffer = Buffer.from(data, 'hex');
-
-    // libusb transfers the raw packet directly — no Report ID prepend needed
-    // (Report ID is a HID concept; libusb operates at USB level)
-    await transferOut(openDev.epOut, dataBuffer);
-  },
-
-  async receive(): Promise<string> {
-    if (!activeDevice) {
-      throw new Error('No active device for receive');
-    }
-    const dev = activeDevice;
+    this.openDevices.set(path, { device: dev, iface, epIn, epOut });
+  }
 
-    // Mirrors WebUsbTransport.receiveData() exactly:
-    // 1. Read first 64-byte packet, skip byte[0] (0x3F marker)
-    const firstPacket = await readPacket(dev);
+  /**
+   * 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> {
+    // Read first packet, skip report byte
+    const firstPacket = await transferIn(dev.epIn, PACKET_SIZE);
     const firstData = skipReportByte(firstPacket);
 
-    // 2. Use SDK's decodeChunked to parse ## header → { typeId, length, restBuffer }
+    // Decode header: ## marker → { typeId, length, restBuffer }
     const { length, typeId, restBuffer } = decodeProtocol.decodeChunked(toArrayBuffer(firstData));
 
-    // 3. Allocate result buffer: typeId(2) + length(4) + payload(length)
+    // Allocate result: typeId(2) + length(4) + payload(length)
     const lengthWithHeader = Number(length) + HEADER_LENGTH;
     const decoded = new ByteBuffer(lengthWithHeader);
     decoded.writeUint16(typeId);
@@ -247,24 +416,22 @@ export const UsbPlugin: LowlevelTransportSharedPlugin = {
       decoded.append(restBuffer);
     }
 
-    // 4. Read subsequent packets until complete
+    // Read subsequent packets until complete
     while (decoded.offset < lengthWithHeader) {
-      const packet = await readPacket(dev);
+      const packet = await transferIn(dev.epIn, 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 {
         decoded.append(buf.slice(0, lengthWithHeader - decoded.offset));
       }
     }
 
-    // 5. Return as hex string
     decoded.reset();
     const result = decoded.toBuffer();
     return Buffer.from(result as unknown as ArrayBuffer).toString('hex');
-  },
-};
+  }
+}
 
-export default UsbPlugin;
 export { PACKET_SIZE } from './constants';