@onekeyfe/hd-transport-lowlevel 1.1.34-alpha.2 → 1.1.34-alpha.3

package/.eslintignore

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

package/__tests__/protocol-v2.test.js

@@ -0,0 +1,388 @@
+/* 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: {
+    ProtocolInfoRequest: {
+      fields: {},
+    },
+    ProtocolInfo: {
+      fields: {
+        version: {
+          type: 'uint32',
+          id: 1,
+        },
+        supported_messages: {
+          rule: 'repeated',
+          type: 'uint32',
+          id: 2,
+          options: {
+            packed: false,
+          },
+        },
+        protobuf_definition: {
+          type: 'string',
+          id: 3,
+        },
+      },
+    },
+    Ping: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    Success: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_ProtocolInfoRequest: 60200,
+        MessageType_ProtocolInfo: 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: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const callResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'ProtocolInfo',
+      {
+        version: 1,
+        supported_messages: [60200, 60201, 60206, 60207],
+        protobuf_definition: 'onekey-protocol-v2',
+      },
+      { 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', 'ProtocolInfoRequest', {})).resolves.toEqual({
+      type: 'ProtocolInfo',
+      message: {
+        version: 1,
+        supported_messages: [60200, 60201, 60206, 60207],
+        protobuf_definition: 'onekey-protocol-v2',
+      },
+    });
+    expect(plugin.send).toHaveBeenCalled();
+    const sentSeqs = plugin.send.mock.calls.map(([, hex]) =>
+      Number.parseInt(hex.slice(12, 14), 16)
+    );
+    expect(sentSeqs).toEqual([1, 2]);
+  });
+
+  test('falls back to Protocol V2 probe for unnamed Protocol V2 devices', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { 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('retains the Protocol V2 hint and sequence cursor across release and reacquire', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const plugin = createPlugin({
+      devices: [{ id: 'reconnect-pro2-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [bytesToHex(probeResponse), bytesToHex(probeResponse)],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await lowlevel.enumerate();
+    await expect(lowlevel.acquire({ uuid: 'reconnect-pro2-id' })).resolves.toEqual({
+      uuid: 'reconnect-pro2-id',
+      protocolType: 'V2',
+    });
+    await lowlevel.release('reconnect-pro2-id');
+    await expect(lowlevel.acquire({ uuid: 'reconnect-pro2-id' })).resolves.toEqual({
+      uuid: 'reconnect-pro2-id',
+      protocolType: 'V2',
+    });
+
+    const sentSeqs = plugin.send.mock.calls.map(([, hex]) =>
+      Number.parseInt(hex.slice(12, 14), 16)
+    );
+    expect(sentSeqs).toEqual([1, 2]);
+  });
+
+  test('reuses the active generation when Core acquires the same BLE connection again', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { router: PROTOCOL_V2_CHANNEL_BLE_UART }
+    );
+    const plugin = createPlugin({
+      devices: [{ id: 'repeated-acquire-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [bytesToHex(probeResponse), bytesToHex(probeResponse)],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(
+      lowlevel.acquire({ uuid: 'repeated-acquire-id', expectedProtocol: 'V2' })
+    ).resolves.toEqual({
+      uuid: 'repeated-acquire-id',
+      protocolType: 'V2',
+    });
+    await lowlevel.call('repeated-acquire-id', 'Ping', { message: 'first-acquire' });
+    await expect(
+      lowlevel.acquire({ uuid: 'repeated-acquire-id', expectedProtocol: 'V2' })
+    ).resolves.toEqual({
+      uuid: 'repeated-acquire-id',
+      protocolType: 'V2',
+    });
+    await lowlevel.call('repeated-acquire-id', 'Ping', { message: 'second-acquire' });
+
+    const sentSeqs = plugin.send.mock.calls.map(([, hex]) =>
+      Number.parseInt(hex.slice(12, 14), 16)
+    );
+    expect(sentSeqs).toEqual([1, 2]);
+  });
+
+  test('trusts explicit Protocol V2 during bootloader reconnect without probing Ping', async () => {
+    const plugin = createPlugin({
+      devices: [{ id: 'bootloader-v2-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [],
+    });
+    const lowlevel = configureTransport(plugin);
+
+    await expect(
+      lowlevel.acquire({ uuid: 'bootloader-v2-id', expectedProtocol: 'V2' })
+    ).resolves.toEqual({
+      uuid: 'bootloader-v2-id',
+      protocolType: 'V2',
+    });
+    expect(plugin.send).not.toHaveBeenCalled();
+    expect(plugin.receive).not.toHaveBeenCalled();
+  });
+
+  test('resets the lowlevel connection before probing Protocol V2 after a V1 timeout', async () => {
+    const probeResponse = ProtocolV2.encodeFrame(
+      schemas,
+      'Success',
+      { message: 'ok' },
+      { 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('disconnects a tainted Protocol V2 link after a response timeout', async () => {
+    const plugin = createPlugin({
+      devices: [{ id: 'timeout-v2-id', name: 'OneKey Pro 2', commType: 'ble' }],
+      responses: [],
+    });
+    plugin.receive.mockImplementation(() => new Promise(() => {}));
+    const lowlevel = configureTransport(plugin);
+
+    await lowlevel.acquire({ uuid: 'timeout-v2-id', expectedProtocol: 'V2' });
+    plugin.disconnect.mockClear();
+    await expect(
+      lowlevel.call('timeout-v2-id', 'Ping', { message: 'timeout' }, { timeoutMs: 10 })
+    ).rejects.toThrow('Lowlevel response timeout after 10ms for Ping');
+
+    expect(plugin.disconnect).toHaveBeenCalledWith('timeout-v2-id');
+  });
+
+  test('verifies expected Protocol V1 instead of trusting the requested protocol', async () => {
+    const plugin = createPlugin({
+      devices: [{ id: 'v2-id', name: 'Unknown BLE Device', commType: 'ble' }],
+      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,53 @@
-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;
+    private protocolV2Generations;
+    private connectedDevices;
+    private protocolV2Links;
+    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;
+    private createProtocolV2Adapter;
+    private advanceProtocolV2Generation;
     cancel(): void;
 }
 

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,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,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"}