@onekeyfe/hd-transport-web-device 1.2.0-alpha.2 → 1.2.0-alpha.20

package/dist/index.js

@@ -41,6 +41,14 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+const HIGH_VOLUME_CALLS = new Set(['FileWrite', 'FilesystemFileWrite', 'EmmcFileWrite']);
+function shouldSuppressHighVolumeCallLog(name) {
+    return HIGH_VOLUME_CALLS.has(name);
+}
+function createTransportCallLog(name, protocol) {
+    return { name, protocol };
+}
+
 const { parseConfigure: parseConfigure$1, check: check$1, ProtocolV1: ProtocolV1$1 } = transport__default["default"];
 const CONFIGURATION_ID = 1;
 const INTERFACE_ID = 0;
@@ -52,19 +60,6 @@ const HEADER_LENGTH = transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE;
 const PACKET_IO_MAX_RETRIES = 3;
 const PACKET_IO_RETRY_DELAY = 300;
 const PROTOCOL_PROBE_TIMEOUT = 1000;
-const WEBUSB_FILE_WRITE_LOG_BLOCK_PATTERN = /(?:^|[^a-z])(?:raw)?(?:filesystem|emmc)?filewrite$/i;
-function shouldSuppressWebUsbCallLog(name) {
-    const normalized = name.replace(/[_\s-]/g, '');
-    return WEBUSB_FILE_WRITE_LOG_BLOCK_PATTERN.test(normalized);
-}
-function isLogBlockCommand$1(name) {
-    var _a, _b;
-    return (_b = (_a = transport.LogBlockCommand === null || transport.LogBlockCommand === void 0 ? void 0 : transport.LogBlockCommand.has) === null || _a === void 0 ? void 0 : _a.call(transport.LogBlockCommand, name)) !== null && _b !== void 0 ? _b : false;
-}
-function shouldBlockWebUsbCallDataLog(name) {
-    const normalized = name.replace(/[_\s-]/g, '');
-    return isLogBlockCommand$1(name) || WEBUSB_FILE_WRITE_LOG_BLOCK_PATTERN.test(normalized);
-}
 function inferProtocolHintFromDeviceName$1(name) {
     return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
 }
@@ -74,7 +69,9 @@ class WebUsbTransport {
         this.deviceProtocolHints = new Map();
         this.protocolV2Assemblers = new Map();
         this.protocolV2Sessions = new Map();
+        this.protocolV2Sequences = new Map();
         this.protocolV2ReadTimeouts = new Map();
+        this.protocolV2WriteTimeoutMs = transport.PROTOCOL_V2_WRITE_WATCHDOG_TIMEOUT_MS;
         this.deviceEndpoints = new Map();
         this.mockSerialPaths = new WeakMap();
         this.mockSerialCounter = 0;
@@ -100,11 +97,9 @@ class WebUsbTransport {
         this.messages = messages;
     }
     configureProtocolV2(signedData) {
-        var _a;
         this.messagesV2 = parseConfigure$1(signedData);
         this.protocolV2Sessions.clear();
         this.protocolV2ReadTimeouts.clear();
-        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[WebUsbTransport] Protocol V2 schema configured');
     }
     promptDeviceAccess() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -145,7 +140,10 @@ class WebUsbTransport {
             if (!this.usb)
                 return [];
             const devices = yield this.usb.getDevices();
-            const onekeyDevices = devices.filter(dev => hdShared.ONEKEY_WEBUSB_FILTER.some(desc => dev.vendorId === desc.vendorId && dev.productId === desc.productId));
+            const onekeyDevices = devices.filter(dev => {
+                const isOneKey = hdShared.ONEKEY_WEBUSB_FILTER.some((desc) => dev.vendorId === desc.vendorId && dev.productId === desc.productId);
+                return isOneKey && !hdShared.isKnownTrezorWebUsbDevice(dev);
+            });
             this.deviceList = onekeyDevices.map(device => {
                 const path = this.getDevicePath(device);
                 const protocolHint = inferProtocolHintFromDeviceName$1(device.productName);
@@ -158,10 +156,6 @@ class WebUsbTransport {
                     commType: 'webusb',
                 };
             });
-            for (const dev of onekeyDevices) {
-                this.Log.debug(`[WebUSB] Device: name="${dev.productName}" serial="${dev.serialNumber}" ` +
-                    `VID=0x${dev.vendorId.toString(16)} PID=0x${dev.productId.toString(16)}`);
-            }
             return this.deviceList;
         });
     }
@@ -200,14 +194,13 @@ class WebUsbTransport {
             if (expectedProtocol === 'V1') {
                 if (yield this.probeProtocolV1(path)) {
                     this.deviceProtocol.set(path, 'V1');
-                    this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> V1 (expected)`);
                     return 'V1';
                 }
+                yield this.resetConnectionAfterProbe(path);
                 throw this.createProtocolMismatchError(expectedProtocol);
             }
             if (expectedProtocol === 'V2') {
                 this.deviceProtocol.set(path, 'V2');
-                this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> V2 (expected)`);
                 return 'V2';
             }
             const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(path) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
@@ -215,9 +208,11 @@ class WebUsbTransport {
                 const detected = protocol === 'V1' ? yield this.probeProtocolV1(path) : yield this.probeProtocolV2(path);
                 if (detected) {
                     this.deviceProtocol.set(path, protocol);
-                    this.Log.debug(`[WebUsbTransport] detectProtocol: path=${path} -> ${protocol}`);
                     return protocol;
                 }
+                if (protocol === 'V1') {
+                    yield this.resetConnectionAfterProbe(path);
+                }
             }
             this.deviceProtocol.delete(path);
             throw this.createProtocolDetectionError();
@@ -287,7 +282,6 @@ class WebUsbTransport {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             let device = yield this.findDevice(path);
-            this.Log.debug('[WebUsbTransport] connecting to device:', device.productName, 'PID:', device.productId);
             if (!device.opened) {
                 yield device.open();
             }
@@ -420,19 +414,11 @@ class WebUsbTransport {
         return copied.buffer;
     }
     transferOutWithRetry(path, packet) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             let lastError;
             for (let attempt = 1; attempt <= PACKET_IO_MAX_RETRIES; attempt += 1) {
                 try {
-                    const device = yield this.findDevice(path);
-                    if (!device.opened) {
-                        yield this.connect(path, false);
-                    }
-                    const endpoints = this.deviceEndpoints.get(path);
-                    const endpointOut = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpointOut) !== null && _a !== void 0 ? _a : this.endpointId;
-                    const transferBuffer = this.toArrayBuffer(packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength));
-                    yield device.transferOut(endpointOut, transferBuffer);
+                    yield this.transferOutOnce(path, packet);
                     return;
                 }
                 catch (error) {
@@ -453,6 +439,19 @@ class WebUsbTransport {
             throw lastError;
         });
     }
+    transferOutOnce(path, packet) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.findDevice(path);
+            if (!device.opened) {
+                yield this.connect(path, false);
+            }
+            const endpoints = this.deviceEndpoints.get(path);
+            const endpointOut = (_a = endpoints === null || endpoints === void 0 ? void 0 : endpoints.endpointOut) !== null && _a !== void 0 ? _a : this.endpointId;
+            const transferBuffer = this.toArrayBuffer(packet.buffer.slice(packet.byteOffset, packet.byteOffset + packet.byteLength));
+            yield device.transferOut(endpointOut, transferBuffer);
+        });
+    }
     transferInWithRetry(path, length, cancelToken) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -519,7 +518,7 @@ class WebUsbTransport {
             yield this.connect(path, false);
         });
     }
-    withProtocolReadTimeout(path, promise, timeoutMs, protocol, onTimeout) {
+    withProtocolReadTimeout(_path, promise, timeoutMs, protocol, onTimeout) {
         return __awaiter(this, void 0, void 0, function* () {
             let timer;
             let timedOut = false;
@@ -534,11 +533,11 @@ class WebUsbTransport {
                 return yield Promise.race([
                     guardedPromise,
                     new Promise((_, reject) => {
-                        timer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                        timer = setTimeout(() => {
                             timedOut = true;
                             onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout();
                             reject(new Error(`Protocol ${protocol} read timeout after ${timeoutMs}ms`));
-                        }), timeoutMs);
+                        }, timeoutMs);
                     }),
                 ]);
             }
@@ -557,8 +556,7 @@ class WebUsbTransport {
                 yield this.callProtocolV1(path, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT });
                 return true;
             }
-            catch (error) {
-                this.Log.debug('[WebUsbTransport] Protocol V1 Initialize probe failed:', error);
+            catch (_error) {
                 return false;
             }
         });
@@ -573,7 +571,6 @@ class WebUsbTransport {
                 timeoutMs: PROTOCOL_PROBE_TIMEOUT,
                 logger: this.Log,
                 logPrefix: 'ProtocolV2 WebUSB',
-                onProbeFailed: () => this.resetConnectionAfterProbe(path),
             });
         });
     }
@@ -590,12 +587,8 @@ class WebUsbTransport {
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${path}`);
             }
-            if (shouldSuppressWebUsbCallLog(name)) ;
-            else if (shouldBlockWebUsbCallDataLog(name)) {
-                this.Log.debug('call-', ' name: ', name, ' protocol: ', protocol);
-            }
-            else {
-                this.Log.debug('call-', ' name: ', name, ' data: ', data, ' protocol: ', protocol);
+            if (!shouldSuppressHighVolumeCallLog(name)) {
+                this.Log.debug('transport call', createTransportCallLog(name, protocol));
             }
             if (protocol === 'V2') {
                 return this.callProtocolV2(path, name, data, options);
@@ -636,13 +629,20 @@ class WebUsbTransport {
             }
             let session = this.protocolV2Sessions.get(path);
             if (!session) {
+                let sequenceCursor = this.protocolV2Sequences.get(path);
+                if (!sequenceCursor) {
+                    sequenceCursor = new transport.ProtocolV2SequenceCursor();
+                    this.protocolV2Sequences.set(path, sequenceCursor);
+                }
                 session = new transport.ProtocolV2Session({
                     schemas: {
                         protocolV1: protocolV1Messages,
                         protocolV2: this.messagesV2,
                     },
                     router: transport.PROTOCOL_V2_CHANNEL_USB,
-                    writeFrame: (frame) => this.transferOutWithRetry(path, frame),
+                    sequenceCursor,
+                    writeTimeoutMs: this.protocolV2WriteTimeoutMs,
+                    writeFrame: (frame) => this.transferOutOnce(path, frame),
                     readFrame: () => this.receiveProtocolV2Frame(path, this.protocolV2ReadTimeouts.get(path)),
                     logger: this.Log,
                     logPrefix: 'ProtocolV2 WebUSB',
@@ -655,6 +655,21 @@ class WebUsbTransport {
             try {
                 return yield session.call(name, data, options);
             }
+            catch (error) {
+                const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+                if (message.includes('protocol v2 read timeout') ||
+                    message.includes('protocol v2 write timeout') ||
+                    message.includes('protocol v2 delivery timeout') ||
+                    message.includes('response timeout')) {
+                    try {
+                        yield this.resetConnectionAfterProbe(path);
+                    }
+                    catch (resetError) {
+                        this.Log.debug('[WebUsbTransport] Protocol V2 timeout reset failed:', resetError);
+                    }
+                }
+                throw error;
+            }
             finally {
                 this.protocolV2ReadTimeouts.delete(path);
             }
@@ -737,6 +752,8 @@ class WebUsbTransport {
             this.deviceProtocolHints.delete(path);
             (_b = this.protocolV2Assemblers.get(path)) === null || _b === void 0 ? void 0 : _b.reset();
             this.protocolV2Assemblers.delete(path);
+            this.protocolV2Sessions.delete(path);
+            this.protocolV2ReadTimeouts.delete(path);
             this.deviceEndpoints.delete(path);
         });
     }
@@ -745,15 +762,6 @@ class WebUsbTransport {
     }
 }
 
-const FILE_WRITE_LOG_BLOCK_PATTERN = /(?:^|[^a-z])(?:raw)?(?:filesystem|emmc)?filewrite$/i;
-function shouldSuppressHighVolumeCallLog(name) {
-    const normalized = name.replace(/[_\s-]/g, '');
-    return FILE_WRITE_LOG_BLOCK_PATTERN.test(normalized);
-}
-function isLogBlockCommand(name) {
-    var _a, _b;
-    return (_b = (_a = transport.LogBlockCommand === null || transport.LogBlockCommand === void 0 ? void 0 : transport.LogBlockCommand.has) === null || _a === void 0 ? void 0 : _a.call(transport.LogBlockCommand, name)) !== null && _b !== void 0 ? _b : false;
-}
 const { parseConfigure, ProtocolV1, check } = transport__default["default"];
 function inferProtocolHintFromDeviceName(name) {
     return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
@@ -761,8 +769,6 @@ function inferProtocolHintFromDeviceName(name) {
 const toBleDescriptor = (device, protocolType) => (Object.assign({ id: device.id, name: device.name, path: device.id, debug: false, commType: 'electron-ble' }, (protocolType ? { protocolType } : {})));
 const BLE_PACKET_SIZE = 192;
 const BLE_WRITE_DELAY_MS = 5;
-const BLE_WRITE_MAX_RETRIES = 3;
-const BLE_WRITE_RETRY_DELAY_MS = 300;
 const BLE_RESPONSE_TIMEOUT_MS = 30000;
 const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
 const PROTOCOL_V2_PROBE_TIMEOUT_MS = 5000;
@@ -778,8 +784,27 @@ class ElectronBleTransport {
         this.v2Assemblers = new Map();
         this.v2FrameQueues = new Map();
         this.v2FramePromises = new Map();
-        this.activeProtocolV2Call = null;
-        this.nextProtocolV2CallToken = 1;
+        this.protocolV2Links = new transport.ProtocolV2LinkManager({
+            getSchemas: () => {
+                if (!this._messages || !this._messagesV2) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
+                }
+                return {
+                    protocolV1: this._messages,
+                    protocolV2: this._messagesV2,
+                };
+            },
+            classifyError: () => 'link-fatal',
+            onLinkInvalidated: (uuid, reason) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+                this.rejectProtocolV2Frames(uuid, new Error(reason));
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Electron BLE] Protocol V2 link invalidated:', uuid, reason);
+                if (reason.startsWith('Protocol V2 link-fatal error:')) {
+                    yield this.release(uuid);
+                }
+            }),
+        });
         this.notificationCleanups = new Map();
         this.disconnectCleanups = new Map();
         this.notificationTokens = new Map();
@@ -815,15 +840,14 @@ class ElectronBleTransport {
         throw error;
     }
     cleanupDeviceState(deviceId) {
-        var _a;
+        this.protocolV2Links
+            .invalidateLink(deviceId, 'Electron BLE device state cleaned')
+            .catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] link cleanup failed:', error); });
         this.connectedDevices.delete(deviceId);
         this.deviceProtocol.delete(deviceId);
         this.v1Buffers.delete(deviceId);
         this.v2Assemblers.delete(deviceId);
         this.resetProtocolV2Frames(deviceId);
-        if (((_a = this.activeProtocolV2Call) === null || _a === void 0 ? void 0 : _a.uuid) === deviceId) {
-            this.activeProtocolV2Call = null;
-        }
         this.notificationTokens.delete(deviceId);
         const notifyCleanup = this.notificationCleanups.get(deviceId);
         if (notifyCleanup) {
@@ -850,9 +874,10 @@ class ElectronBleTransport {
         this.configured = true;
     }
     configureProtocolV2(signedData) {
-        var _a;
         this._messagesV2 = parseConfigure(signedData);
-        (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] Protocol V2 schema configured');
+        this.protocolV2Links
+            .invalidateAllLinks('Protocol V2 schema reconfigured')
+            .catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] schema link cleanup failed:', error); });
     }
     listen() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -890,12 +915,14 @@ class ElectronBleTransport {
             if (!uuid) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleRequiredUUID);
             }
+            if (this.connectedDevices.has(uuid)) {
+                yield this.release(uuid);
+            }
             if (forceCleanRunPromise && this.runPromise) {
                 const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
                 this.runPromise.reject(error);
                 this.rejectAllProtocolV2Frames(error);
                 this.runPromise = null;
-                this.activeProtocolV2Call = null;
             }
             try {
                 if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
@@ -963,6 +990,7 @@ class ElectronBleTransport {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                yield this.protocolV2Links.invalidateLink(id, 'Electron BLE transport released');
                 if (this.connectedDevices.has(id)) {
                     if ((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle) {
                         yield window.desktopApi.nobleBle.unsubscribe(id);
@@ -1036,14 +1064,12 @@ class ElectronBleTransport {
         });
     }
     resetProbeStateAfterProtocolProbe(uuid, protocol) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g;
         return __awaiter(this, void 0, void 0, function* () {
+            yield this.protocolV2Links.invalidateLink(uuid, `Reset notify state after Protocol ${protocol} probe`);
             this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
             (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
             this.resetProtocolV2Frames(uuid);
-            if (((_b = this.activeProtocolV2Call) === null || _b === void 0 ? void 0 : _b.uuid) === uuid) {
-                this.activeProtocolV2Call = null;
-            }
             if (this.runPromise) {
                 const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
                 this.runPromise.reject(error);
@@ -1056,16 +1082,16 @@ class ElectronBleTransport {
             }
             this.notificationTokens.delete(uuid);
             try {
-                yield ((_d = (_c = window.desktopApi) === null || _c === void 0 ? void 0 : _c.nobleBle) === null || _d === void 0 ? void 0 : _d.unsubscribe(uuid));
+                yield ((_c = (_b = window.desktopApi) === null || _b === void 0 ? void 0 : _b.nobleBle) === null || _c === void 0 ? void 0 : _c.unsubscribe(uuid));
             }
             catch (error) {
-                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug(`[Electron BLE] unsubscribe after Protocol ${protocol} probe failed:`, error);
+                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug(`[Electron BLE] unsubscribe after Protocol ${protocol} probe failed:`, error);
             }
             try {
-                yield ((_g = (_f = window.desktopApi) === null || _f === void 0 ? void 0 : _f.nobleBle) === null || _g === void 0 ? void 0 : _g.subscribe(uuid));
+                yield ((_f = (_e = window.desktopApi) === null || _e === void 0 ? void 0 : _e.nobleBle) === null || _f === void 0 ? void 0 : _f.subscribe(uuid));
             }
             catch (error) {
-                (_h = this.Log) === null || _h === void 0 ? void 0 : _h.debug(`[Electron BLE] resubscribe after Protocol ${protocol} probe failed:`, error);
+                (_g = this.Log) === null || _g === void 0 ? void 0 : _g.debug(`[Electron BLE] resubscribe after Protocol ${protocol} probe failed:`, error);
                 throw error;
             }
             const cleanup = this.createNotificationSubscription(uuid);
@@ -1120,52 +1146,40 @@ class ElectronBleTransport {
             const totalBytes = hexData.length / 2;
             if (totalBytes <= BLE_PACKET_SIZE) {
                 yield hdShared.wait(BLE_WRITE_DELAY_MS);
-                yield this.writeWithRetry(uuid, hexData);
+                yield this.writeOnce(uuid, hexData);
                 return;
             }
             for (let offset = 0; offset < hexData.length;) {
                 const chunkHexLen = Math.min(BLE_PACKET_SIZE * 2, hexData.length - offset);
                 const chunkHex = hexData.substring(offset, offset + chunkHexLen);
                 offset += chunkHexLen;
-                yield this.writeWithRetry(uuid, chunkHex);
+                yield this.writeOnce(uuid, chunkHex);
                 if (offset < hexData.length) {
                     yield hdShared.wait(BLE_WRITE_DELAY_MS);
                 }
             }
         });
     }
-    writeWithRetry(uuid, hexData) {
-        var _a, _b, _c;
+    writeOnce(uuid, hexData) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            let lastError;
             const nobleBle = (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle;
             if (!nobleBle) {
                 throw new Error('Noble BLE API not available');
             }
-            for (let attempt = 1; attempt <= BLE_WRITE_MAX_RETRIES; attempt++) {
-                try {
-                    yield nobleBle.write(uuid, hexData);
-                    return;
-                }
-                catch (error) {
-                    lastError = error;
-                    (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error(`[Electron BLE] write failed (attempt ${attempt}/${BLE_WRITE_MAX_RETRIES}):`, error);
-                    if (attempt < BLE_WRITE_MAX_RETRIES) {
-                        yield hdShared.wait(BLE_WRITE_RETRY_DELAY_MS);
-                    }
-                }
-            }
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError, `BLE write failed after ${BLE_WRITE_MAX_RETRIES} attempts: ${(_c = lastError === null || lastError === void 0 ? void 0 : lastError.message) !== null && _c !== void 0 ? _c : lastError}`);
+            yield nobleBle.write(uuid, hexData);
         });
     }
     handleNotification(deviceId, hexData) {
         var _a, _b;
         if (hexData === 'PAIRING_REJECTED') {
             (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] Pairing rejection detected for device:', deviceId);
-            if (this.runPromise) {
-                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled);
+            const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled);
+            if (this.deviceProtocol.get(deviceId) === 'V2') {
+                this.rejectProtocolV2Frames(deviceId, error);
+            }
+            else if (this.runPromise) {
                 this.runPromise.reject(error);
-                this.rejectAllProtocolV2Frames(error);
             }
             return;
         }
@@ -1181,13 +1195,8 @@ class ElectronBleTransport {
         this.handleProtocolV1Notification(deviceId, hexData);
     }
     handleProtocolV2Notification(deviceId, hexData) {
-        var _a, _b, _c;
+        var _a;
         try {
-            if (!this.runPromise || ((_a = this.activeProtocolV2Call) === null || _a === void 0 ? void 0 : _a.uuid) !== deviceId) {
-                (_b = this.v2Assemblers.get(deviceId)) === null || _b === void 0 ? void 0 : _b.reset();
-                this.resetProtocolV2Frames(deviceId);
-                return;
-            }
             const bytes = transport.hexToBytes(hexData);
             if (bytes.length === 0)
                 return;
@@ -1199,12 +1208,9 @@ class ElectronBleTransport {
             }
         }
         catch (error) {
-            (_c = this.Log) === null || _c === void 0 ? void 0 : _c.error('[Electron BLE] Protocol V2 notification error:', error);
-            if (this.runPromise) {
-                const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
-                this.runPromise.reject(notifyError);
-                this.rejectAllProtocolV2Frames(notifyError);
-            }
+            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.error('[Electron BLE] Protocol V2 notification error:', error);
+            const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleWriteCharacteristicError);
+            this.rejectProtocolV2Frames(deviceId, notifyError);
         }
     }
     getProtocolV2FrameQueue(uuid) {
@@ -1235,9 +1241,13 @@ class ElectronBleTransport {
         this.v2FrameQueues.delete(uuid);
         this.v2FramePromises.delete(uuid);
     }
-    isActiveProtocolV2Call(uuid, token) {
-        var _a;
-        return ((_a = this.activeProtocolV2Call) === null || _a === void 0 ? void 0 : _a.uuid) === uuid && this.activeProtocolV2Call.token === token;
+    rejectProtocolV2Frames(uuid, error) {
+        this.v2FrameQueues.delete(uuid);
+        const framePromise = this.v2FramePromises.get(uuid);
+        if (framePromise) {
+            this.v2FramePromises.delete(uuid);
+            framePromise.reject(error);
+        }
     }
     readProtocolV2Frame(uuid) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1272,7 +1282,7 @@ class ElectronBleTransport {
         }
     }
     call(uuid, name, data, options) {
-        var _a, _b;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
@@ -1284,12 +1294,8 @@ class ElectronBleTransport {
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${uuid}`);
             }
-            if (shouldSuppressHighVolumeCallLog(name)) ;
-            else if (isLogBlockCommand(name)) {
-                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] call', 'name:', name, 'protocol:', protocol);
-            }
-            else {
-                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug('[Electron BLE] call', 'name:', name, 'data:', data, 'protocol:', protocol);
+            if (!shouldSuppressHighVolumeCallLog(name)) {
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('transport call', createTransportCallLog(name, protocol));
             }
             if (protocol === 'V2') {
                 return this.callProtocolV2(uuid, name, data, options);
@@ -1360,76 +1366,60 @@ class ElectronBleTransport {
         });
     }
     callProtocolV2(uuid, name, data, options) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._messages || !this._messagesV2) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            const forceRun = name === 'Initialize' || name === 'Cancel' || name === 'Ping';
-            if (this.runPromise) {
-                if (!forceRun) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
-                }
-                const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleForceCleanRunPromise);
-                this.runPromise.reject(error);
-                this.rejectAllProtocolV2Frames(error);
-                this.runPromise = null;
-                this.activeProtocolV2Call = null;
-            }
-            const runPromise = hdShared.createDeferred();
-            runPromise.promise.catch(() => undefined);
-            this.runPromise = runPromise;
-            const callToken = this.nextProtocolV2CallToken++;
-            this.activeProtocolV2Call = { uuid, token: callToken };
-            (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
-            this.resetProtocolV2Frames(uuid);
-            let completed = false;
-            const callOptions = Object.assign(Object.assign({}, options), { timeoutMs: (_b = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _b !== void 0 ? _b : BLE_RESPONSE_TIMEOUT_MS });
+            const callOptions = Object.assign(Object.assign({}, options), { timeoutMs: (_a = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _a !== void 0 ? _a : BLE_RESPONSE_TIMEOUT_MS });
             try {
-                const session = new transport.ProtocolV2Session({
-                    schemas: {
-                        protocolV1: this._messages,
-                        protocolV2: this._messagesV2,
-                    },
-                    router: transport.PROTOCOL_V2_CHANNEL_BLE_UART,
-                    writeFrame: (frame) => this.writeWithChunking(uuid, transport.bytesToHex(frame)),
-                    readFrame: () => __awaiter(this, void 0, void 0, function* () {
-                        const rxFrame = yield this.readProtocolV2Frame(uuid);
-                        if (!(rxFrame instanceof Uint8Array)) {
-                            throw new Error('Response is not Uint8Array');
-                        }
-                        return rxFrame;
-                    }),
-                    logger: this.Log,
-                    logPrefix: 'ProtocolV2 BLE',
-                    createTimeoutError: (_messageName, timeout) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `BLE response timeout after ${timeout}ms for ${name}`),
-                });
-                const result = yield session.call(name, data, callOptions);
-                completed = true;
-                return result;
+                return yield this.protocolV2Links.call(uuid, () => this.createProtocolV2Adapter(uuid), name, data, callOptions);
             }
             catch (e) {
-                if (this.isActiveProtocolV2Call(uuid, callToken)) {
-                    (_c = this.v2Assemblers.get(uuid)) === null || _c === void 0 ? void 0 : _c.reset();
-                    this.resetProtocolV2Frames(uuid);
-                }
-                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.error('[Electron BLE] Protocol V2 call error:', e);
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Electron BLE] Protocol V2 call error:', e);
                 throw e;
             }
-            finally {
-                if (this.isActiveProtocolV2Call(uuid, callToken)) {
-                    if (!completed) {
-                        (_e = this.v2Assemblers.get(uuid)) === null || _e === void 0 ? void 0 : _e.reset();
-                    }
-                    this.resetProtocolV2Frames(uuid);
-                    this.activeProtocolV2Call = null;
-                }
-                if (this.runPromise === runPromise) {
-                    this.runPromise = null;
-                }
-            }
         });
     }
+    createProtocolV2Adapter(uuid) {
+        var _a;
+        const generation = (_a = this.notificationTokens.get(uuid)) !== null && _a !== void 0 ? _a : 0;
+        const assertCurrentGeneration = () => {
+            if (this.notificationTokens.get(uuid) !== generation) {
+                throw new Error(`Protocol V2 notification generation changed for ${uuid}`);
+            }
+        };
+        return {
+            router: transport.PROTOCOL_V2_CHANNEL_BLE_UART,
+            generation,
+            prepareCall: () => {
+                var _a;
+                assertCurrentGeneration();
+                (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+                this.resetProtocolV2Frames(uuid);
+            },
+            writeFrame: (frame) => {
+                assertCurrentGeneration();
+                return this.writeWithChunking(uuid, transport.bytesToHex(frame));
+            },
+            readFrame: () => __awaiter(this, void 0, void 0, function* () {
+                assertCurrentGeneration();
+                const rxFrame = yield this.readProtocolV2Frame(uuid);
+                if (!(rxFrame instanceof Uint8Array)) {
+                    throw new Error('Response is not Uint8Array');
+                }
+                return rxFrame;
+            }),
+            reset: (reason) => {
+                var _a;
+                (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+                this.rejectProtocolV2Frames(uuid, new Error(reason));
+            },
+            logger: this.Log,
+            logPrefix: 'ProtocolV2 BLE',
+            createTimeoutError: (messageName, timeout) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `BLE response timeout after ${timeout}ms for ${messageName}`),
+        };
+    }
     processProtocolV1Notification(deviceId, hexData) {
         try {
             if (typeof hexData !== 'string') {

package/dist/transportLog.d.ts

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