@onekeyfe/hd-transport-lowlevel 1.1.27 → 1.2.0-alpha.0

package/.eslintignore

@@ -0,0 +1,4 @@
+coverage/
+dist/
+__tests__/
+jest.config.js

package/__tests__/protocol-v2.test.js

@@ -0,0 +1,288 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const LowlevelTransport = require('../src').default;
+const { parseConfigure } = require('../../hd-transport/src/serialization/protobuf/messages');
+const { ProtocolV1, ProtocolV2 } = require('../../hd-transport/src/protocols');
+const { bytesToHex } = require('../../hd-transport/src/protocols/v2/session');
+const { PROTOCOL_V2_CHANNEL_BLE_UART } = require('../../hd-transport/src/constants');
+
+const protocolV1Schema = {
+  nested: {
+    Initialize: {
+      fields: {},
+    },
+    Success: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Initialize: 1,
+        MessageType_Success: 2,
+      },
+    },
+  },
+};
+
+const protocolV2Schema = {
+  nested: {
+    GetProtoVersion: {
+      fields: {},
+    },
+    ProtoVersion: {
+      fields: {
+        major_version: {
+          type: 'uint32',
+          id: 1,
+        },
+        minor_version: {
+          type: 'uint32',
+          id: 2,
+        },
+        patch_version: {
+          type: 'uint32',
+          id: 3,
+        },
+      },
+    },
+    Ping: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    Success: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_GetProtoVersion: 60200,
+        MessageType_ProtoVersion: 60201,
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+      },
+    },
+  },
+};
+
+const schemas = {
+  protocolV1: parseConfigure(protocolV1Schema),
+  protocolV2: parseConfigure(protocolV2Schema),
+};
+
+const createLogger = () => ({
+  debug: jest.fn(),
+  error: jest.fn(),
+});
+
+const createPlugin = ({ devices, responses }) => ({
+  enumerate: jest.fn(() => Promise.resolve(devices)),
+  connect: jest.fn(() => Promise.resolve()),
+  disconnect: jest.fn(() => Promise.resolve()),
+  init: jest.fn(() => Promise.resolve()),
+  send: jest.fn(() => Promise.resolve()),
+  receive: jest.fn(() => {
+    const next = responses.shift();
+    if (next instanceof Error) {
+      return Promise.reject(next);
+    }
+    if (!next) {
+      return Promise.reject(new Error('No queued response'));
+    }
+    return Promise.resolve(next);
+  }),
+  version: 'test-plugin',
+});
+
+const configureTransport = plugin => {
+  const lowlevel = new LowlevelTransport();
+  lowlevel.init(createLogger(), undefined, plugin);
+  lowlevel.configure(protocolV1Schema);
+  lowlevel.configureProtocolV2(protocolV2Schema);
+  return lowlevel;
+};
+
+const splitFrame = (frame, index) => [
+  bytesToHex(frame.slice(0, index)),
+  bytesToHex(frame.slice(index)),
+];
+
+describe('LowlevelTransport protocol framing', () => {
+  test('keeps Protocol V1 raw notification chunks compatible', async () => {
+    const responseChunks = ProtocolV1.encodeTransportPackets(schemas.protocolV1, 'Success', {
+      message: 'ok',
+    }).map(chunk => chunk.toString('hex'));
+    const plugin = createPlugin({
+      devices: [{ id: 'classic-id', name: 'OneKey Classic', commType: 'ble' }],
+      responses: [...responseChunks, ...responseChunks],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(lowlevel.acquire({ uuid: 'classic-id' })).resolves.toEqual({
+      uuid: 'classic-id',
+      protocolType: 'V1',
+    });
+    await expect(lowlevel.call('classic-id', 'Initialize', {})).resolves.toEqual({
+      type: 'Success',
+      message: { message: 'ok' },
+    });
+  });
+
+  test('rejects calls before protocol detection', async () => {
+    const responseChunks = ProtocolV1.encodeTransportPackets(schemas.protocolV1, 'Success', {
+      message: 'ok',
+    }).map(chunk => chunk.toString('hex'));
+    const plugin = createPlugin({
+      devices: [{ id: 'classic-id', name: 'OneKey Classic', commType: 'ble' }],
+      responses: responseChunks,
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(lowlevel.call('classic-id', 'Initialize', {})).rejects.toThrow(
+      'Device protocol has not been detected'
+    );
+  });
+
+  test('detects Protocol V2 devices and reassembles split Protocol V2 notifications', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      {
+        message: 'probe',
+      },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const callResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'ProtoVersion',
+      {
+        major_version: 2,
+        minor_version: 1,
+        patch_version: 3,
+      },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const plugin = createPlugin({
+      devices: [{ id: 'pro2-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [...splitFrame(probeResponse, 4), ...splitFrame(callResponse, 5)],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(lowlevel.enumerate()).resolves.toEqual([
+      { id: 'pro2-id', name: 'OneKey Pro 2', commType: 'ble' },
+    ]);
+    await expect(lowlevel.acquire({ uuid: 'pro2-id' })).resolves.toEqual({
+      uuid: 'pro2-id',
+      protocolType: 'V2',
+    });
+    await expect(lowlevel.call('pro2-id', 'GetProtoVersion', {})).resolves.toEqual({
+      type: 'ProtoVersion',
+      message: {
+        major_version: 2,
+        minor_version: 1,
+        patch_version: 3,
+      },
+    });
+    expect(plugin.send).toHaveBeenCalled();
+  });
+
+  test('falls back to Protocol V2 probe for unnamed Protocol V2 devices', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      {
+        message: 'probe',
+      },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const plugin = createPlugin({
+      devices: [{ id: 'unknown-pro2-id', name: 'Unknown BLE Device', commType: 'ble' }],
+      responses: [new Error('Protocol V1 probe timed out'), bytesToHex(probeResponse)],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(lowlevel.acquire({ uuid: 'unknown-pro2-id' })).resolves.toEqual({
+      uuid: 'unknown-pro2-id',
+      protocolType: 'V2',
+    });
+    expect(lowlevel.getProtocolType('unknown-pro2-id')).toBe('V2');
+  });
+
+  test('resets the lowlevel connection before probing Protocol V2 after a V1 timeout', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      {
+        message: 'probe',
+      },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    let staleReceivePending = false;
+    let resetAfterTimeout = false;
+    const plugin = createPlugin({
+      devices: [{ id: 'slow-v2-id', name: 'Unknown BLE Device', commType: 'ble' }],
+      responses: [],
+    });
+    plugin.disconnect.mockImplementation(() => {
+      staleReceivePending = false;
+      resetAfterTimeout = true;
+      return Promise.resolve();
+    });
+    plugin.receive.mockImplementation(() => {
+      if (!staleReceivePending && !resetAfterTimeout) {
+        staleReceivePending = true;
+        return new Promise(() => {});
+      }
+      if (staleReceivePending) {
+        return Promise.reject(new Error('stale receive still pending'));
+      }
+      return Promise.resolve(bytesToHex(probeResponse));
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(lowlevel.acquire({ uuid: 'slow-v2-id' })).resolves.toEqual({
+      uuid: 'slow-v2-id',
+      protocolType: 'V2',
+    });
+    expect(plugin.disconnect).toHaveBeenCalledWith('slow-v2-id');
+    expect(plugin.connect).toHaveBeenCalledTimes(2);
+  });
+
+  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' }],
+      responses: [new Error('Protocol V1 probe timed out')],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(lowlevel.acquire({ uuid: 'v2-id', expectedProtocol: 'V1' })).rejects.toThrow(
+      'Device protocol mismatch: expected V1'
+    );
+  });
+
+  test('rejects automatic detection instead of caching V1 when both protocol probes fail', async () => {
+    const plugin = createPlugin({
+      devices: [{ id: 'flaky-pro2-id', name: 'Unknown BLE Device', commType: 'ble' }],
+      responses: [
+        new Error('Protocol V1 probe timed out'),
+        new Error('Protocol V2 probe timed out'),
+      ],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(lowlevel.acquire({ uuid: 'flaky-pro2-id' })).rejects.toThrow(
+      'Unable to detect BLE protocol'
+    );
+    expect(lowlevel.getProtocolType('flaky-pro2-id')).toBeUndefined();
+  });
+});

package/dist/index.d.ts

@@ -1,26 +1,48 @@
-import * as _onekeyfe_hd_transport from '@onekeyfe/hd-transport';
-import _onekeyfe_hd_transport__default, { LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
+import * as transport from '@onekeyfe/hd-transport';
+import transport__default, { ProtocolType, LowlevelTransportSharedPlugin, LowLevelDevice, TransportCallOptions } from '@onekeyfe/hd-transport';
 import EventEmitter from 'events';
 
 type LowLevelAcquireInput = {
     uuid: string;
+    expectedProtocol?: ProtocolType;
 };
 
 declare class LowlevelTransport {
-    _messages: ReturnType<typeof _onekeyfe_hd_transport__default.parseConfigure> | undefined;
+    _messages: ReturnType<typeof transport__default.parseConfigure> | undefined;
+    _messagesV2: ReturnType<typeof transport__default.parseConfigure> | undefined;
     configured: boolean;
     Log?: any;
     emitter?: EventEmitter;
     plugin: LowlevelTransportSharedPlugin;
+    private deviceProtocol;
+    private deviceProtocolHints;
+    private protocolV2Assemblers;
+    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<_onekeyfe_hd_transport.LowLevelDevice[]>;
+    enumerate(): Promise<LowLevelDevice[]>;
     acquire(input: LowLevelAcquireInput): Promise<{
         uuid: string;
+        protocolType: ProtocolType;
     }>;
     release(uuid: string): Promise<boolean>;
-    call(uuid: string, name: string, data: Record<string, unknown>): Promise<_onekeyfe_hd_transport.MessageFromOneKey>;
+    call(uuid: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<transport.MessageFromOneKey>;
+    private callProtocolV1;
+    private createProtocolTimeoutError;
+    private createProtocolMismatchError;
+    private createProtocolDetectionError;
+    private clearProbeProtocol;
+    private detectProtocol;
+    private resetConnectionAfterProbe;
+    private probeProtocolV1;
+    private probeProtocolV2;
+    private receiveHex;
+    private readProtocolV1Message;
+    private readProtocolV2Frame;
+    private writeProtocolV2Frame;
+    private callProtocolV2;
     cancel(): void;
 }
 

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,SAA8B,MAAM,wBAAwB,CAAC;AAEpE,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAIpD,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,SAAS,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,GAAG,SAAS,CAAC;IAEnE,UAAU,UAAS;IAEnB,GAAG,CAAC,EAAE,GAAG,CAAC;IAEV,OAAO,CAAC,EAAE,YAAY,CAAC;IAEvB,MAAM,EAAE,6BAA6B,CAAuC;IAE5E,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,6BAA6B;IAO9E,SAAS,CAAC,UAAU,EAAE,GAAG;IAMzB,MAAM;IAIN,SAAS;IAIH,OAAO,CAAC,KAAK,EAAE,oBAAoB;;;IAanC,OAAO,CAAC,IAAI,EAAE,MAAM;IAUpB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAuCpE,MAAM;CAGP"}
+{"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"}

package/dist/index.js

@@ -37,11 +37,30 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const { check, buildBuffers, receiveOne, parseConfigure } = transport__default["default"];
+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;
+}
+function isProtocolV1TransportChunk(data) {
+    return data.length >= 9 && data[0] === 0x3f && data[1] === 0x23 && data[2] === 0x23;
+}
+function readProtocolV1PayloadLength(data) {
+    return data[5] * 0x1000000 + data[6] * 0x10000 + data[7] * 0x100 + data[8];
+}
 class LowlevelTransport {
     constructor() {
         this.configured = false;
         this.plugin = {};
+        this.deviceProtocol = new Map();
+        this.deviceProtocolHints = new Map();
+        this.protocolV2Assemblers = new Map();
+    }
+    getProtocolType(path) {
+        return this.deviceProtocol.get(path);
     }
     init(logger, emitter, plugin) {
         this.Log = logger;
@@ -54,28 +73,48 @@ class LowlevelTransport {
         this.configured = true;
         this._messages = messages;
     }
+    configureProtocolV2(signedData) {
+        this._messagesV2 = parseConfigure(signedData);
+    }
     listen() {
     }
     enumerate() {
-        return this.plugin.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;
+            });
+        });
     }
     acquire(input) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 yield this.plugin.connect(input.uuid);
-                return { uuid: input.uuid };
             }
             catch (error) {
                 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());
+            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 };
         });
     }
     release(uuid) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 yield this.plugin.disconnect(uuid);
+                this.deviceProtocol.delete(uuid);
+                this.deviceProtocolHints.delete(uuid);
+                this.protocolV2Assemblers.delete(uuid);
                 return true;
             }
             catch (error) {
@@ -84,19 +123,34 @@ class LowlevelTransport {
             }
         });
     }
-    call(uuid, name, data) {
+    call(uuid, name, data, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._messages === null || !this._messages) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured);
             }
-            const messages = this._messages;
+            const protocol = this.getProtocolType(uuid);
+            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);
+                this.Log.debug('lowlevel-transport', 'call-', ' name: ', name, ' protocol: ', protocol);
             }
             else {
-                this.Log.debug('lowlevel-transport', 'call-', ' name: ', name, ' data: ', data);
+                this.Log.debug('lowlevel-transport', 'call-', ' name: ', name, ' data: ', data, ' protocol: ', protocol);
             }
-            const buffers = buildBuffers(messages, name, data);
+            if (protocol === 'V2') {
+                return this.callProtocolV2(uuid, name, data, options);
+            }
+            return this.callProtocolV1(uuid, name, data, options);
+        });
+    }
+    callProtocolV1(uuid, name, data, options) {
+        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 outData = o.toString('hex');
                 this.Log.debug('send hex strting: ', outData);
@@ -109,16 +163,231 @@ class LowlevelTransport {
                 }
             }
             try {
-                const response = yield this.plugin.receive();
-                if (typeof response !== 'string') {
-                    throw new Error('Returning data is not string');
-                }
+                const response = yield this.readProtocolV1Message(options === null || options === void 0 ? void 0 : options.timeoutMs);
                 this.Log.debug('receive data: ', response);
-                const jsonData = receiveOne(messages, response);
+                const jsonData = ProtocolV1.decodeMessage(messages, response);
                 return check.call(jsonData);
             }
             catch (e) {
-                this.Log.error('lowlevel call error: ', e);
+                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);
+                }
+                else {
+                    this.Log.error('lowlevel call error: ', e);
+                }
+                throw e;
+            }
+        });
+    }
+    createProtocolTimeoutError(name, timeout) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `Lowlevel response timeout after ${timeout}ms for ${name}`);
+    }
+    createProtocolMismatchError(expected) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+    }
+    createProtocolDetectionError() {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'Unable to detect BLE protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping');
+    }
+    clearProbeProtocol(uuid, protocol) {
+        if (this.deviceProtocol.get(uuid) === protocol) {
+            this.deviceProtocol.delete(uuid);
+        }
+    }
+    detectProtocol(uuid, expectedProtocol, protocolHint) {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (expectedProtocol === 'V2') {
+                if (yield this.probeProtocolV2(uuid)) {
+                    this.deviceProtocol.set(uuid, 'V2');
+                    (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+                    return 'V2';
+                }
+                throw this.createProtocolMismatchError(expectedProtocol);
+            }
+            if (expectedProtocol === 'V1') {
+                if (yield this.probeProtocolV1(uuid)) {
+                    this.deviceProtocol.set(uuid, 'V1');
+                    (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V1 (expected)`);
+                    return 'V1';
+                }
+                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';
+            }
+            this.deviceProtocol.delete(uuid);
+            throw this.createProtocolDetectionError();
+        });
+    }
+    resetConnectionAfterProbe(uuid, protocol) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+            try {
+                yield this.plugin.disconnect(uuid);
+            }
+            catch (error) {
+                (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[LowlevelTransport] disconnect after Protocol ${protocol} probe failed:`, error);
+            }
+            try {
+                yield this.plugin.connect(uuid);
+            }
+            catch (error) {
+                (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[LowlevelTransport] reconnect after Protocol ${protocol} probe failed:`, error);
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.LowlevelTrasnportConnectError, (_d = error.message) !== null && _d !== void 0 ? _d : error);
+            }
+        });
+    }
+    probeProtocolV1(uuid) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages) {
+                return false;
+            }
+            try {
+                this.deviceProtocol.set(uuid, 'V1');
+                yield this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+                return true;
+            }
+            catch (error) {
+                this.clearProbeProtocol(uuid, 'V1');
+                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[LowlevelTransport] Protocol V1 Initialize probe failed:', error);
+                return false;
+            }
+        });
+    }
+    probeProtocolV2(uuid) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._messages || !this._messagesV2) {
+                return false;
+            }
+            this.deviceProtocol.set(uuid, 'V2');
+            (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
+            try {
+                const detected = yield transport.probeProtocolV2({
+                    call: (name, data, options) => this.callProtocolV2(uuid, name, data, options),
+                    timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
+                    logger: this.Log,
+                    logPrefix: 'ProtocolV2 Lowlevel-BLE',
+                    onProbeFailed: () => __awaiter(this, void 0, void 0, function* () {
+                        var _b;
+                        (_b = this.protocolV2Assemblers.get(uuid)) === null || _b === void 0 ? void 0 : _b.reset();
+                        yield this.resetConnectionAfterProbe(uuid, 'V2');
+                    }),
+                });
+                if (!detected) {
+                    this.clearProbeProtocol(uuid, 'V2');
+                }
+                return detected;
+            }
+            catch (error) {
+                this.clearProbeProtocol(uuid, 'V2');
+                throw error;
+            }
+        });
+    }
+    receiveHex(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));
+            if (typeof response !== 'string') {
+                throw new Error('Returning data is not string');
+            }
+            return response;
+        });
+    }
+    readProtocolV1Message(timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const first = yield this.receiveHex(timeoutMs, 'ProtocolV1');
+            const firstData = transport.hexToBytes(first);
+            if (!isProtocolV1TransportChunk(firstData)) {
+                return first;
+            }
+            const payloadLength = readProtocolV1PayloadLength(firstData);
+            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');
+                buffer = transport.concatUint8Arrays([buffer, transport.hexToBytes(next)]);
+            }
+            return transport.bytesToHex(buffer.slice(0, expectedLength));
+        });
+    }
+    readProtocolV2Frame(uuid, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let assembler = this.protocolV2Assemblers.get(uuid);
+            if (!assembler) {
+                assembler = new transport.ProtocolV2FrameAssembler();
+                this.protocolV2Assemblers.set(uuid, assembler);
+            }
+            const queuedFrame = assembler.push(new Uint8Array(0));
+            if (queuedFrame)
+                return queuedFrame;
+            let frame;
+            while (!frame) {
+                const response = yield this.receiveHex(timeoutMs, 'ProtocolV2');
+                const chunk = transport.hexToBytes(response);
+                if (chunk.length > 0) {
+                    frame = assembler.push(chunk);
+                }
+            }
+            return frame;
+        });
+    }
+    writeProtocolV2Frame(uuid, frame) {
+        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));
+            }
+        });
+    }
+    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 }));
+            }
+            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;
             }
         });

package/dist/types.d.ts

@@ -1,4 +1,6 @@
+import type { ProtocolType } from '@onekeyfe/hd-transport';
 export type LowLevelAcquireInput = {
     uuid: string;
+    expectedProtocol?: 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,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;CACd,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;CACjC,CAAC"}

package/jest.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  preset: '../../jest.config.js',
+  testEnvironment: 'node',
+  modulePathIgnorePatterns: ['node_modules', '<rootDir>/lib', '<rootDir>/libDev'],
+  collectCoverage: true,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-lowlevel",
-  "version": "1.1.27",
+  "version": "1.2.0-alpha.0",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -15,12 +15,13 @@
   "scripts": {
     "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
     "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "test": "jest",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.1.27",
-    "@onekeyfe/hd-transport": "1.1.27"
+    "@onekeyfe/hd-shared": "1.2.0-alpha.0",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.0"
   },
-  "gitHead": "f0c80ce0246152fee79f9cae836db5d550bb82f0"
+  "gitHead": "de9efe20b83666b641ab9e8d945e6350f6450904"
 }

package/src/index.ts

@@ -1,15 +1,50 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import transport, { LogBlockCommand } from '@onekeyfe/hd-transport';
+import transport, {
+  LogBlockCommand,
+  PROTOCOL_V1_MESSAGE_HEADER_SIZE,
+  PROTOCOL_V2_CHANNEL_BLE_UART,
+  ProtocolV2FrameAssembler,
+  ProtocolV2Session,
+  bytesToHex,
+  concatUint8Arrays,
+  hexToBytes,
+  probeProtocolV2 as probeProtocolV2Helper,
+  withProtocolTimeout,
+} from '@onekeyfe/hd-transport';
 
 import type EventEmitter from 'events';
-import type { LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
+import type {
+  LowLevelDevice,
+  LowlevelTransportSharedPlugin,
+  ProtocolType,
+  TransportCallOptions,
+} from '@onekeyfe/hd-transport';
 import type { LowLevelAcquireInput } from './types';
 
-const { check, buildBuffers, receiveOne, parseConfigure } = transport;
+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;
+
+function inferProtocolHintFromDeviceName(name?: string | null): ProtocolType | undefined {
+  return /\bpro\s*2\b/i.test(name ?? '') ? 'V2' : undefined;
+}
+
+function isProtocolV1TransportChunk(data: Uint8Array) {
+  return data.length >= 9 && data[0] === 0x3f && data[1] === 0x23 && data[2] === 0x23;
+}
+
+function readProtocolV1PayloadLength(data: Uint8Array) {
+  return data[5] * 0x1000000 + data[6] * 0x10000 + data[7] * 0x100 + data[8];
+}
 
 export default class LowlevelTransport {
   _messages: ReturnType<typeof transport.parseConfigure> | undefined;
 
+  _messagesV2: ReturnType<typeof transport.parseConfigure> | undefined;
+
   configured = false;
 
   Log?: any;
@@ -18,6 +53,16 @@ export default class LowlevelTransport {
 
   plugin: LowlevelTransportSharedPlugin = {} as LowlevelTransportSharedPlugin;
 
+  private deviceProtocol: Map<string, ProtocolType> = new Map();
+
+  private deviceProtocolHints: Map<string, ProtocolType> = new Map();
+
+  private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
+
+  getProtocolType(path: string): ProtocolType | undefined {
+    return this.deviceProtocol.get(path);
+  }
+
   init(logger: any, emitter: EventEmitter, plugin: LowlevelTransportSharedPlugin) {
     this.Log = logger;
     this.emitter = emitter;
@@ -31,18 +76,28 @@ export default class LowlevelTransport {
     this._messages = messages;
   }
 
+  configureProtocolV2(signedData: any) {
+    this._messagesV2 = parseConfigure(signedData);
+  }
+
   listen() {
     // empty
   }
 
-  enumerate() {
-    return this.plugin.enumerate();
+  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;
+    });
   }
 
   async acquire(input: LowLevelAcquireInput) {
     try {
       await this.plugin.connect(input.uuid);
-      return { uuid: input.uuid };
     } catch (error) {
       this.Log.debug('lowlelvel transport connect error: ', error);
       throw ERRORS.TypedError(
@@ -50,11 +105,25 @@ export default class LowlevelTransport {
         error.message ?? error
       );
     }
+
+    this.protocolV2Assemblers.set(input.uuid, new ProtocolV2FrameAssembler());
+    const protocolHint = input.expectedProtocol
+      ? undefined
+      : this.deviceProtocolHints.get(input.uuid);
+    const protocolType = await this.detectProtocol(
+      input.uuid,
+      input.expectedProtocol,
+      protocolHint
+    );
+    return { uuid: input.uuid, protocolType };
   }
 
   async release(uuid: string) {
     try {
       await this.plugin.disconnect(uuid);
+      this.deviceProtocol.delete(uuid);
+      this.deviceProtocolHints.delete(uuid);
+      this.protocolV2Assemblers.delete(uuid);
       return true;
     } catch (error) {
       this.Log.debug('lowlelvel transport disconnect error: ', error);
@@ -62,19 +131,57 @@ export default class LowlevelTransport {
     }
   }
 
-  async call(uuid: string, name: string, data: Record<string, unknown>) {
+  async call(
+    uuid: string,
+    name: string,
+    data: Record<string, unknown>,
+    options?: TransportCallOptions
+  ) {
     if (this._messages === null || !this._messages) {
       throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
     }
 
-    const messages = this._messages;
+    const protocol = this.getProtocolType(uuid);
+    if (!protocol) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        `Device protocol has not been detected for ${uuid}`
+      );
+    }
     if (LogBlockCommand.has(name)) {
-      this.Log.debug('lowlevel-transport', 'call-', ' name: ', name);
+      this.Log.debug('lowlevel-transport', 'call-', ' name: ', name, ' protocol: ', protocol);
     } else {
-      this.Log.debug('lowlevel-transport', 'call-', ' name: ', name, ' data: ', data);
+      this.Log.debug(
+        'lowlevel-transport',
+        'call-',
+        ' name: ',
+        name,
+        ' data: ',
+        data,
+        ' protocol: ',
+        protocol
+      );
+    }
+
+    if (protocol === 'V2') {
+      return this.callProtocolV2(uuid, name, data, options);
     }
 
-    const buffers = buildBuffers(messages, name, data);
+    return this.callProtocolV1(uuid, name, data, options);
+  }
+
+  private async callProtocolV1(
+    uuid: string,
+    name: string,
+    data: Record<string, unknown>,
+    options?: TransportCallOptions
+  ) {
+    if (!this._messages) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportNotConfigured);
+    }
+
+    const messages = this._messages;
+    const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
     for (const o of buffers) {
       const outData = o.toString('hex');
       // Upload resources on low-end phones may OOM
@@ -88,15 +195,263 @@ export default class LowlevelTransport {
     }
 
     try {
-      const response = await this.plugin.receive();
-      if (typeof response !== 'string') {
-        throw new Error('Returning data is not string');
-      }
+      const response = await this.readProtocolV1Message(options?.timeoutMs);
       this.Log.debug('receive data: ', response);
-      const jsonData = receiveOne(messages, response);
+      const jsonData = ProtocolV1.decodeMessage(messages, response);
       return check.call(jsonData);
     } catch (e) {
-      this.Log.error('lowlevel call error: ', e);
+      if (name === 'Initialize' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS) {
+        this.Log.debug('[LowlevelTransport] Protocol V1 Initialize probe call failed:', e);
+      } else {
+        this.Log.error('lowlevel call error: ', e);
+      }
+      throw e;
+    }
+  }
+
+  private createProtocolTimeoutError(name: string, timeout: number) {
+    return ERRORS.TypedError(
+      HardwareErrorCode.BleTimeoutError,
+      `Lowlevel response timeout after ${timeout}ms for ${name}`
+    );
+  }
+
+  private createProtocolMismatchError(expected: ProtocolType) {
+    return ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`
+    );
+  }
+
+  private createProtocolDetectionError() {
+    return ERRORS.TypedError(
+      HardwareErrorCode.BleTimeoutError,
+      'Unable to detect BLE protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping'
+    );
+  }
+
+  private clearProbeProtocol(uuid: string, protocol: ProtocolType) {
+    if (this.deviceProtocol.get(uuid) === protocol) {
+      this.deviceProtocol.delete(uuid);
+    }
+  }
+
+  private async detectProtocol(
+    uuid: string,
+    expectedProtocol?: ProtocolType,
+    protocolHint?: ProtocolType
+  ): Promise<ProtocolType> {
+    if (expectedProtocol === 'V2') {
+      if (await this.probeProtocolV2(uuid)) {
+        this.deviceProtocol.set(uuid, 'V2');
+        this.Log?.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V2 (expected)`);
+        return 'V2';
+      }
+      throw this.createProtocolMismatchError(expectedProtocol);
+    }
+
+    if (expectedProtocol === 'V1') {
+      if (await this.probeProtocolV1(uuid)) {
+        this.deviceProtocol.set(uuid, 'V1');
+        this.Log?.debug(`[LowlevelTransport] detectProtocol: uuid=${uuid} -> V1 (expected)`);
+        return 'V1';
+      }
+      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';
+    }
+
+    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';
+    }
+
+    this.deviceProtocol.delete(uuid);
+    throw this.createProtocolDetectionError();
+  }
+
+  private async resetConnectionAfterProbe(uuid: string, protocol: ProtocolType) {
+    this.protocolV2Assemblers.get(uuid)?.reset();
+
+    try {
+      await this.plugin.disconnect(uuid);
+    } catch (error) {
+      this.Log?.debug(
+        `[LowlevelTransport] disconnect after Protocol ${protocol} probe failed:`,
+        error
+      );
+    }
+
+    try {
+      await this.plugin.connect(uuid);
+    } catch (error) {
+      this.Log?.debug(
+        `[LowlevelTransport] reconnect after Protocol ${protocol} probe failed:`,
+        error
+      );
+      throw ERRORS.TypedError(
+        HardwareErrorCode.LowlevelTrasnportConnectError,
+        error.message ?? error
+      );
+    }
+  }
+
+  private async probeProtocolV1(uuid: string) {
+    if (!this._messages) {
+      return false;
+    }
+
+    try {
+      this.deviceProtocol.set(uuid, 'V1');
+      await this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+      return true;
+    } catch (error) {
+      this.clearProbeProtocol(uuid, 'V1');
+      this.Log?.debug('[LowlevelTransport] Protocol V1 Initialize probe failed:', error);
+      return false;
+    }
+  }
+
+  private async probeProtocolV2(uuid: string) {
+    if (!this._messages || !this._messagesV2) {
+      return false;
+    }
+
+    this.deviceProtocol.set(uuid, 'V2');
+    this.protocolV2Assemblers.get(uuid)?.reset();
+    try {
+      const detected = await probeProtocolV2Helper({
+        call: (name: string, data: Record<string, unknown>, options?: TransportCallOptions) =>
+          this.callProtocolV2(uuid, name, data, options),
+        timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
+        logger: this.Log,
+        logPrefix: 'ProtocolV2 Lowlevel-BLE',
+        onProbeFailed: async () => {
+          this.protocolV2Assemblers.get(uuid)?.reset();
+          await this.resetConnectionAfterProbe(uuid, 'V2');
+        },
+      });
+      if (!detected) {
+        this.clearProbeProtocol(uuid, 'V2');
+      }
+      return detected;
+    } catch (error) {
+      this.clearProbeProtocol(uuid, 'V2');
+      throw error;
+    }
+  }
+
+  private async receiveHex(timeoutMs: number | undefined, commandName: string) {
+    const response = await withProtocolTimeout(this.plugin.receive(), timeoutMs, () =>
+      this.createProtocolTimeoutError(commandName, timeoutMs ?? 0)
+    );
+    if (typeof response !== 'string') {
+      throw new Error('Returning data is not string');
+    }
+    return response;
+  }
+
+  private async readProtocolV1Message(timeoutMs?: number) {
+    const first = await this.receiveHex(timeoutMs, 'ProtocolV1');
+    const firstData = hexToBytes(first);
+    if (!isProtocolV1TransportChunk(firstData)) {
+      return first;
+    }
+
+    const payloadLength = readProtocolV1PayloadLength(firstData);
+    let buffer = firstData.slice(3);
+    const expectedLength = PROTOCOL_V1_MESSAGE_HEADER_SIZE + payloadLength;
+
+    while (buffer.length < expectedLength) {
+      const next = await this.receiveHex(timeoutMs, 'ProtocolV1');
+      buffer = concatUint8Arrays([buffer, hexToBytes(next)]);
+    }
+
+    return bytesToHex(buffer.slice(0, expectedLength));
+  }
+
+  private async readProtocolV2Frame(uuid: string, timeoutMs?: number) {
+    let assembler = this.protocolV2Assemblers.get(uuid);
+    if (!assembler) {
+      assembler = new ProtocolV2FrameAssembler();
+      this.protocolV2Assemblers.set(uuid, assembler);
+    }
+
+    const queuedFrame = assembler.push(new Uint8Array(0));
+    if (queuedFrame) return queuedFrame;
+
+    let frame: Uint8Array | undefined;
+    while (!frame) {
+      const response = await this.receiveHex(timeoutMs, 'ProtocolV2');
+      const chunk = hexToBytes(response);
+      if (chunk.length > 0) {
+        frame = assembler.push(chunk);
+      }
+    }
+    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 callProtocolV2(
+    uuid: string,
+    name: string,
+    data: Record<string, unknown>,
+    options?: TransportCallOptions
+  ) {
+    if (!this._messages || !this._messagesV2) {
+      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,
+      });
+    } catch (e) {
+      this.protocolV2Assemblers.get(uuid)?.reset();
+      this.Log.error('lowlevel Protocol V2 call error: ', e);
       throw e;
     }
   }

package/src/types.ts

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