@onekeyfe/hd-transport 1.1.26 → 1.1.27-alpha.31

package/__tests__/build-receive.test.js

@@ -1,7 +1,5 @@
 const { parseConfigure } = require('../src/serialization/protobuf/messages');
-const { buildOne } = require('../src/serialization/send');
-const { receiveOne } = require('../src/serialization/receive');
-const { buildEncodeBuffers } = require('../src/serialization/send');
+const { ProtocolV1 } = require('../src/protocols');
 
 const messages = {
   StellarPaymentOp: {
@@ -96,17 +94,17 @@ const parsedMessages = parseConfigure({
 describe('encoding json -> protobuf -> json', () => {
   fixtures.forEach(f => {
     describe(f.name, () => {
-      test('buildOne - receiveOne', () => {
+      test('encodeEnvelope - decodeMessage', () => {
         // encoded message
-        const encodedMessage = buildOne(parsedMessages, f.name, f.in);
+        const encodedMessage = ProtocolV1.encodeEnvelope(parsedMessages, f.name, f.in);
         // then decode message and check, whether decoded message matches original json
-        const decodedMessage = receiveOne(parsedMessages, encodedMessage);
+        const decodedMessage = ProtocolV1.decodeMessage(parsedMessages, encodedMessage);
         expect(decodedMessage.type).toEqual(f.name);
         expect(decodedMessage.message).toEqual(f.in);
       });
 
-      test('buildBuffers - receiveAndParse', () => {
-        const result = buildEncodeBuffers(parsedMessages, f.name, f.in);
+      test('encodeMessageChunks - receiveAndParse', () => {
+        const result = ProtocolV1.encodeMessageChunks(parsedMessages, f.name, f.in);
         result.forEach(r => {
           expect(r.byteLength).toBeLessThanOrEqual(63);
         });

package/__tests__/decode-features.test.js

@@ -1,8 +1,9 @@
+/* eslint-disable import/order */
 const ProtoBuf = require('protobufjs/light');
 const ByteBuffer = require('bytebuffer');
 
 const { decode } = require('../src/serialization/protobuf/decode');
-const { decode: decodeProtocol } = require('../src/serialization/protocol/decode');
+const { decodeEnvelope } = require('../src/protocols/v1/decode');
 
 // Reuse the messages.json already committed alongside @onekeyfe/hd-core
 // (runtime data for DataManager). hd-transport's own messages.json is
@@ -61,7 +62,7 @@ describe('Fix messages decode', () => {
       test('decode', () => {
         // deserialize
         const encoded = ByteBuffer.fromHex(f.encodeMessage);
-        const { buffer } = decodeProtocol(encoded);
+        const { buffer } = decodeEnvelope(encoded);
         const decoded = decode(Message, buffer);
 
         // filter null values

package/__tests__/protocol-v2.test.js

@@ -0,0 +1,481 @@
+const { ProtocolV2 } = require('../src/protocols');
+const { parseConfigure } = require('../src/serialization/protobuf/messages');
+const {
+  ProtocolV2FrameAssembler,
+  ProtocolV2Session,
+  probeProtocolV2,
+} = require('../src/protocols/v2/session');
+const protocolV2 = require('../src/protocols/v2');
+
+const protocolV1Messages = parseConfigure({
+  nested: {
+    Success: {
+      fields: {
+        message: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    OnekeyGetFeatures: {
+      fields: {},
+    },
+    OnekeyFeatures: {
+      fields: {},
+    },
+    MessageType: {
+      values: {
+        MessageType_Success: 2,
+        MessageType_OnekeyGetFeatures: 10025,
+        MessageType_OnekeyFeatures: 10026,
+      },
+    },
+  },
+});
+
+const protocolV2Messages = parseConfigure({
+  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,
+        },
+      },
+    },
+    DeviceFirmwareUpdate: {
+      fields: {},
+    },
+    DeviceFirmwareInstallProgress: {
+      fields: {
+        target_id: {
+          type: 'uint32',
+          id: 1,
+        },
+        progress: {
+          type: 'uint32',
+          id: 2,
+        },
+      },
+    },
+    FileWrite: {
+      fields: {},
+    },
+    PartialNested: {
+      fields: {
+        child: {
+          type: 'NestedChild',
+          id: 1,
+        },
+        label: {
+          type: 'string',
+          id: 2,
+        },
+      },
+    },
+    NestedChild: {
+      fields: {
+        value: {
+          type: 'string',
+          id: 1,
+        },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_GetProtoVersion: 60200,
+        MessageType_ProtoVersion: 60201,
+        MessageType_Ping: 60206,
+        MessageType_Success: 60207,
+        MessageType_FileWrite: 60805,
+        MessageType_DeviceFirmwareUpdate: 61000,
+        MessageType_DeviceFirmwareInstallProgress: 61001,
+        MessageType_PartialNested: 62000,
+      },
+    },
+  },
+});
+
+const schemas = {
+  protocolV1: protocolV1Messages,
+  protocolV2: protocolV2Messages,
+};
+
+const rewriteSeq = (frame, seq) => {
+  const copy = new Uint8Array(frame);
+  copy[6] = seq;
+  copy[copy.length - 1] = protocolV2.crc8(copy, copy.length - 1);
+  return copy;
+};
+
+describe('Protocol V2 framing and session', () => {
+  test('encodes and decodes Protocol V2 protobuf frames', () => {
+    const frame = ProtocolV2.encodeFrame(schemas, 'ProtoVersion', {
+      major_version: 1,
+      minor_version: 2,
+      patch_version: 3,
+    });
+
+    const parsed = protocolV2.decodeFrame(frame);
+    expect(parsed.msgType).toBe(60201);
+
+    const decoded = ProtocolV2.decodeFrame(schemas, frame);
+    expect(decoded).toEqual({
+      type: 'ProtoVersion',
+      messageName: 'ProtoVersion',
+      msgType: 60201,
+      pbPayload: parsed.pbPayload,
+      seq: parsed.seq,
+      message: {
+        major_version: 1,
+        minor_version: 2,
+        patch_version: 3,
+      },
+    });
+  });
+
+  test('does not encode V1-only messages into Protocol V2 frames', () => {
+    expect(() => ProtocolV2.encodeFrame(schemas, 'Ping', { message: 'ok' })).not.toThrow();
+    expect(() => ProtocolV2.encodeFrame(schemas, 'OnekeyGetFeatures', {})).toThrow(
+      'Protocol V2 message "OnekeyGetFeatures" is not defined'
+    );
+  });
+
+  test('decodes Protocol V2 frames with the Protocol V2 catalog first', () => {
+    const frame = ProtocolV2.encodeFrame(schemas, 'Success', {
+      message: 'ok',
+    });
+
+    const parsed = protocolV2.decodeFrame(frame);
+    expect(parsed.msgType).toBe(60207);
+
+    const decoded = ProtocolV2.decodeFrame(schemas, frame);
+    expect(decoded.type).toBe('Success');
+    expect(decoded.message).toEqual({ message: 'ok' });
+  });
+
+  test('decodes missing optional nested messages as null', () => {
+    const frame = ProtocolV2.encodeFrame(schemas, 'PartialNested', {
+      label: 'only label',
+    });
+
+    const decoded = ProtocolV2.decodeFrame(schemas, frame);
+    expect(decoded.message).toEqual({
+      child: null,
+      label: 'only label',
+    });
+  });
+
+  test('reassembles split Protocol V2 frames and rejects oversized frames', () => {
+    const frame = ProtocolV2.encodeFrame(schemas, 'ProtoVersion', {
+      major_version: 1,
+      minor_version: 0,
+      patch_version: 0,
+    });
+    const assembler = new ProtocolV2FrameAssembler();
+
+    expect(assembler.push(frame.slice(0, 4))).toBeUndefined();
+    expect(assembler.push(frame.slice(4))).toEqual(frame);
+
+    const oversized = new Uint8Array([0x5a, 0xff, 0xff]);
+    expect(() => assembler.push(oversized)).toThrow('Protocol V2 frame too large');
+  });
+
+  test('keeps bytes after the first complete frame for the next read', () => {
+    const first = ProtocolV2.encodeFrame(schemas, 'ProtoVersion', {
+      major_version: 1,
+      minor_version: 0,
+      patch_version: 0,
+    });
+    const second = ProtocolV2.encodeFrame(schemas, 'ProtoVersion', {
+      major_version: 2,
+      minor_version: 0,
+      patch_version: 0,
+    });
+    const assembler = new ProtocolV2FrameAssembler();
+    const combined = new Uint8Array(first.length + second.length);
+    combined.set(first, 0);
+    combined.set(second, first.length);
+
+    expect(assembler.push(combined)).toEqual(first);
+    expect(assembler.push(new Uint8Array(0))).toEqual(second);
+  });
+
+  test('session writes one encoded frame and decodes the response frame', async () => {
+    const written = [];
+    const response = ProtocolV2.encodeFrame(schemas, 'ProtoVersion', {
+      major_version: 2,
+      minor_version: 0,
+      patch_version: 1,
+    });
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      writeFrame: frame => {
+        written.push(frame);
+        return Promise.resolve();
+      },
+      readFrame: () =>
+        Promise.resolve(rewriteSeq(response, protocolV2.decodeFrame(written[0]).seq)),
+    });
+
+    const result = await session.call('GetProtoVersion', {});
+
+    expect(written).toHaveLength(1);
+    expect(written[0][4]).toBe(1);
+    expect(written[0][5]).toBe(0);
+    expect(protocolV2.decodeFrame(written[0]).msgType).toBe(60200);
+    expect(result).toEqual({
+      type: 'ProtoVersion',
+      message: {
+        major_version: 2,
+        minor_version: 0,
+        patch_version: 1,
+      },
+    });
+  });
+
+  test('session accepts response frames with a device-owned seq', async () => {
+    const response = ProtocolV2.encodeFrame(schemas, 'ProtoVersion', {
+      major_version: 2,
+      minor_version: 0,
+      patch_version: 1,
+    });
+    const logger = {
+      debug: jest.fn(),
+    };
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      writeFrame: () => Promise.resolve(),
+      readFrame: () => Promise.resolve(response),
+      logger,
+    });
+
+    await expect(session.call('GetProtoVersion', {})).resolves.toEqual({
+      type: 'ProtoVersion',
+      message: {
+        major_version: 2,
+        minor_version: 0,
+        patch_version: 1,
+      },
+    });
+    expect(logger.debug).toHaveBeenCalledWith(expect.stringContaining('seq differs'));
+  });
+
+  test('session logs decoded transmit and receive payloads', async () => {
+    const response = ProtocolV2.encodeFrame(schemas, 'Success', {
+      message: 'accepted',
+    });
+    const logger = {
+      debug: jest.fn(),
+    };
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      writeFrame: () => Promise.resolve(),
+      readFrame: () => Promise.resolve(response),
+      logger,
+      logPrefix: 'ProtocolV2 Test',
+    });
+
+    await expect(session.call('Ping', { message: 'hello' })).resolves.toEqual({
+      type: 'Success',
+      message: {
+        message: 'accepted',
+      },
+    });
+
+    expect(logger.debug).toHaveBeenCalledWith('[ProtocolV2 Test] TX payload name=Ping', {
+      message: 'hello',
+    });
+    expect(logger.debug).toHaveBeenCalledWith(
+      '[ProtocolV2 Test] RX payload type=Success msgType=60207',
+      {
+        message: 'accepted',
+      }
+    );
+  });
+
+  test('session suppresses payload logs for file transfer calls', async () => {
+    const response = ProtocolV2.encodeFrame(schemas, 'Success', {
+      message: 'ok',
+    });
+    const logger = {
+      debug: jest.fn(),
+    };
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      writeFrame: () => Promise.resolve(),
+      readFrame: () => Promise.resolve(response),
+      logger,
+    });
+
+    await expect(session.call('FileWrite', {})).resolves.toEqual({
+      type: 'Success',
+      message: {
+        message: 'ok',
+      },
+    });
+
+    expect(logger.debug.mock.calls.some(([message]) => String(message).includes('payload'))).toBe(
+      false
+    );
+  });
+
+  test('session skips unrelated terminal frames when expected response types are provided', async () => {
+    const stale = ProtocolV2.encodeFrame(schemas, 'Success', {
+      message: 'stale response',
+    });
+    const response = ProtocolV2.encodeFrame(schemas, 'ProtoVersion', {
+      major_version: 2,
+      minor_version: 0,
+      patch_version: 1,
+    });
+    const logger = {
+      debug: jest.fn(),
+    };
+    const readFrame = jest.fn().mockResolvedValueOnce(stale).mockResolvedValueOnce(response);
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      writeFrame: () => Promise.resolve(),
+      readFrame,
+      logger,
+    });
+
+    await expect(
+      session.call('GetProtoVersion', {}, { expectedTypes: ['ProtoVersion'] })
+    ).resolves.toEqual({
+      type: 'ProtoVersion',
+      message: {
+        major_version: 2,
+        minor_version: 0,
+        patch_version: 1,
+      },
+    });
+
+    expect(readFrame).toHaveBeenCalledTimes(2);
+    expect(logger.debug).toHaveBeenCalledWith(expect.stringContaining('skip unexpected response'));
+  });
+
+  test('session consumes intermediate response frames before returning the final response', async () => {
+    const written = [];
+    const progress = ProtocolV2.encodeFrame(schemas, 'DeviceFirmwareInstallProgress', {
+      target_id: 0,
+      progress: 42,
+    });
+    const success = ProtocolV2.encodeFrame(schemas, 'Success', {
+      message: 'ok',
+    });
+    const onIntermediateResponse = jest.fn();
+    const readFrame = jest.fn(() => {
+      const [writtenFrame] = written;
+      const { seq } = protocolV2.decodeFrame(writtenFrame);
+      return Promise.resolve(
+        readFrame.mock.calls.length === 1 ? rewriteSeq(progress, seq) : rewriteSeq(success, seq)
+      );
+    });
+    const session = new ProtocolV2Session({
+      schemas,
+      router: 1,
+      writeFrame: frame => {
+        written.push(frame);
+        return Promise.resolve();
+      },
+      readFrame,
+    });
+
+    const result = await session.call(
+      'DeviceFirmwareUpdate',
+      {},
+      {
+        intermediateTypes: ['DeviceFirmwareInstallProgress'],
+        onIntermediateResponse,
+      }
+    );
+
+    expect(readFrame).toHaveBeenCalledTimes(2);
+    expect(onIntermediateResponse).toHaveBeenCalledWith({
+      type: 'DeviceFirmwareInstallProgress',
+      message: {
+        target_id: 0,
+        progress: 42,
+      },
+    });
+    expect(result).toEqual({
+      type: 'Success',
+      message: {
+        message: 'ok',
+      },
+    });
+  });
+
+  test('probeProtocolV2 accepts Ping success as a normal V2 probe response', async () => {
+    await expect(
+      probeProtocolV2({
+        call: () => Promise.resolve({ type: 'Success', message: {} }),
+        timeoutMs: 1,
+      })
+    ).resolves.toBe(true);
+
+    await expect(
+      probeProtocolV2({
+        call: () => Promise.resolve({ type: 'Failure', message: {} }),
+        timeoutMs: 1,
+      })
+    ).resolves.toBe(false);
+  });
+
+  test('probeProtocolV2 only uses Ping for acquire probing', async () => {
+    const call = jest.fn().mockRejectedValue(new Error('ping timeout'));
+    const onProbeFailed = jest.fn();
+
+    await expect(
+      probeProtocolV2({
+        call,
+        timeoutMs: 1,
+        onProbeFailed,
+      })
+    ).resolves.toBe(false);
+    expect(call).toHaveBeenNthCalledWith(
+      1,
+      'Ping',
+      { message: 'probe' },
+      {
+        timeoutMs: 1,
+        expectedTypes: ['Success'],
+      }
+    );
+    expect(call).toHaveBeenCalledTimes(1);
+    expect(onProbeFailed).toHaveBeenCalledWith(expect.any(Error));
+  });
+});

package/dist/constants.d.ts

@@ -1,6 +1,15 @@
-export declare const MESSAGE_TOP_CHAR = 63;
-export declare const MESSAGE_HEADER_BYTE = 35;
-export declare const HEADER_SIZE: number;
-export declare const BUFFER_SIZE = 63;
-export declare const COMMON_HEADER_SIZE = 6;
+export declare const PROTOCOL_V1_REPORT_ID = 63;
+export declare const PROTOCOL_V1_HEADER_BYTE = 35;
+export declare const PROTOCOL_V1_CHUNK_PAYLOAD_SIZE = 63;
+export declare const PROTOCOL_V1_USB_PACKET_SIZE: number;
+export declare const PROTOCOL_V1_MESSAGE_HEADER_SIZE: number;
+export declare const PROTOCOL_V1_ENVELOPE_HEADER_SIZE: number;
+export declare const PROTOCOL_V2_FRAME_MAX_BYTES = 4608;
+export declare const PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE = 4096;
+export declare const PROTOCOL_V2_BLE_FILE_CHUNK_SIZE = 1800;
+export declare const PROTOCOL_V2_FILE_CHUNK_SIZE = 4096;
+export declare const PROTOCOL_V2_CHANNEL_USB = 0;
+export declare const PROTOCOL_V2_CHANNEL_BLE_UART = 1;
+export declare const PROTOCOL_V2_CHANNEL_SOCKET = 2;
+export declare const PROTOCOL_V2_PACKET_SRC_COMMAND = 0;
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,KAAS,CAAC;AACvC,eAAO,MAAM,mBAAmB,KAAO,CAAC;AACxC,eAAO,MAAM,WAAW,QAAgB,CAAC;AACzC,eAAO,MAAM,WAAW,KAAK,CAAC;AAI9B,eAAO,MAAM,kBAAkB,IAAI,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,KAAO,CAAC;AAG1C,eAAO,MAAM,uBAAuB,KAAO,CAAC;AAG5C,eAAO,MAAM,8BAA8B,KAAK,CAAC;AAGjD,eAAO,MAAM,2BAA2B,QAAqC,CAAC;AAG9E,eAAO,MAAM,+BAA+B,QAAQ,CAAC;AAGrD,eAAO,MAAM,gCAAgC,QAA0C,CAAC;AAKxF,eAAO,MAAM,2BAA2B,OAAO,CAAC;AAGhD,eAAO,MAAM,kCAAkC,OAAO,CAAC;AAGvD,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAGpD,eAAO,MAAM,2BAA2B,OAAqC,CAAC;AAM9E,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAC9C,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAG5C,eAAO,MAAM,8BAA8B,IAAI,CAAC"}