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

package/__tests__/firmware-upload-progress.test.js

@@ -0,0 +1,42 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const { getProtocolV1SendOptions, shouldLogFirmwareUploadProgress } = require('../src');
+
+describe('firmware upload progress logging', () => {
+  test('按 5% 进度限流打印', () => {
+    expect(
+      shouldLogFirmwareUploadProgress({
+        percent: 9,
+        lastLoggedPercent: 5,
+        now: 5_000,
+        lastLoggedAt: 0,
+      })
+    ).toBe(false);
+
+    expect(
+      shouldLogFirmwareUploadProgress({
+        percent: 10,
+        lastLoggedPercent: 5,
+        now: 5_000,
+        lastLoggedAt: 0,
+      })
+    ).toBe(true);
+  });
+
+  test('进度不足 5% 时最长每 10 秒打印一次心跳', () => {
+    expect(
+      shouldLogFirmwareUploadProgress({
+        percent: 7,
+        lastLoggedPercent: 5,
+        now: 10_000,
+        lastLoggedAt: 0,
+      })
+    ).toBe(true);
+  });
+});
+
+describe('firmware upload write mode', () => {
+  test('固件上传使用带响应写入，普通命令保持默认模式', () => {
+    expect(getProtocolV1SendOptions('FirmwareUpload')).toEqual({ withoutResponse: false });
+    expect(getProtocolV1SendOptions('Initialize')).toBeUndefined();
+  });
+});

package/__tests__/protocol-v2.test.js

@@ -122,6 +122,49 @@ const splitFrame = (frame, index) => [
 ];
 
 describe('LowlevelTransport protocol framing', () => {
+  test('falls back to Protocol V2 when a cached V1 hint is stale', async () => {
+    const plugin = createPlugin({ devices: [], responses: [] });
+    const lowlevel = configureTransport(plugin);
+    const events = [];
+    lowlevel.probeProtocolV1 = jest.fn().mockImplementation(() => {
+      events.push('probe-v1');
+      return Promise.resolve(false);
+    });
+    lowlevel.resetConnectionAfterProbe = jest.fn().mockImplementation(() => {
+      events.push('reset');
+      return Promise.resolve();
+    });
+    lowlevel.probeProtocolV2 = jest.fn().mockImplementation(() => {
+      events.push('probe-v2');
+      return Promise.resolve(true);
+    });
+
+    await expect(lowlevel.detectProtocol('pro-lowlevel', undefined, 'V1')).resolves.toBe('V2');
+
+    expect(events).toEqual(['probe-v1', 'reset', 'probe-v2']);
+    expect(lowlevel.getProtocolType('pro-lowlevel')).toBe('V2');
+  });
+
+  test('keeps active links when the Protocol V2 schema is configured repeatedly', () => {
+    const lowlevel = new LowlevelTransport();
+    const invalidateAllLinks = jest.fn().mockResolvedValue(undefined);
+    lowlevel.protocolV2Links.invalidateAllLinks = invalidateAllLinks;
+
+    lowlevel.configureProtocolV2(protocolV2Schema);
+    lowlevel.configureProtocolV2(protocolV2Schema);
+
+    expect(invalidateAllLinks).not.toHaveBeenCalled();
+
+    lowlevel.configureProtocolV2({
+      nested: {
+        ...protocolV2Schema.nested,
+        ExtraMessage: { fields: {} },
+      },
+    });
+
+    expect(invalidateAllLinks).toHaveBeenCalledWith('Protocol V2 schema reconfigured');
+  });
+
   test('keeps Protocol V1 raw notification chunks compatible', async () => {
     const responseChunks = ProtocolV1.encodeTransportPackets(schemas.protocolV1, 'Success', {
       message: 'ok',
@@ -142,6 +185,23 @@ describe('LowlevelTransport protocol framing', () => {
     });
   });
 
+  test('uses the Protocol V2 BLE writer with the lowlevel compatibility packet size', async () => {
+    const plugin = createPlugin({ devices: [], responses: [] });
+    const lowlevel = configureTransport(plugin);
+    const context = {
+      messageName: 'Ping',
+      timeoutMs: 1000,
+      highThroughput: false,
+      generation: 1,
+      signal: new AbortController().signal,
+    };
+
+    await lowlevel.writeProtocolV2Frame('pro2-id', new Uint8Array(130), context, jest.fn());
+
+    expect(plugin.send).toHaveBeenCalledTimes(3);
+    expect(plugin.send.mock.calls.map(([, hex]) => hex.length / 2)).toEqual([64, 64, 2]);
+  });
+
   test('rejects calls before protocol detection', async () => {
     const responseChunks = ProtocolV1.encodeTransportPackets(schemas.protocolV1, 'Success', {
       message: 'ok',
@@ -172,7 +232,7 @@ describe('LowlevelTransport protocol framing', () => {
         supported_messages: [60200, 60201, 60206, 60207],
         protobuf_definition: 'onekey-protocol-v2',
       },
-      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART, seq: 2 }
     );
     const plugin = createPlugin({
       devices: [{ id: 'pro2-id', name: 'OneKey Pro 2', commType: 'ble' }],
@@ -196,6 +256,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 +282,97 @@ 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 responses = [1, 2, 3, 4].map(seq =>
+      bytesToHex(
+        ProtocolV2.encodeFrame(
+          schemas,
+          'Success',
+          { message: 'ok' },
+          { router: PROTOCOL_V2_CHANNEL_BLE_UART, seq }
+        )
+      )
+    );
+    const plugin = createPlugin({
+      devices: [{ id: 'repeated-acquire-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses,
+    });
+    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, 3, 4]);
+  });
+
+  test('actively probes explicit Protocol V2 during bootloader reconnect', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const plugin = createPlugin({
+      devices: [{ id: 'bootloader-v2-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [bytesToHex(probeResponse)],
+    });
+    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).toHaveBeenCalledTimes(1);
+    expect(plugin.receive).toHaveBeenCalledTimes(1);
+  });
+
   test('resets the lowlevel connection before probing Protocol V2 after a V1 timeout', async () => {
     const probeResponse = ProtocolV2.encodeFrame(
       schemas,
@@ -256,6 +411,57 @@ describe('LowlevelTransport protocol framing', () => {
     expect(plugin.connect).toHaveBeenCalledTimes(2);
   });
 
+  test('disconnects a tainted Protocol V2 link after a response timeout', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const plugin = createPlugin({
+      devices: [{ id: 'timeout-v2-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [bytesToHex(probeResponse)],
+    });
+    let receiveCount = 0;
+    plugin.receive.mockImplementation(() => {
+      receiveCount += 1;
+      return receiveCount === 1
+        ? Promise.resolve(bytesToHex(probeResponse))
+        : 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('preserves an undefined business timeout outside explicit probes', async () => {
+    const plugin = createPlugin({
+      devices: [{ id: 'v2-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [],
+    });
+    const lowlevel = configureTransport(plugin);
+    lowlevel.deviceProtocol.set('v2-id', 'V2');
+    const linkCall = jest
+      .spyOn(lowlevel.protocolV2Links, 'call')
+      .mockResolvedValue({ type: 'Success', message: {} });
+
+    await lowlevel.call('v2-id', 'Ping', { message: 'no-business-timeout' });
+
+    expect(linkCall).toHaveBeenCalledWith(
+      'v2-id',
+      expect.any(Function),
+      'Ping',
+      { message: 'no-business-timeout' },
+      undefined
+    );
+  });
+
   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

@@ -5,8 +5,18 @@ import EventEmitter from 'events';
 type LowLevelAcquireInput = {
     uuid: string;
     expectedProtocol?: ProtocolType;
+    protocolHint?: ProtocolType;
 };
 
+declare function shouldLogFirmwareUploadProgress({ percent, lastLoggedPercent, now, lastLoggedAt, }: {
+    percent: number;
+    lastLoggedPercent: number;
+    now: number;
+    lastLoggedAt: number;
+}): boolean;
+declare function getProtocolV1SendOptions(name: string): {
+    withoutResponse: boolean;
+} | undefined;
 declare class LowlevelTransport {
     _messages: ReturnType<typeof transport__default.parseConfigure> | undefined;
     _messagesV2: ReturnType<typeof transport__default.parseConfigure> | undefined;
@@ -17,6 +27,10 @@ declare class LowlevelTransport {
     private deviceProtocol;
     private deviceProtocolHints;
     private protocolV2Assemblers;
+    private protocolV2Generations;
+    private connectedDevices;
+    private protocolV2Links;
+    private protocolV2SchemaConfiguration;
     getProtocolType(path: string): ProtocolType | undefined;
     init(logger: any, emitter: EventEmitter, plugin: LowlevelTransportSharedPlugin): void;
     configure(signedData: any): void;
@@ -43,7 +57,9 @@ declare class LowlevelTransport {
     private readProtocolV2Frame;
     private writeProtocolV2Frame;
     private callProtocolV2;
+    private createProtocolV2Adapter;
+    private advanceProtocolV2Generation;
     cancel(): void;
 }
 
-export { LowlevelTransport as default };
+export { LowlevelTransport as default, getProtocolV1SendOptions, shouldLogFirmwareUploadProgress };

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,EAEZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAUpD,wBAAgB,+BAA+B,CAAC,EAC9C,OAAO,EACP,iBAAiB,EACjB,GAAG,EACH,YAAY,GACb,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;CACtB,WAMA;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM;;cAEpD;AAcD,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,OAAO,CAAC,6BAA6B,CAAqB;IAE1D,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;IAiBnC,MAAM;IAIA,SAAS;IAWT,OAAO,CAAC,KAAK,EAAE,oBAAoB;;;;IAgCnC,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;YAsBlB,cAAc;IA6E5B,OAAO,CAAC,0BAA0B;IAOlC,OAAO,CAAC,2BAA2B;IAOnC,OAAO,CAAC,4BAA4B;IAOpC,OAAO,CAAC,kBAAkB;YAMZ,cAAc;YA2Cd,yBAAyB;YAiCzB,eAAe;YAgBf,eAAe;YA6Bf,UAAU;YAUV,qBAAqB;YAmBrB,mBAAmB;YAqBnB,oBAAoB;YAgBpB,cAAc;IAwB5B,OAAO,CAAC,uBAAuB;IAgC/B,OAAO,CAAC,2BAA2B;IAMnC,MAAM;CAGP"}

package/dist/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var hdShared = require('@onekeyfe/hd-shared');
 var transport = require('@onekeyfe/hd-transport');
 
@@ -40,8 +42,17 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 const { check, ProtocolV1, parseConfigure } = transport__default["default"];
 const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
 const PROTOCOL_V2_PROBE_TIMEOUT_MS = 5000;
-const LOWLEVEL_PROTOCOL_TIMEOUT_MS = 30000;
 const LOWLEVEL_PROTOCOL_V2_PACKET_LENGTH = 64;
+const FIRMWARE_UPLOAD_LOG_PERCENT_STEP = 5;
+const FIRMWARE_UPLOAD_LOG_INTERVAL_MS = 10000;
+function shouldLogFirmwareUploadProgress({ percent, lastLoggedPercent, now, lastLoggedAt, }) {
+    return (percent === 100 ||
+        percent - lastLoggedPercent >= FIRMWARE_UPLOAD_LOG_PERCENT_STEP ||
+        now - lastLoggedAt >= FIRMWARE_UPLOAD_LOG_INTERVAL_MS);
+}
+function getProtocolV1SendOptions(name) {
+    return name === 'FirmwareUpload' ? { withoutResponse: false } : undefined;
+}
 function inferProtocolHintFromDeviceName(name) {
     return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
 }
@@ -58,6 +69,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);
@@ -74,7 +117,18 @@ class LowlevelTransport {
         this._messages = messages;
     }
     configureProtocolV2(signedData) {
+        const configuration = typeof signedData === 'string' ? signedData : JSON.stringify(signedData);
+        if (this.protocolV2SchemaConfiguration === configuration) {
+            return;
+        }
+        const isReconfiguration = this.protocolV2SchemaConfiguration !== undefined;
         this._messagesV2 = parseConfigure(signedData);
+        this.protocolV2SchemaConfiguration = configuration;
+        if (isReconfiguration) {
+            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() {
     }
@@ -91,19 +145,25 @@ class LowlevelTransport {
         });
     }
     acquire(input) {
-        var _a;
+        var _a, _b;
         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);
             }
-            this.protocolV2Assemblers.set(input.uuid, new transport.ProtocolV2FrameAssembler());
+            this.protocolV2Assemblers.set(input.uuid, new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_BLE_FRAME_MAX_BYTES));
             const protocolHint = input.expectedProtocol
                 ? undefined
-                : this.deviceProtocolHints.get(input.uuid);
+                : (_b = input.protocolHint) !== null && _b !== void 0 ? _b : this.deviceProtocolHints.get(input.uuid);
             const protocolType = yield this.detectProtocol(input.uuid, input.expectedProtocol, protocolHint);
             return { uuid: input.uuid, protocolType };
         });
@@ -111,9 +171,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;
             }
@@ -132,12 +193,7 @@ class LowlevelTransport {
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${uuid}`);
             }
-            if (transport.LogBlockCommand.has(name)) {
-                this.Log.debug('lowlevel-transport', 'call-', ' name: ', name, ' protocol: ', protocol);
-            }
-            else {
-                this.Log.debug('lowlevel-transport', 'call-', ' name: ', name, ' data: ', data, ' protocol: ', protocol);
-            }
+            this.Log.debug('transport call', { name, protocol });
             if (protocol === 'V2') {
                 return this.callProtocolV2(uuid, name, data, options);
             }
@@ -145,17 +201,42 @@ class LowlevelTransport {
         });
     }
     callProtocolV1(uuid, name, data, options) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
             const messages = this._messages;
             const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
-            for (const o of buffers) {
+            const isFirmwareUpload = name === 'FirmwareUpload';
+            const uploadStartedAt = Date.now();
+            const totalBytes = buffers.reduce((sum, buffer) => sum + buffer.limit, 0);
+            let sentBytes = 0;
+            let lastLoggedPercent = 0;
+            let lastLoggedAt = uploadStartedAt;
+            for (const [index, o] of buffers.entries()) {
                 const outData = o.toString('hex');
-                this.Log.debug('send hex strting: ', outData);
                 try {
-                    yield this.plugin.send(uuid, outData);
+                    yield this.plugin.send(uuid, outData, getProtocolV1SendOptions(name));
+                    sentBytes += o.limit;
+                    if (isFirmwareUpload) {
+                        const now = Date.now();
+                        const percent = Math.floor(((index + 1) / buffers.length) * 100);
+                        if (shouldLogFirmwareUploadProgress({
+                            percent,
+                            lastLoggedPercent,
+                            now,
+                            lastLoggedAt,
+                        })) {
+                            const elapsedSeconds = Math.max((now - uploadStartedAt) / 1000, 0.001);
+                            const kibPerSecond = sentBytes / 1024 / elapsedSeconds;
+                            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[LowlevelTransport] FirmwareUpload progress: ${percent}% ` +
+                                `(${index + 1}/${buffers.length} packets, ${sentBytes}/${totalBytes} bytes, ` +
+                                `${elapsedSeconds.toFixed(1)}s, ${kibPerSecond.toFixed(1)} KiB/s)`);
+                            lastLoggedPercent = percent;
+                            lastLoggedAt = now;
+                        }
+                    }
                 }
                 catch (e) {
                     this.Log.debug('lowlevel transport send error: ', e);
@@ -163,12 +244,20 @@ class LowlevelTransport {
                 }
             }
             try {
-                const response = yield this.readProtocolV1Message(options === null || options === void 0 ? void 0 : options.timeoutMs);
-                this.Log.debug('receive data: ', response);
+                const response = yield this.readProtocolV1Message(uuid, options === null || options === void 0 ? void 0 : options.timeoutMs);
                 const jsonData = ProtocolV1.decodeMessage(messages, response);
                 return check.call(jsonData);
             }
             catch (e) {
+                if ((e === null || e === void 0 ? void 0 : e.errorCode) === hdShared.HardwareErrorCode.BleTimeoutError &&
+                    (options === null || options === void 0 ? void 0 : options.timeoutMs) !== PROTOCOL_PROBE_TIMEOUT_MS) {
+                    try {
+                        yield this.resetConnectionAfterProbe(uuid, 'V1');
+                    }
+                    catch (resetError) {
+                        this.Log.debug('[LowlevelTransport] reset after Protocol V1 timeout failed:', resetError);
+                    }
+                }
                 if (name === 'Initialize' && (options === null || options === void 0 ? void 0 : options.timeoutMs) === PROTOCOL_PROBE_TIMEOUT_MS) {
                     this.Log.debug('[LowlevelTransport] Protocol V1 Initialize probe call failed:', e);
                 }
@@ -194,7 +283,7 @@ class LowlevelTransport {
         }
     }
     detectProtocol(uuid, expectedProtocol, protocolHint) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             if (expectedProtocol === 'V2') {
                 if (yield this.probeProtocolV2(uuid)) {
@@ -212,28 +301,17 @@ class LowlevelTransport {
                 }
                 throw this.createProtocolMismatchError(expectedProtocol);
             }
-            if (protocolHint === 'V2' && (yield this.probeProtocolV2(uuid))) {
-                this.deviceProtocol.set(uuid, 'V2');
-                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (hint)`);
-                return 'V2';
-            }
-            const cachedProtocol = this.deviceProtocol.get(uuid);
-            if (cachedProtocol === 'V2' && (yield this.probeProtocolV2(uuid))) {
-                this.deviceProtocol.set(uuid, 'V2');
-                (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (cached)`);
-                return 'V2';
-            }
-            const protocolV1Detected = yield this.probeProtocolV1(uuid);
-            if (protocolV1Detected) {
-                this.deviceProtocol.set(uuid, 'V1');
-                (_e = this.Log) === null || _e === void 0 ? void 0 : _e.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V1`);
-                return 'V1';
-            }
-            yield this.resetConnectionAfterProbe(uuid, 'V1');
-            if (yield this.probeProtocolV2(uuid)) {
-                this.deviceProtocol.set(uuid, 'V2');
-                (_f = this.Log) === null || _f === void 0 ? void 0 : _f.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2`);
-                return 'V2';
+            const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
+            for (const [index, protocol] of probeOrder.entries()) {
+                if (index > 0) {
+                    yield this.resetConnectionAfterProbe(uuid, probeOrder[index - 1]);
+                }
+                const detected = protocol === 'V1' ? yield this.probeProtocolV1(uuid) : yield this.probeProtocolV2(uuid);
+                if (detected) {
+                    this.deviceProtocol.set(uuid, protocol);
+                    (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> ${protocol}`);
+                    return protocol;
+                }
             }
             this.deviceProtocol.delete(uuid);
             throw this.createProtocolDetectionError();
@@ -242,8 +320,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 +331,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 +389,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,17 +409,17 @@ 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) {
-                assembler = new transport.ProtocolV2FrameAssembler();
+                assembler = new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_BLE_FRAME_MAX_BYTES);
                 this.protocolV2Assemblers.set(uuid, assembler);
             }
             const queuedFrame = assembler.push(new Uint8Array(0));
@@ -345,7 +427,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);
@@ -354,47 +436,74 @@ class LowlevelTransport {
             return frame;
         });
     }
-    writeProtocolV2Frame(uuid, frame) {
+    writeProtocolV2Frame(uuid, frame, context, assertCurrentGeneration) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (let offset = 0; offset < frame.length; offset += LOWLEVEL_PROTOCOL_V2_PACKET_LENGTH) {
-                const chunk = frame.slice(offset, offset + LOWLEVEL_PROTOCOL_V2_PACKET_LENGTH);
-                yield this.plugin.send(uuid, transport.bytesToHex(chunk));
-            }
+            yield transport.writeProtocolV2BleFrame({
+                frame,
+                packetCapacity: LOWLEVEL_PROTOCOL_V2_PACKET_LENGTH,
+                assertActive: assertCurrentGeneration,
+                signal: context.signal,
+                abortMessage: `Protocol V2 BLE write aborted for ${context.messageName}`,
+                writePacket: packet => this.plugin.send(uuid, transport.bytesToHex(packet)),
+            });
         });
     }
     callProtocolV2(uuid, name, data, options) {
-        var _a, _b, _c;
         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, options);
             }
             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, context) => this.writeProtocolV2Frame(uuid, frame, context, assertCurrentGeneration),
+            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');
     }
 }
 
-module.exports = LowlevelTransport;
+exports["default"] = LowlevelTransport;
+exports.getProtocolV1SendOptions = getProtocolV1SendOptions;
+exports.shouldLogFirmwareUploadProgress = shouldLogFirmwareUploadProgress;

package/dist/types.d.ts

@@ -2,5 +2,6 @@ import type { ProtocolType } from '@onekeyfe/hd-transport';
 export type LowLevelAcquireInput = {
     uuid: string;
     expectedProtocol?: ProtocolType;
+    protocolHint?: ProtocolType;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,YAAY,CAAC;CACjC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,YAAY,CAAC;IAChC,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-lowlevel",
-  "version": "1.2.0-alpha.8",
+  "version": "1.2.0-alpha.81",
   "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.81",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.81"
   },
-  "gitHead": "d2b1323e5ad9c373e72d4d092f35c9f274c1fd74"
+  "gitHead": "8f6b4dca4ab97dc0a83f7ace61c24a0f0e193016"
 }

package/src/index.ts

@@ -1,15 +1,16 @@
 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,
   probeProtocolV2 as probeProtocolV2Helper,
   withProtocolTimeout,
+  writeProtocolV2BleFrame,
 } from '@onekeyfe/hd-transport';
 
 import type EventEmitter from 'events';
@@ -17,6 +18,7 @@ import type {
   LowLevelDevice,
   LowlevelTransportSharedPlugin,
   ProtocolType,
+  ProtocolV2CallContext,
   TransportCallOptions,
 } from '@onekeyfe/hd-transport';
 import type { LowLevelAcquireInput } from './types';
@@ -25,8 +27,31 @@ const { check, ProtocolV1, parseConfigure } = transport;
 
 const PROTOCOL_PROBE_TIMEOUT_MS = 1000;
 const PROTOCOL_V2_PROBE_TIMEOUT_MS = 5000;
-const LOWLEVEL_PROTOCOL_TIMEOUT_MS = 30_000;
 const LOWLEVEL_PROTOCOL_V2_PACKET_LENGTH = 64;
+const FIRMWARE_UPLOAD_LOG_PERCENT_STEP = 5;
+const FIRMWARE_UPLOAD_LOG_INTERVAL_MS = 10_000;
+
+export function shouldLogFirmwareUploadProgress({
+  percent,
+  lastLoggedPercent,
+  now,
+  lastLoggedAt,
+}: {
+  percent: number;
+  lastLoggedPercent: number;
+  now: number;
+  lastLoggedAt: number;
+}) {
+  return (
+    percent === 100 ||
+    percent - lastLoggedPercent >= FIRMWARE_UPLOAD_LOG_PERCENT_STEP ||
+    now - lastLoggedAt >= FIRMWARE_UPLOAD_LOG_INTERVAL_MS
+  );
+}
+
+export function getProtocolV1SendOptions(name: string) {
+  return name === 'FirmwareUpload' ? { withoutResponse: false } : undefined;
+}
 
 function inferProtocolHintFromDeviceName(name?: string | null): ProtocolType | undefined {
   return /\bpro\s*2\b/i.test(name ?? '') ? 'V2' : undefined;
@@ -59,6 +84,43 @@ 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);
+        }
+      }
+    },
+  });
+
+  private protocolV2SchemaConfiguration: string | undefined;
+
   getProtocolType(path: string): ProtocolType | undefined {
     return this.deviceProtocol.get(path);
   }
@@ -77,7 +139,20 @@ export default class LowlevelTransport {
   }
 
   configureProtocolV2(signedData: any) {
+    const configuration = typeof signedData === 'string' ? signedData : JSON.stringify(signedData);
+    if (this.protocolV2SchemaConfiguration === configuration) {
+      return;
+    }
+
+    const isReconfiguration = this.protocolV2SchemaConfiguration !== undefined;
     this._messagesV2 = parseConfigure(signedData);
+    this.protocolV2SchemaConfiguration = configuration;
+
+    if (isReconfiguration) {
+      this.protocolV2Links
+        .invalidateAllLinks('Protocol V2 schema reconfigured')
+        .catch(error => this.Log?.debug('Protocol V2 schema link cleanup failed:', error));
+    }
   }
 
   listen() {
@@ -96,9 +171,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,
@@ -106,10 +187,13 @@ export default class LowlevelTransport {
       );
     }
 
-    this.protocolV2Assemblers.set(input.uuid, new ProtocolV2FrameAssembler());
+    this.protocolV2Assemblers.set(
+      input.uuid,
+      new ProtocolV2FrameAssembler(PROTOCOL_V2_BLE_FRAME_MAX_BYTES)
+    );
     const protocolHint = input.expectedProtocol
       ? undefined
-      : this.deviceProtocolHints.get(input.uuid);
+      : input.protocolHint ?? this.deviceProtocolHints.get(input.uuid);
     const protocolType = await this.detectProtocol(
       input.uuid,
       input.expectedProtocol,
@@ -120,9 +204,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);
+      // A name-derived protocol hint survives disconnect and lets fast reconnect probe
+      // Protocol V2 first without sending a redundant V1 Initialize.
       this.protocolV2Assemblers.delete(uuid);
       return true;
     } catch (error) {
@@ -148,20 +235,7 @@ export default class LowlevelTransport {
         `Device protocol has not been detected for ${uuid}`
       );
     }
-    if (LogBlockCommand.has(name)) {
-      this.Log.debug('lowlevel-transport', 'call-', ' name: ', name, ' protocol: ', protocol);
-    } else {
-      this.Log.debug(
-        'lowlevel-transport',
-        'call-',
-        ' name: ',
-        name,
-        ' data: ',
-        data,
-        ' protocol: ',
-        protocol
-      );
-    }
+    this.Log.debug('transport call', { name, protocol });
 
     if (protocol === 'V2') {
       return this.callProtocolV2(uuid, name, data, options);
@@ -182,12 +256,41 @@ export default class LowlevelTransport {
 
     const messages = this._messages;
     const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
-    for (const o of buffers) {
+    const isFirmwareUpload = name === 'FirmwareUpload';
+    const uploadStartedAt = Date.now();
+    const totalBytes = buffers.reduce((sum, buffer) => sum + buffer.limit, 0);
+    let sentBytes = 0;
+    let lastLoggedPercent = 0;
+    let lastLoggedAt = uploadStartedAt;
+
+    for (const [index, o] of buffers.entries()) {
       const outData = o.toString('hex');
-      // Upload resources on low-end phones may OOM
-      this.Log.debug('send hex strting: ', outData);
       try {
-        await this.plugin.send(uuid, outData);
+        await this.plugin.send(uuid, outData, getProtocolV1SendOptions(name));
+        sentBytes += o.limit;
+
+        if (isFirmwareUpload) {
+          const now = Date.now();
+          const percent = Math.floor(((index + 1) / buffers.length) * 100);
+          if (
+            shouldLogFirmwareUploadProgress({
+              percent,
+              lastLoggedPercent,
+              now,
+              lastLoggedAt,
+            })
+          ) {
+            const elapsedSeconds = Math.max((now - uploadStartedAt) / 1000, 0.001);
+            const kibPerSecond = sentBytes / 1024 / elapsedSeconds;
+            this.Log?.debug(
+              `[LowlevelTransport] FirmwareUpload progress: ${percent}% ` +
+                `(${index + 1}/${buffers.length} packets, ${sentBytes}/${totalBytes} bytes, ` +
+                `${elapsedSeconds.toFixed(1)}s, ${kibPerSecond.toFixed(1)} KiB/s)`
+            );
+            lastLoggedPercent = percent;
+            lastLoggedAt = now;
+          }
+        }
       } catch (e) {
         this.Log.debug('lowlevel transport send error: ', e);
         throw ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError, e.reason);
@@ -195,11 +298,20 @@ export default class LowlevelTransport {
     }
 
     try {
-      const response = await this.readProtocolV1Message(options?.timeoutMs);
-      this.Log.debug('receive data: ', response);
+      const response = await this.readProtocolV1Message(uuid, options?.timeoutMs);
       const jsonData = ProtocolV1.decodeMessage(messages, response);
       return check.call(jsonData);
     } catch (e) {
+      if (
+        e?.errorCode === HardwareErrorCode.BleTimeoutError &&
+        options?.timeoutMs !== PROTOCOL_PROBE_TIMEOUT_MS
+      ) {
+        try {
+          await this.resetConnectionAfterProbe(uuid, 'V1');
+        } catch (resetError) {
+          this.Log.debug('[LowlevelTransport] reset after Protocol V1 timeout failed:', resetError);
+        }
+      }
       if (name === 'Initialize' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS) {
         this.Log.debug('[LowlevelTransport] Protocol V1 Initialize probe call failed:', e);
       } else {
@@ -259,31 +371,20 @@ export default class LowlevelTransport {
       throw this.createProtocolMismatchError(expectedProtocol);
     }
 
-    if (protocolHint === 'V2' && (await this.probeProtocolV2(uuid))) {
-      this.deviceProtocol.set(uuid, 'V2');
-      this.Log?.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (hint)`);
-      return 'V2';
-    }
-
-    const cachedProtocol = this.deviceProtocol.get(uuid);
-    if (cachedProtocol === 'V2' && (await this.probeProtocolV2(uuid))) {
-      this.deviceProtocol.set(uuid, 'V2');
-      this.Log?.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (cached)`);
-      return 'V2';
-    }
-
-    const protocolV1Detected = await this.probeProtocolV1(uuid);
-    if (protocolV1Detected) {
-      this.deviceProtocol.set(uuid, 'V1');
-      this.Log?.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V1`);
-      return 'V1';
-    }
+    const probeOrder: ProtocolType[] =
+      protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
 
-    await this.resetConnectionAfterProbe(uuid, 'V1');
-    if (await this.probeProtocolV2(uuid)) {
-      this.deviceProtocol.set(uuid, 'V2');
-      this.Log?.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2`);
-      return 'V2';
+    for (const [index, protocol] of probeOrder.entries()) {
+      if (index > 0) {
+        await this.resetConnectionAfterProbe(uuid, probeOrder[index - 1]);
+      }
+      const detected =
+        protocol === 'V1' ? await this.probeProtocolV1(uuid) : await this.probeProtocolV2(uuid);
+      if (detected) {
+        this.deviceProtocol.set(uuid, protocol);
+        this.Log?.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> ${protocol}`);
+        return protocol;
+      }
     }
 
     this.deviceProtocol.delete(uuid);
@@ -291,9 +392,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 +410,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 +469,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 +479,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,17 +491,17 @@ 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();
+      assembler = new ProtocolV2FrameAssembler(PROTOCOL_V2_BLE_FRAME_MAX_BYTES);
       this.protocolV2Assemblers.set(uuid, assembler);
     }
 
@@ -402,7 +510,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);
@@ -411,11 +519,20 @@ export default class LowlevelTransport {
     return frame;
   }
 
-  private async writeProtocolV2Frame(uuid: string, frame: Uint8Array) {
-    for (let offset = 0; offset < frame.length; offset += LOWLEVEL_PROTOCOL_V2_PACKET_LENGTH) {
-      const chunk = frame.slice(offset, offset + LOWLEVEL_PROTOCOL_V2_PACKET_LENGTH);
-      await this.plugin.send(uuid, bytesToHex(chunk));
-    }
+  private async writeProtocolV2Frame(
+    uuid: string,
+    frame: Uint8Array,
+    context: ProtocolV2CallContext,
+    assertCurrentGeneration: () => void
+  ) {
+    await writeProtocolV2BleFrame({
+      frame,
+      packetCapacity: LOWLEVEL_PROTOCOL_V2_PACKET_LENGTH,
+      assertActive: assertCurrentGeneration,
+      signal: context.signal,
+      abortMessage: `Protocol V2 BLE write aborted for ${context.messageName}`,
+      writePacket: packet => this.plugin.send(uuid, bytesToHex(packet)),
+    });
   }
 
   private async callProtocolV2(
@@ -428,34 +545,58 @@ export default class LowlevelTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    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
+      );
     } 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, context: ProtocolV2CallContext) =>
+        this.writeProtocolV2Frame(uuid, frame, context, assertCurrentGeneration),
+      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');
   }

package/src/types.ts

@@ -3,4 +3,5 @@ import type { ProtocolType } from '@onekeyfe/hd-transport';
 export type LowLevelAcquireInput = {
   uuid: string;
   expectedProtocol?: ProtocolType;
+  protocolHint?: ProtocolType;
 };