@onekeyfe/hd-transport-lowlevel 1.2.0-alpha.15 → 1.2.0-alpha.151

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

@@ -68,12 +68,25 @@ const protocolV2Schema = {
         },
       },
     },
+    Failure: {
+      fields: {
+        code: {
+          type: 'uint32',
+          id: 1,
+        },
+        message: {
+          type: 'string',
+          id: 2,
+        },
+      },
+    },
     MessageType: {
       values: {
         MessageType_ProtocolInfoRequest: 60200,
         MessageType_ProtocolInfo: 60201,
         MessageType_Ping: 60206,
         MessageType_Success: 60207,
+        MessageType_Failure: 60208,
       },
     },
   },
@@ -122,6 +135,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 +198,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,11 +245,15 @@ 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' }],
-      responses: [...splitFrame(probeResponse, 4), ...splitFrame(callResponse, 5)],
+      responses: [
+        new Error('Protocol V1 probe timed out'),
+        ...splitFrame(probeResponse, 4),
+        ...splitFrame(callResponse, 5),
+      ],
     });
     const lowlevel = configureTransport(plugin);
 
@@ -196,9 +273,9 @@ describe('LowlevelTransport protocol framing', () => {
       },
     });
     expect(plugin.send).toHaveBeenCalled();
-    const sentSeqs = plugin.send.mock.calls.map(([, hex]) =>
-      Number.parseInt(hex.slice(12, 14), 16)
-    );
+    const sentSeqs = plugin.send.mock.calls
+      .map(([, hex]) => Number.parseInt(hex.slice(12, 14), 16))
+      .filter(seq => seq > 0);
     expect(sentSeqs).toEqual([1, 2]);
   });
 
@@ -222,7 +299,7 @@ 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 () => {
+  test('detects Protocol V2 again after release without a name-derived hint', async () => {
     const probeResponse = ProtocolV2.encodeFrame(
       schemas,
       'Success',
@@ -231,7 +308,12 @@ describe('LowlevelTransport protocol framing', () => {
     );
     const plugin = createPlugin({
       devices: [{ id: 'reconnect-pro2-id', name: 'OneKey Pro 2', commType: 'ble' }],
-      responses: [bytesToHex(probeResponse), bytesToHex(probeResponse)],
+      responses: [
+        new Error('Protocol V1 probe timed out'),
+        bytesToHex(probeResponse),
+        new Error('Protocol V1 probe timed out'),
+        bytesToHex(probeResponse),
+      ],
     });
     const lowlevel = configureTransport(plugin);
 
@@ -246,22 +328,26 @@ describe('LowlevelTransport protocol framing', () => {
       protocolType: 'V2',
     });
 
-    const sentSeqs = plugin.send.mock.calls.map(([, hex]) =>
-      Number.parseInt(hex.slice(12, 14), 16)
-    );
+    const sentSeqs = plugin.send.mock.calls
+      .map(([, hex]) => Number.parseInt(hex.slice(12, 14), 16))
+      .filter(seq => seq > 0);
     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 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: [bytesToHex(probeResponse), bytesToHex(probeResponse)],
+      responses,
     });
     const lowlevel = configureTransport(plugin);
 
@@ -283,13 +369,19 @@ describe('LowlevelTransport protocol framing', () => {
     const sentSeqs = plugin.send.mock.calls.map(([, hex]) =>
       Number.parseInt(hex.slice(12, 14), 16)
     );
-    expect(sentSeqs).toEqual([1, 2]);
+    expect(sentSeqs).toEqual([1, 2, 3, 4]);
   });
 
-  test('trusts explicit Protocol V2 during bootloader reconnect without probing Ping', async () => {
+  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: [],
+      responses: [bytesToHex(probeResponse)],
     });
     const lowlevel = configureTransport(plugin);
 
@@ -299,8 +391,35 @@ describe('LowlevelTransport protocol framing', () => {
       uuid: 'bootloader-v2-id',
       protocolType: 'V2',
     });
-    expect(plugin.send).not.toHaveBeenCalled();
-    expect(plugin.receive).not.toHaveBeenCalled();
+    expect(plugin.send).toHaveBeenCalledTimes(1);
+    expect(plugin.receive).toHaveBeenCalledTimes(1);
+  });
+
+  test('disconnects and clears a lowlevel connection when Protocol V2 reports link disabled', async () => {
+    const failureResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Failure',
+      { code: 5, message: 'link disabled' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const plugin = createPlugin({
+      devices: [{ id: 'usb-owned-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [bytesToHex(failureResponse)],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(
+      lowlevel.acquire({ uuid: 'usb-owned-id', expectedProtocol: 'V2' })
+    ).rejects.toMatchObject({
+      name: 'ProtocolV2LinkDisabledError',
+      failureCode: 5,
+      firmwareMessage: 'link disabled',
+    });
+
+    expect(plugin.disconnect).toHaveBeenCalledWith('usb-owned-id');
+    expect(lowlevel.connectedDevices.has('usb-owned-id')).toBe(false);
+    expect(lowlevel.getProtocolType('usb-owned-id')).toBeUndefined();
+    expect(lowlevel.protocolV2Assemblers.has('usb-owned-id')).toBe(false);
   });
 
   test('resets the lowlevel connection before probing Protocol V2 after a V1 timeout', async () => {
@@ -342,11 +461,23 @@ describe('LowlevelTransport protocol framing', () => {
   });
 
   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: [],
+      responses: [bytesToHex(probeResponse)],
+    });
+    let receiveCount = 0;
+    plugin.receive.mockImplementation(() => {
+      receiveCount += 1;
+      return receiveCount === 1
+        ? Promise.resolve(bytesToHex(probeResponse))
+        : new Promise(() => {});
     });
-    plugin.receive.mockImplementation(() => new Promise(() => {}));
     const lowlevel = configureTransport(plugin);
 
     await lowlevel.acquire({ uuid: 'timeout-v2-id', expectedProtocol: 'V2' });
@@ -358,6 +489,28 @@ describe('LowlevelTransport protocol framing', () => {
     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

@@ -1,12 +1,22 @@
 import * as transport from '@onekeyfe/hd-transport';
-import transport__default, { ProtocolType, LowlevelTransportSharedPlugin, LowLevelDevice, TransportCallOptions } from '@onekeyfe/hd-transport';
+import transport__default, { ProtocolType, LowlevelTransportSharedPlugin, TransportCallOptions } from '@onekeyfe/hd-transport';
 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;
@@ -20,18 +30,20 @@ declare class LowlevelTransport {
     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;
     configureProtocolV2(signedData: any): void;
     listen(): void;
-    enumerate(): Promise<LowLevelDevice[]>;
+    enumerate(): Promise<transport.LowLevelDevice[]>;
     acquire(input: LowLevelAcquireInput): Promise<{
         uuid: string;
         protocolType: ProtocolType;
     }>;
     release(uuid: string): Promise<boolean>;
     call(uuid: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<transport.MessageFromOneKey>;
+    post(uuid: string, name: string, data: Record<string, unknown>): Promise<void>;
     private callProtocolV1;
     private createProtocolTimeoutError;
     private createProtocolMismatchError;
@@ -51,4 +63,4 @@ declare class LowlevelTransport {
     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,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;YAsBlB,cAAc;IAoC5B,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"}
+{"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,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;AAUD,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;IAKT,OAAO,CAAC,KAAK,EAAE,oBAAoB;;;;IAmDnC,OAAO,CAAC,IAAI,EAAE,MAAM;IAepB,IAAI,CACR,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,CAAC,EAAE,oBAAoB;IAoB1B,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;YAatD,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,10 +42,16 @@ 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;
-function inferProtocolHintFromDeviceName(name) {
-    return /\bpro\s*2\b/i.test(name !== null && name !== void 0 ? name : '') ? 'V2' : undefined;
+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 isProtocolV1TransportChunk(data) {
     return data.length >= 9 && data[0] === 0x3f && data[1] === 0x23 && data[2] === 0x23;
@@ -106,27 +114,29 @@ 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.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); });
+        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() {
     }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
             const devices = yield this.plugin.enumerate();
-            return devices.map((device) => {
-                const protocolHint = inferProtocolHintFromDeviceName(device.name);
-                if (protocolHint) {
-                    this.deviceProtocolHints.set(device.id, protocolHint);
-                }
-                return device;
-            });
+            return devices;
         });
     }
     acquire(input) {
-        var _a;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             const alreadyConnected = this.connectedDevices.has(input.uuid);
             try {
@@ -141,12 +151,35 @@ class LowlevelTransport {
                 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);
-            const protocolType = yield this.detectProtocol(input.uuid, input.expectedProtocol, protocolHint);
-            return { uuid: input.uuid, protocolType };
+                : (_b = input.protocolHint) !== null && _b !== void 0 ? _b : this.deviceProtocolHints.get(input.uuid);
+            try {
+                const protocolType = yield this.detectProtocol(input.uuid, input.expectedProtocol, protocolHint);
+                return { uuid: input.uuid, protocolType };
+            }
+            catch (error) {
+                try {
+                    yield this.protocolV2Links.invalidateLink(input.uuid, 'Lowlevel transport acquire failed');
+                }
+                catch (cleanupError) {
+                    (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug('[LowlevelTransport] acquire link cleanup failed:', cleanupError);
+                }
+                try {
+                    yield this.plugin.disconnect(input.uuid);
+                }
+                catch (cleanupError) {
+                    (_d = this.Log) === null || _d === void 0 ? void 0 : _d.debug('[LowlevelTransport] acquire disconnect failed:', cleanupError);
+                }
+                finally {
+                    this.connectedDevices.delete(input.uuid);
+                    this.deviceProtocol.delete(input.uuid);
+                    this.protocolV2Assemblers.delete(input.uuid);
+                    this.advanceProtocolV2Generation(input.uuid);
+                }
+                throw error;
+            }
         });
     }
     release(uuid) {
@@ -174,24 +207,58 @@ class LowlevelTransport {
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${uuid}`);
             }
-            this.Log.debug('transport call', { name, protocol });
             if (protocol === 'V2') {
                 return this.callProtocolV2(uuid, name, data, options);
             }
             return this.callProtocolV1(uuid, name, data, options);
         });
     }
+    post(uuid, name, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.getProtocolType(uuid) === 'V2') {
+                yield this.protocolV2Links.sendFlowControl(uuid, () => this.createProtocolV2Adapter(uuid), name, data);
+                return;
+            }
+            yield this.callProtocolV1(uuid, name, data);
+        });
+    }
     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');
                 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);
@@ -204,6 +271,15 @@ class LowlevelTransport {
                 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);
                 }
@@ -229,12 +305,15 @@ 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') {
-                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 (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);
             }
             if (expectedProtocol === 'V1') {
                 if (yield this.probeProtocolV1(uuid)) {
@@ -244,28 +323,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();
@@ -373,7 +441,7 @@ class LowlevelTransport {
         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));
@@ -390,23 +458,25 @@ 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;
         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;
             try {
-                return yield this.protocolV2Links.call(uuid, () => this.createProtocolV2Adapter(uuid), name, data, Object.assign(Object.assign({}, options), { timeoutMs }));
+                return yield this.protocolV2Links.call(uuid, () => this.createProtocolV2Adapter(uuid), name, data, options);
             }
             catch (e) {
                 this.Log.error('lowlevel Protocol V2 call error: ', e);
@@ -431,10 +501,7 @@ class LowlevelTransport {
                 assertCurrentGeneration();
                 (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
             },
-            writeFrame: (frame) => {
-                assertCurrentGeneration();
-                return this.writeProtocolV2Frame(uuid, frame);
-            },
+            writeFrame: (frame, context) => this.writeProtocolV2Frame(uuid, frame, context, assertCurrentGeneration),
             readFrame: (context) => {
                 assertCurrentGeneration();
                 return this.readProtocolV2Frame(uuid, context.timeoutMs, context.messageName);
@@ -459,4 +526,6 @@ class LowlevelTransport {
     }
 }
 
-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.15",
+  "version": "1.2.0-alpha.151",
   "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.15",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.15"
+    "@onekeyfe/hd-shared": "1.2.0-alpha.151",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.151"
   },
-  "gitHead": "06dd8f9cba892bb66242e5a51038a7103fb05f09"
+  "gitHead": "d1fa81c92deb1bfa3903e3963a82edd6384d568a"
 }

package/src/index.ts

@@ -10,13 +10,14 @@ import transport, {
   hexToBytes,
   probeProtocolV2 as probeProtocolV2Helper,
   withProtocolTimeout,
+  writeProtocolV2BleFrame,
 } from '@onekeyfe/hd-transport';
 
 import type EventEmitter from 'events';
 import type {
-  LowLevelDevice,
   LowlevelTransportSharedPlugin,
   ProtocolType,
+  ProtocolV2CallContext,
   TransportCallOptions,
 } from '@onekeyfe/hd-transport';
 import type { LowLevelAcquireInput } from './types';
@@ -25,11 +26,30 @@ 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
+  );
+}
 
-function inferProtocolHintFromDeviceName(name?: string | null): ProtocolType | undefined {
-  return /\bpro\s*2\b/i.test(name ?? '') ? 'V2' : undefined;
+export function getProtocolV1SendOptions(name: string) {
+  return name === 'FirmwareUpload' ? { withoutResponse: false } : undefined;
 }
 
 function isProtocolV1TransportChunk(data: Uint8Array) {
@@ -94,6 +114,8 @@ export default class LowlevelTransport {
     },
   });
 
+  private protocolV2SchemaConfiguration: string | undefined;
+
   getProtocolType(path: string): ProtocolType | undefined {
     return this.deviceProtocol.get(path);
   }
@@ -112,10 +134,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.protocolV2Links
-      .invalidateAllLinks('Protocol V2 schema reconfigured')
-      .catch(error => this.Log?.debug('Protocol V2 schema link cleanup failed:', error));
+    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() {
@@ -124,13 +156,7 @@ export default class LowlevelTransport {
 
   async enumerate() {
     const devices = await this.plugin.enumerate();
-    return devices.map((device: LowLevelDevice) => {
-      const protocolHint = inferProtocolHintFromDeviceName(device.name);
-      if (protocolHint) {
-        this.deviceProtocolHints.set(device.id, protocolHint);
-      }
-      return device;
-    });
+    return devices;
   }
 
   async acquire(input: LowLevelAcquireInput) {
@@ -150,16 +176,38 @@ export default class LowlevelTransport {
       );
     }
 
-    this.protocolV2Assemblers.set(input.uuid, new ProtocolV2FrameAssembler());
-    const protocolHint = input.expectedProtocol
-      ? undefined
-      : this.deviceProtocolHints.get(input.uuid);
-    const protocolType = await this.detectProtocol(
+    this.protocolV2Assemblers.set(
       input.uuid,
-      input.expectedProtocol,
-      protocolHint
+      new ProtocolV2FrameAssembler(PROTOCOL_V2_BLE_FRAME_MAX_BYTES)
     );
-    return { uuid: input.uuid, protocolType };
+    const protocolHint = input.expectedProtocol
+      ? undefined
+      : input.protocolHint ?? this.deviceProtocolHints.get(input.uuid);
+    try {
+      const protocolType = await this.detectProtocol(
+        input.uuid,
+        input.expectedProtocol,
+        protocolHint
+      );
+      return { uuid: input.uuid, protocolType };
+    } catch (error) {
+      try {
+        await this.protocolV2Links.invalidateLink(input.uuid, 'Lowlevel transport acquire failed');
+      } catch (cleanupError) {
+        this.Log?.debug('[LowlevelTransport] acquire link cleanup failed:', cleanupError);
+      }
+      try {
+        await this.plugin.disconnect(input.uuid);
+      } catch (cleanupError) {
+        this.Log?.debug('[LowlevelTransport] acquire disconnect failed:', cleanupError);
+      } finally {
+        this.connectedDevices.delete(input.uuid);
+        this.deviceProtocol.delete(input.uuid);
+        this.protocolV2Assemblers.delete(input.uuid);
+        this.advanceProtocolV2Generation(input.uuid);
+      }
+      throw error;
+    }
   }
 
   async release(uuid: string) {
@@ -168,8 +216,7 @@ export default class LowlevelTransport {
       await this.plugin.disconnect(uuid);
       this.connectedDevices.delete(uuid);
       this.deviceProtocol.delete(uuid);
-      // 设备名称推断出的协议提示不依赖当前连接，保留它可以让快速重连
-      // 直接执行 Protocol V2 探测，避免先发送一次无意义的 V1 Initialize。
+      // Confirmed protocol stays on the device endpoint; BLE names are not a probe hint.
       this.protocolV2Assemblers.delete(uuid);
       return true;
     } catch (error) {
@@ -195,8 +242,6 @@ export default class LowlevelTransport {
         `Device protocol has not been detected for ${uuid}`
       );
     }
-    this.Log.debug('transport call', { name, protocol });
-
     if (protocol === 'V2') {
       return this.callProtocolV2(uuid, name, data, options);
     }
@@ -204,6 +249,19 @@ export default class LowlevelTransport {
     return this.callProtocolV1(uuid, name, data, options);
   }
 
+  async post(uuid: string, name: string, data: Record<string, unknown>) {
+    if (this.getProtocolType(uuid) === 'V2') {
+      await this.protocolV2Links.sendFlowControl(
+        uuid,
+        () => this.createProtocolV2Adapter(uuid),
+        name,
+        data
+      );
+      return;
+    }
+    await this.callProtocolV1(uuid, name, data);
+  }
+
   private async callProtocolV1(
     uuid: string,
     name: string,
@@ -216,10 +274,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');
       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);
@@ -231,6 +320,16 @@ export default class LowlevelTransport {
       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 {
@@ -273,12 +372,12 @@ export default class LowlevelTransport {
     protocolHint?: ProtocolType
   ): Promise<ProtocolType> {
     if (expectedProtocol === 'V2') {
-      // 固件升级重启后的 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 (await this.probeProtocolV2(uuid)) {
+        this.deviceProtocol.set(uuid, 'V2');
+        this.Log?.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+        return 'V2';
+      }
+      throw this.createProtocolMismatchError(expectedProtocol);
     }
 
     if (expectedProtocol === 'V1') {
@@ -290,31 +389,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);
@@ -431,7 +519,7 @@ export default class LowlevelTransport {
   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);
     }
 
@@ -449,11 +537,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(
@@ -466,18 +563,13 @@ export default class LowlevelTransport {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    const timeoutMs = options?.timeoutMs ?? LOWLEVEL_PROTOCOL_TIMEOUT_MS;
-
     try {
       return await this.protocolV2Links.call(
         uuid,
         () => this.createProtocolV2Adapter(uuid),
         name,
         data,
-        {
-          ...options,
-          timeoutMs,
-        }
+        options
       );
     } catch (e) {
       this.Log.error('lowlevel Protocol V2 call error: ', e);
@@ -501,10 +593,8 @@ export default class LowlevelTransport {
         assertCurrentGeneration();
         this.protocolV2Assemblers.get(uuid)?.reset();
       },
-      writeFrame: (frame: Uint8Array) => {
-        assertCurrentGeneration();
-        return this.writeProtocolV2Frame(uuid, frame);
-      },
+      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);

package/src/types.ts

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