@onekeyfe/hd-transport-lowlevel 1.2.0-alpha.8 → 1.2.0-alpha.9

package/__tests__/protocol-v2.test.js

@@ -196,6 +196,10 @@ describe('LowlevelTransport protocol framing', () => {
       },
     });
     expect(plugin.send).toHaveBeenCalled();
+    const sentSeqs = plugin.send.mock.calls.map(([, hex]) =>
+      Number.parseInt(hex.slice(12, 14), 16)
+    );
+    expect(sentSeqs).toEqual([1, 2]);
   });
 
   test('falls back to Protocol V2 probe for unnamed Protocol V2 devices', async () => {
@@ -218,6 +222,87 @@ describe('LowlevelTransport protocol framing', () => {
     expect(lowlevel.getProtocolType('unknown-pro2-id')).toBe('V2');
   });
 
+  test('retains the Protocol V2 hint and sequence cursor across release and reacquire', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const plugin = createPlugin({
+      devices: [{ id: 'reconnect-pro2-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [bytesToHex(probeResponse), bytesToHex(probeResponse)],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await lowlevel.enumerate();
+    await expect(lowlevel.acquire({ uuid: 'reconnect-pro2-id' })).resolves.toEqual({
+      uuid: 'reconnect-pro2-id',
+      protocolType: 'V2',
+    });
+    await lowlevel.release('reconnect-pro2-id');
+    await expect(lowlevel.acquire({ uuid: 'reconnect-pro2-id' })).resolves.toEqual({
+      uuid: 'reconnect-pro2-id',
+      protocolType: 'V2',
+    });
+
+    const sentSeqs = plugin.send.mock.calls.map(([, hex]) =>
+      Number.parseInt(hex.slice(12, 14), 16)
+    );
+    expect(sentSeqs).toEqual([1, 2]);
+  });
+
+  test('reuses the active generation when Core acquires the same BLE connection again', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const plugin = createPlugin({
+      devices: [{ id: 'repeated-acquire-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [bytesToHex(probeResponse), bytesToHex(probeResponse)],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(
+      lowlevel.acquire({ uuid: 'repeated-acquire-id', expectedProtocol: 'V2' })
+    ).resolves.toEqual({
+      uuid: 'repeated-acquire-id',
+      protocolType: 'V2',
+    });
+    await lowlevel.call('repeated-acquire-id', 'Ping', { message: 'first-acquire' });
+    await expect(
+      lowlevel.acquire({ uuid: 'repeated-acquire-id', expectedProtocol: 'V2' })
+    ).resolves.toEqual({
+      uuid: 'repeated-acquire-id',
+      protocolType: 'V2',
+    });
+    await lowlevel.call('repeated-acquire-id', 'Ping', { message: 'second-acquire' });
+
+    const sentSeqs = plugin.send.mock.calls.map(([, hex]) =>
+      Number.parseInt(hex.slice(12, 14), 16)
+    );
+    expect(sentSeqs).toEqual([1, 2]);
+  });
+
+  test('trusts explicit Protocol V2 during bootloader reconnect without probing Ping', async () => {
+    const plugin = createPlugin({
+      devices: [{ id: 'bootloader-v2-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(
+      lowlevel.acquire({ uuid: 'bootloader-v2-id', expectedProtocol: 'V2' })
+    ).resolves.toEqual({
+      uuid: 'bootloader-v2-id',
+      protocolType: 'V2',
+    });
+    expect(plugin.send).not.toHaveBeenCalled();
+    expect(plugin.receive).not.toHaveBeenCalled();
+  });
+
   test('resets the lowlevel connection before probing Protocol V2 after a V1 timeout', async () => {
     const probeResponse = ProtocolV2.encodeFrame(
       schemas,
@@ -256,6 +341,23 @@ describe('LowlevelTransport protocol framing', () => {
     expect(plugin.connect).toHaveBeenCalledTimes(2);
   });
 
+  test('disconnects a tainted Protocol V2 link after a response timeout', async () => {
+    const plugin = createPlugin({
+      devices: [{ id: 'timeout-v2-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [],
+    });
+    plugin.receive.mockImplementation(() => new Promise(() => {}));
+    const lowlevel = configureTransport(plugin);
+
+    await lowlevel.acquire({ uuid: 'timeout-v2-id', expectedProtocol: 'V2' });
+    plugin.disconnect.mockClear();
+    await expect(
+      lowlevel.call('timeout-v2-id', 'Ping', { message: 'timeout' }, { timeoutMs: 10 })
+    ).rejects.toThrow('Lowlevel response timeout after 10ms for Ping');
+
+    expect(plugin.disconnect).toHaveBeenCalledWith('timeout-v2-id');
+  });
+
   test('verifies expected Protocol V1 instead of trusting the requested protocol', async () => {
     const plugin = createPlugin({
       devices: [{ id: 'v2-id', name: 'Unknown BLE Device', commType: 'ble' }],

package/dist/index.d.ts

@@ -17,6 +17,9 @@ declare class LowlevelTransport {
     private deviceProtocol;
     private deviceProtocolHints;
     private protocolV2Assemblers;
+    private protocolV2Generations;
+    private connectedDevices;
+    private protocolV2Links;
     getProtocolType(path: string): ProtocolType | undefined;
     init(logger: any, emitter: EventEmitter, plugin: LowlevelTransportSharedPlugin): void;
     configure(signedData: any): void;
@@ -43,6 +46,8 @@ declare class LowlevelTransport {
     private readProtocolV2Frame;
     private writeProtocolV2Frame;
     private callProtocolV2;
+    private createProtocolV2Adapter;
+    private advanceProtocolV2Generation;
     cancel(): void;
 }
 

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,SAWN,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EACV,cAAc,EACd,6BAA6B,EAC7B,YAAY,EACZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAqBpD,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,SAAS,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEnE,WAAW,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAErE,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAEvB,MAAM,EAAE,6BAA6B,CAAuC;IAE5E,OAAO,CAAC,cAAc,CAAwC;IAE9D,OAAO,CAAC,mBAAmB,CAAwC;IAEnE,OAAO,CAAC,oBAAoB,CAAoD;IAEhF,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIvD,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,6BAA6B;IAO9E,SAAS,CAAC,UAAU,EAAE,GAAG;IAMzB,mBAAmB,CAAC,UAAU,EAAE,GAAG;IAInC,MAAM;IAIA,SAAS;IAWT,OAAO,CAAC,KAAK,EAAE,oBAAoB;;;;IAuBnC,OAAO,CAAC,IAAI,EAAE,MAAM;IAapB,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;YAmClB,cAAc;IAuC5B,OAAO,CAAC,0BAA0B;IAOlC,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,4BAA4B;IAOpC,OAAO,CAAC,kBAAkB;YAMZ,cAAc;YAsDd,yBAAyB;YA0BzB,eAAe;YAgBf,eAAe;YA6Bf,UAAU;YAUV,qBAAqB;YAmBrB,mBAAmB;YAqBnB,oBAAoB;YAOpB,cAAc;IAsC5B,MAAM;CAGP"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,SAYN,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EACV,cAAc,EACd,6BAA6B,EAC7B,YAAY,EACZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAqBpD,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,SAAS,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEnE,WAAW,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAErE,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAEvB,MAAM,EAAE,6BAA6B,CAAuC;IAE5E,OAAO,CAAC,cAAc,CAAwC;IAE9D,OAAO,CAAC,mBAAmB,CAAwC;IAEnE,OAAO,CAAC,oBAAoB,CAAoD;IAEhF,OAAO,CAAC,qBAAqB,CAAkC;IAE/D,OAAO,CAAC,gBAAgB,CAA0B;IAElD,OAAO,CAAC,eAAe,CA6BpB;IAEH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIvD,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,6BAA6B;IAO9E,SAAS,CAAC,UAAU,EAAE,GAAG;IAMzB,mBAAmB,CAAC,UAAU,EAAE,GAAG;IAOnC,MAAM;IAIA,SAAS;IAWT,OAAO,CAAC,KAAK,EAAE,oBAAoB;;;;IA6BnC,OAAO,CAAC,IAAI,EAAE,MAAM;IAgBpB,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;YAmClB,cAAc;IAuC5B,OAAO,CAAC,0BAA0B;IAOlC,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,4BAA4B;IAOpC,OAAO,CAAC,kBAAkB;YAMZ,cAAc;YAsDd,yBAAyB;YAiCzB,eAAe;YAgBf,eAAe;YA6Bf,UAAU;YAUV,qBAAqB;YAmBrB,mBAAmB;YAqBnB,oBAAoB;YAOpB,cAAc;IA6B5B,OAAO,CAAC,uBAAuB;IAkC/B,OAAO,CAAC,2BAA2B;IAMnC,MAAM;CAGP"}

package/dist/index.js

@@ -58,6 +58,38 @@ class LowlevelTransport {
         this.deviceProtocol = new Map();
         this.deviceProtocolHints = new Map();
         this.protocolV2Assemblers = new Map();
+        this.protocolV2Generations = new Map();
+        this.connectedDevices = new Set();
+        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, _c;
+                (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[LowlevelTransport] Protocol V2 link invalidated: ${uuid}`, reason);
+                if (reason.startsWith('Protocol V2 link-fatal error:')) {
+                    this.deviceProtocol.delete(uuid);
+                    this.advanceProtocolV2Generation(uuid);
+                    try {
+                        yield this.plugin.disconnect(uuid);
+                    }
+                    catch (error) {
+                        (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[LowlevelTransport] disconnect tainted Protocol V2 link failed: ${uuid}`, error);
+                    }
+                    finally {
+                        this.connectedDevices.delete(uuid);
+                    }
+                }
+            }),
+        });
     }
     getProtocolType(path) {
         return this.deviceProtocol.get(path);
@@ -75,6 +107,9 @@ class LowlevelTransport {
     }
     configureProtocolV2(signedData) {
         this._messagesV2 = parseConfigure(signedData);
+        this.protocolV2Links
+            .invalidateAllLinks('Protocol V2 schema reconfigured')
+            .catch(error => { var _a; return (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('Protocol V2 schema link cleanup failed:', error); });
     }
     listen() {
     }
@@ -93,10 +128,16 @@ class LowlevelTransport {
     acquire(input) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const alreadyConnected = this.connectedDevices.has(input.uuid);
             try {
                 yield this.plugin.connect(input.uuid);
+                if (!alreadyConnected) {
+                    this.connectedDevices.add(input.uuid);
+                    this.advanceProtocolV2Generation(input.uuid);
+                }
             }
             catch (error) {
+                this.connectedDevices.delete(input.uuid);
                 this.Log.debug('lowlelvel transport connect error: ', error);
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.LowlevelTrasnportConnectError, (_a = error.message) !== null && _a !== void 0 ? _a : error);
             }
@@ -111,9 +152,10 @@ class LowlevelTransport {
     release(uuid) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                yield this.protocolV2Links.invalidateLink(uuid, 'Lowlevel transport released');
                 yield this.plugin.disconnect(uuid);
+                this.connectedDevices.delete(uuid);
                 this.deviceProtocol.delete(uuid);
-                this.deviceProtocolHints.delete(uuid);
                 this.protocolV2Assemblers.delete(uuid);
                 return true;
             }
@@ -163,7 +205,7 @@ class LowlevelTransport {
                 }
             }
             try {
-                const response = yield this.readProtocolV1Message(options === null || options === void 0 ? void 0 : options.timeoutMs);
+                const response = yield this.readProtocolV1Message(uuid, options === null || options === void 0 ? void 0 : options.timeoutMs);
                 this.Log.debug('receive data: ', response);
                 const jsonData = ProtocolV1.decodeMessage(messages, response);
                 return check.call(jsonData);
@@ -197,12 +239,9 @@ class LowlevelTransport {
         var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, function* () {
             if (expectedProtocol === 'V2') {
-                if (yield this.probeProtocolV2(uuid)) {
-                    this.deviceProtocol.set(uuid, 'V2');
-                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
-                    return 'V2';
-                }
-                throw this.createProtocolMismatchError(expectedProtocol);
+                this.deviceProtocol.set(uuid, 'V2');
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+                return 'V2';
             }
             if (expectedProtocol === 'V1') {
                 if (yield this.probeProtocolV1(uuid)) {
@@ -242,8 +281,10 @@ class LowlevelTransport {
     resetConnectionAfterProbe(uuid, protocol) {
         var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
+            yield this.protocolV2Links.invalidateLink(uuid, `Reset connection after Protocol ${protocol} probe`);
             (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
             try {
+                this.connectedDevices.delete(uuid);
                 yield this.plugin.disconnect(uuid);
             }
             catch (error) {
@@ -251,6 +292,8 @@ class LowlevelTransport {
             }
             try {
                 yield this.plugin.connect(uuid);
+                this.connectedDevices.add(uuid);
+                this.advanceProtocolV2Generation(uuid);
             }
             catch (error) {
                 (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[LowlevelTransport] reconnect after Protocol ${protocol} probe failed:`, error);
@@ -307,18 +350,18 @@ class LowlevelTransport {
             }
         });
     }
-    receiveHex(timeoutMs, commandName) {
+    receiveHex(uuid, timeoutMs, commandName) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield transport.withProtocolTimeout(this.plugin.receive(), timeoutMs, () => this.createProtocolTimeoutError(commandName, timeoutMs !== null && timeoutMs !== void 0 ? timeoutMs : 0));
+            const response = yield transport.withProtocolTimeout(this.plugin.receive(uuid), timeoutMs, () => this.createProtocolTimeoutError(commandName, timeoutMs !== null && timeoutMs !== void 0 ? timeoutMs : 0));
             if (typeof response !== 'string') {
                 throw new Error('Returning data is not string');
             }
             return response;
         });
     }
-    readProtocolV1Message(timeoutMs) {
+    readProtocolV1Message(uuid, timeoutMs) {
         return __awaiter(this, void 0, void 0, function* () {
-            const first = yield this.receiveHex(timeoutMs, 'ProtocolV1');
+            const first = yield this.receiveHex(uuid, timeoutMs, 'ProtocolV1');
             const firstData = transport.hexToBytes(first);
             if (!isProtocolV1TransportChunk(firstData)) {
                 return first;
@@ -327,13 +370,13 @@ class LowlevelTransport {
             let buffer = firstData.slice(3);
             const expectedLength = transport.PROTOCOL_V1_MESSAGE_HEADER_SIZE + payloadLength;
             while (buffer.length < expectedLength) {
-                const next = yield this.receiveHex(timeoutMs, 'ProtocolV1');
+                const next = yield this.receiveHex(uuid, timeoutMs, 'ProtocolV1');
                 buffer = transport.concatUint8Arrays([buffer, transport.hexToBytes(next)]);
             }
             return transport.bytesToHex(buffer.slice(0, expectedLength));
         });
     }
-    readProtocolV2Frame(uuid, timeoutMs) {
+    readProtocolV2Frame(uuid, timeoutMs, commandName = 'ProtocolV2') {
         return __awaiter(this, void 0, void 0, function* () {
             let assembler = this.protocolV2Assemblers.get(uuid);
             if (!assembler) {
@@ -345,7 +388,7 @@ class LowlevelTransport {
                 return queuedFrame;
             let frame;
             while (!frame) {
-                const response = yield this.receiveHex(timeoutMs, 'ProtocolV2');
+                const response = yield this.receiveHex(uuid, timeoutMs, commandName);
                 const chunk = transport.hexToBytes(response);
                 if (chunk.length > 0) {
                     frame = assembler.push(chunk);
@@ -363,35 +406,61 @@ class LowlevelTransport {
         });
     }
     callProtocolV2(uuid, name, data, options) {
-        var _a, _b, _c;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._messages || !this._messagesV2) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
             const timeoutMs = (_a = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _a !== void 0 ? _a : LOWLEVEL_PROTOCOL_TIMEOUT_MS;
-            (_b = this.protocolV2Assemblers.get(uuid)) === null || _b === void 0 ? void 0 : _b.reset();
-            const session = new transport.ProtocolV2Session({
-                schemas: {
-                    protocolV1: this._messages,
-                    protocolV2: this._messagesV2,
-                },
-                router: transport.PROTOCOL_V2_CHANNEL_BLE_UART,
-                writeFrame: (frame) => this.writeProtocolV2Frame(uuid, frame),
-                readFrame: () => this.readProtocolV2Frame(uuid, timeoutMs),
-                logger: this.Log,
-                logPrefix: 'ProtocolV2 Lowlevel-BLE',
-                createTimeoutError: (_messageName, timeout) => this.createProtocolTimeoutError(name, timeout),
-            });
             try {
-                return yield session.call(name, data, Object.assign(Object.assign({}, options), { timeoutMs }));
+                return yield this.protocolV2Links.call(uuid, () => this.createProtocolV2Adapter(uuid), name, data, Object.assign(Object.assign({}, options), { timeoutMs }));
             }
             catch (e) {
-                (_c = this.protocolV2Assemblers.get(uuid)) === null || _c === void 0 ? void 0 : _c.reset();
                 this.Log.error('lowlevel Protocol V2 call error: ', e);
                 throw e;
             }
         });
     }
+    createProtocolV2Adapter(uuid) {
+        var _a;
+        const generation = (_a = this.protocolV2Generations.get(uuid)) !== null && _a !== void 0 ? _a : 0;
+        const assertCurrentGeneration = () => {
+            if (this.protocolV2Generations.get(uuid) !== generation) {
+                throw new Error(`Protocol V2 connection generation changed for ${uuid}`);
+            }
+        };
+        return {
+            router: transport.PROTOCOL_V2_CHANNEL_BLE_UART,
+            maxFrameBytes: transport.PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
+            generation,
+            prepareCall: () => {
+                var _a;
+                assertCurrentGeneration();
+                (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+            },
+            writeFrame: (frame) => {
+                assertCurrentGeneration();
+                return this.writeProtocolV2Frame(uuid, frame);
+            },
+            readFrame: (context) => {
+                assertCurrentGeneration();
+                return this.readProtocolV2Frame(uuid, context.timeoutMs, context.messageName);
+            },
+            reset: () => {
+                var _a;
+                (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+            },
+            logger: this.Log,
+            logPrefix: 'ProtocolV2 Lowlevel-BLE',
+            createTimeoutError: (messageName, timeout) => this.createProtocolTimeoutError(messageName, timeout),
+        };
+    }
+    advanceProtocolV2Generation(uuid) {
+        var _a;
+        const nextGeneration = ((_a = this.protocolV2Generations.get(uuid)) !== null && _a !== void 0 ? _a : 0) + 1;
+        this.protocolV2Generations.set(uuid, nextGeneration);
+        return nextGeneration;
+    }
     cancel() {
         this.Log.debug('lowlevel-transport', 'cancel');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-lowlevel",
-  "version": "1.2.0-alpha.8",
+  "version": "1.2.0-alpha.9",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,8 +20,8 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.8",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.8"
+    "@onekeyfe/hd-shared": "1.2.0-alpha.9",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.9"
   },
-  "gitHead": "d2b1323e5ad9c373e72d4d092f35c9f274c1fd74"
+  "gitHead": "f90ef9921b742f68cce9f4e7a0425e45e8ae7ec9"
 }

package/src/index.ts

@@ -2,9 +2,10 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import transport, {
   LogBlockCommand,
   PROTOCOL_V1_MESSAGE_HEADER_SIZE,
+  PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
   PROTOCOL_V2_CHANNEL_BLE_UART,
   ProtocolV2FrameAssembler,
-  ProtocolV2Session,
+  ProtocolV2LinkManager,
   bytesToHex,
   concatUint8Arrays,
   hexToBytes,
@@ -59,6 +60,41 @@ export default class LowlevelTransport {
 
   private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
 
+  private protocolV2Generations: Map<string, number> = new Map();
+
+  private connectedDevices: Set<string> = new Set();
+
+  private protocolV2Links = new ProtocolV2LinkManager<string>({
+    getSchemas: () => {
+      if (!this._messages || !this._messagesV2) {
+        throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+      }
+      return {
+        protocolV1: this._messages,
+        protocolV2: this._messagesV2,
+      };
+    },
+    classifyError: () => 'link-fatal',
+    onLinkInvalidated: async (uuid, reason) => {
+      this.protocolV2Assemblers.get(uuid)?.reset();
+      this.Log?.debug(`[LowlevelTransport] Protocol V2 link invalidated: ${uuid}`, reason);
+      if (reason.startsWith('Protocol V2 link-fatal error:')) {
+        this.deviceProtocol.delete(uuid);
+        this.advanceProtocolV2Generation(uuid);
+        try {
+          await this.plugin.disconnect(uuid);
+        } catch (error) {
+          this.Log?.debug(
+            `[LowlevelTransport] disconnect tainted Protocol V2 link failed: ${uuid}`,
+            error
+          );
+        } finally {
+          this.connectedDevices.delete(uuid);
+        }
+      }
+    },
+  });
+
   getProtocolType(path: string): ProtocolType | undefined {
     return this.deviceProtocol.get(path);
   }
@@ -78,6 +114,9 @@ export default class LowlevelTransport {
 
   configureProtocolV2(signedData: any) {
     this._messagesV2 = parseConfigure(signedData);
+    this.protocolV2Links
+      .invalidateAllLinks('Protocol V2 schema reconfigured')
+      .catch(error => this.Log?.debug('Protocol V2 schema link cleanup failed:', error));
   }
 
   listen() {
@@ -96,9 +135,15 @@ export default class LowlevelTransport {
   }
 
   async acquire(input: LowLevelAcquireInput) {
+    const alreadyConnected = this.connectedDevices.has(input.uuid);
     try {
       await this.plugin.connect(input.uuid);
+      if (!alreadyConnected) {
+        this.connectedDevices.add(input.uuid);
+        this.advanceProtocolV2Generation(input.uuid);
+      }
     } catch (error) {
+      this.connectedDevices.delete(input.uuid);
       this.Log.debug('lowlelvel transport connect error: ', error);
       throw ERRORS.TypedError(
         HardwareErrorCode.LowlevelTrasnportConnectError,
@@ -120,9 +165,12 @@ export default class LowlevelTransport {
 
   async release(uuid: string) {
     try {
+      await this.protocolV2Links.invalidateLink(uuid, 'Lowlevel transport released');
       await this.plugin.disconnect(uuid);
+      this.connectedDevices.delete(uuid);
       this.deviceProtocol.delete(uuid);
-      this.deviceProtocolHints.delete(uuid);
+      // 设备名称推断出的协议提示不依赖当前连接，保留它可以让快速重连
+      // 直接执行 Protocol V2 探测，避免先发送一次无意义的 V1 Initialize。
       this.protocolV2Assemblers.delete(uuid);
       return true;
     } catch (error) {
@@ -195,7 +243,7 @@ export default class LowlevelTransport {
     }
 
     try {
-      const response = await this.readProtocolV1Message(options?.timeoutMs);
+      const response = await this.readProtocolV1Message(uuid, options?.timeoutMs);
       this.Log.debug('receive data: ', response);
       const jsonData = ProtocolV1.decodeMessage(messages, response);
       return check.call(jsonData);
@@ -242,12 +290,12 @@ export default class LowlevelTransport {
     protocolHint?: ProtocolType
   ): Promise<ProtocolType> {
     if (expectedProtocol === 'V2') {
-      if (await this.probeProtocolV2(uuid)) {
-        this.deviceProtocol.set(uuid, 'V2');
-        this.Log?.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
-        return 'V2';
-      }
-      throw this.createProtocolMismatchError(expectedProtocol);
+      // 固件升级重启后的 bootloader 不保证响应 Ping。上层显式传入 V2
+      // 表示协议已经在重启前确认，这里与 RN/Electron BLE 保持一致，
+      // 直接建立 V2 Link，首个业务命令负责验证链路是否可用。
+      this.deviceProtocol.set(uuid, 'V2');
+      this.Log?.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+      return 'V2';
     }
 
     if (expectedProtocol === 'V1') {
@@ -291,9 +339,14 @@ export default class LowlevelTransport {
   }
 
   private async resetConnectionAfterProbe(uuid: string, protocol: ProtocolType) {
+    await this.protocolV2Links.invalidateLink(
+      uuid,
+      `Reset connection after Protocol ${protocol} probe`
+    );
     this.protocolV2Assemblers.get(uuid)?.reset();
 
     try {
+      this.connectedDevices.delete(uuid);
       await this.plugin.disconnect(uuid);
     } catch (error) {
       this.Log?.debug(
@@ -304,6 +357,8 @@ export default class LowlevelTransport {
 
     try {
       await this.plugin.connect(uuid);
+      this.connectedDevices.add(uuid);
+      this.advanceProtocolV2Generation(uuid);
     } catch (error) {
       this.Log?.debug(
         `[LowlevelTransport] reconnect after Protocol ${protocol} probe failed:`,
@@ -361,8 +416,8 @@ export default class LowlevelTransport {
     }
   }
 
-  private async receiveHex(timeoutMs: number | undefined, commandName: string) {
-    const response = await withProtocolTimeout(this.plugin.receive(), timeoutMs, () =>
+  private async receiveHex(uuid: string, timeoutMs: number | undefined, commandName: string) {
+    const response = await withProtocolTimeout(this.plugin.receive(uuid), timeoutMs, () =>
       this.createProtocolTimeoutError(commandName, timeoutMs ?? 0)
     );
     if (typeof response !== 'string') {
@@ -371,8 +426,8 @@ export default class LowlevelTransport {
     return response;
   }
 
-  private async readProtocolV1Message(timeoutMs?: number) {
-    const first = await this.receiveHex(timeoutMs, 'ProtocolV1');
+  private async readProtocolV1Message(uuid: string, timeoutMs?: number) {
+    const first = await this.receiveHex(uuid, timeoutMs, 'ProtocolV1');
     const firstData = hexToBytes(first);
     if (!isProtocolV1TransportChunk(firstData)) {
       return first;
@@ -383,14 +438,14 @@ export default class LowlevelTransport {
     const expectedLength = PROTOCOL_V1_MESSAGE_HEADER_SIZE + payloadLength;
 
     while (buffer.length < expectedLength) {
-      const next = await this.receiveHex(timeoutMs, 'ProtocolV1');
+      const next = await this.receiveHex(uuid, timeoutMs, 'ProtocolV1');
       buffer = concatUint8Arrays([buffer, hexToBytes(next)]);
     }
 
     return bytesToHex(buffer.slice(0, expectedLength));
   }
 
-  private async readProtocolV2Frame(uuid: string, timeoutMs?: number) {
+  private async readProtocolV2Frame(uuid: string, timeoutMs?: number, commandName = 'ProtocolV2') {
     let assembler = this.protocolV2Assemblers.get(uuid);
     if (!assembler) {
       assembler = new ProtocolV2FrameAssembler();
@@ -402,7 +457,7 @@ export default class LowlevelTransport {
 
     let frame: Uint8Array | undefined;
     while (!frame) {
-      const response = await this.receiveHex(timeoutMs, 'ProtocolV2');
+      const response = await this.receiveHex(uuid, timeoutMs, commandName);
       const chunk = hexToBytes(response);
       if (chunk.length > 0) {
         frame = assembler.push(chunk);
@@ -429,33 +484,64 @@ export default class LowlevelTransport {
     }
 
     const timeoutMs = options?.timeoutMs ?? LOWLEVEL_PROTOCOL_TIMEOUT_MS;
-    this.protocolV2Assemblers.get(uuid)?.reset();
-    const session = new ProtocolV2Session({
-      schemas: {
-        protocolV1: this._messages,
-        protocolV2: this._messagesV2,
-      },
-      router: PROTOCOL_V2_CHANNEL_BLE_UART,
-      writeFrame: (frame: Uint8Array) => this.writeProtocolV2Frame(uuid, frame),
-      readFrame: () => this.readProtocolV2Frame(uuid, timeoutMs),
-      logger: this.Log,
-      logPrefix: 'ProtocolV2 Lowlevel-BLE',
-      createTimeoutError: (_messageName: string, timeout: number) =>
-        this.createProtocolTimeoutError(name, timeout),
-    });
 
     try {
-      return await session.call(name, data, {
-        ...options,
-        timeoutMs,
-      });
+      return await this.protocolV2Links.call(
+        uuid,
+        () => this.createProtocolV2Adapter(uuid),
+        name,
+        data,
+        {
+          ...options,
+          timeoutMs,
+        }
+      );
     } catch (e) {
-      this.protocolV2Assemblers.get(uuid)?.reset();
       this.Log.error('lowlevel Protocol V2 call error: ', e);
       throw e;
     }
   }
 
+  private createProtocolV2Adapter(uuid: string) {
+    const generation = this.protocolV2Generations.get(uuid) ?? 0;
+    const assertCurrentGeneration = () => {
+      if (this.protocolV2Generations.get(uuid) !== generation) {
+        throw new Error(`Protocol V2 connection generation changed for ${uuid}`);
+      }
+    };
+
+    return {
+      router: PROTOCOL_V2_CHANNEL_BLE_UART,
+      maxFrameBytes: PROTOCOL_V2_BLE_FRAME_MAX_BYTES,
+      generation,
+      prepareCall: () => {
+        assertCurrentGeneration();
+        this.protocolV2Assemblers.get(uuid)?.reset();
+      },
+      writeFrame: (frame: Uint8Array) => {
+        assertCurrentGeneration();
+        return this.writeProtocolV2Frame(uuid, frame);
+      },
+      readFrame: (context: { messageName: string; timeoutMs?: number }) => {
+        assertCurrentGeneration();
+        return this.readProtocolV2Frame(uuid, context.timeoutMs, context.messageName);
+      },
+      reset: () => {
+        this.protocolV2Assemblers.get(uuid)?.reset();
+      },
+      logger: this.Log,
+      logPrefix: 'ProtocolV2 Lowlevel-BLE',
+      createTimeoutError: (messageName: string, timeout: number) =>
+        this.createProtocolTimeoutError(messageName, timeout),
+    };
+  }
+
+  private advanceProtocolV2Generation(uuid: string) {
+    const nextGeneration = (this.protocolV2Generations.get(uuid) ?? 0) + 1;
+    this.protocolV2Generations.set(uuid, nextGeneration);
+    return nextGeneration;
+  }
+
   cancel() {
     this.Log.debug('lowlevel-transport', 'cancel');
   }