@onekeyfe/hd-transport 1.2.0-alpha.105 → 1.2.0-alpha.107

package/__tests__/protocol-v2.test.js

@@ -233,32 +233,6 @@ const schemas = {
 };
 const productionProtocolV2Messages = parseConfigure(require('../messages-protocol-v2.json'));
 
-const legacyProtocolInfoMessage = parseConfigure({
-  nested: {
-    ProtocolInfo: {
-      fields: {
-        version: {
-          type: 'uint32',
-          id: 1,
-          rule: 'required',
-        },
-        supported_messages: {
-          type: 'uint32',
-          id: 2,
-          rule: 'repeated',
-          options: {
-            packed: false,
-          },
-        },
-        protobuf_definition: {
-          type: 'string',
-          id: 3,
-        },
-      },
-    },
-  },
-}).lookupType('ProtocolInfo');
-
 const rewriteSeq = (frame, seq) => {
   const copy = new Uint8Array(frame);
   copy[4] = 1;
@@ -293,64 +267,6 @@ describe('Protocol V2 framing and session', () => {
     });
   });
 
-  test('decodes a two-byte legacy ProtocolInfo at the generic frame boundary', () => {
-    const frame = protocolV2.encodeProtobufFrame(60201, new Uint8Array([0x08, 0x01]));
-    const productionSchemas = {
-      protocolV1: protocolV1Messages,
-      protocolV2: productionProtocolV2Messages,
-    };
-
-    expect(ProtocolV2.decodeFrame(productionSchemas, frame)).toMatchObject({
-      type: 'ProtocolInfo',
-      message: {
-        version: 1,
-        build_fingerprint: '',
-        supported_messages: [],
-        protobuf_definition: null,
-      },
-    });
-  });
-
-  test('does not reinterpret a malformed current ProtocolInfo as the legacy layout', () => {
-    const frame = protocolV2.encodeProtobufFrame(60201, new Uint8Array([0x08, 0x01, 0x18, 0x01]));
-
-    expect(() =>
-      ProtocolV2.decodeFrame(
-        {
-          protocolV1: protocolV1Messages,
-          protocolV2: productionProtocolV2Messages,
-        },
-        frame
-      )
-    ).toThrow('Protocol V2 protobuf decode failed for "ProtocolInfo"');
-  });
-
-  test('preserves legacy ProtocolInfo capabilities when using the old field numbers', () => {
-    const payload = legacyProtocolInfoMessage
-      .encode({
-        version: 1,
-        supported_messages: [60602],
-        protobuf_definition: 'legacy',
-      })
-      .finish();
-    const frame = protocolV2.encodeProtobufFrame(60201, payload);
-
-    const decoded = ProtocolV2.decodeFrame(
-      {
-        protocolV1: protocolV1Messages,
-        protocolV2: productionProtocolV2Messages,
-      },
-      frame
-    );
-
-    expect(decoded.message).toEqual({
-      version: 1,
-      build_fingerprint: '',
-      supported_messages: [60602],
-      protobuf_definition: null,
-    });
-  });
-
   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(
@@ -530,38 +446,6 @@ describe('Protocol V2 framing and session', () => {
     });
   });
 
-  test('session decodes legacy ProtocolInfo through the generic frame boundary', async () => {
-    const productionSchemas = {
-      protocolV1: protocolV1Messages,
-      protocolV2: productionProtocolV2Messages,
-    };
-    const response = protocolV2.encodeProtobufFrame(60201, new Uint8Array([0x08, 0x01]));
-    const session = new ProtocolV2Session({
-      schemas: productionSchemas,
-      router: 1,
-      writeFrame: () => Promise.resolve(),
-      readFrame: () => Promise.resolve(rewriteSeq(response, 1)),
-    });
-
-    await expect(
-      session.call(
-        'ProtocolInfoRequest',
-        { eventless_wallet_session: true },
-        {
-          expectedTypes: ['ProtocolInfo'],
-        }
-      )
-    ).resolves.toEqual({
-      type: 'ProtocolInfo',
-      message: {
-        version: 1,
-        build_fingerprint: '',
-        supported_messages: [],
-        protobuf_definition: null,
-      },
-    });
-  });
-
   test('session does not log Protocol V2 TX and RX frames', async () => {
     const written = [];
     const logger = { debug: jest.fn() };

package/dist/index.d.ts

@@ -263,18 +263,6 @@ declare const ProtocolV2: {
     };
     encodeFrame(schemas: ProtocolV2Schemas$1, name: string, data: Record<string, unknown>, options?: ProtocolV2FrameOptions): Uint8Array;
     decodeFrame(schemas: ProtocolV2Schemas$1, frame: Uint8Array): {
-        message: {
-            version: any;
-            build_fingerprint: string;
-            supported_messages: any;
-            protobuf_definition: null;
-        };
-        messageName: string;
-        messageTypeId: number;
-        pbPayload: Uint8Array;
-        seq: number;
-        type: string;
-    } | {
         message: {
             [key: string]: any;
         };
@@ -6870,18 +6858,6 @@ declare const _default: {
             protocolV1: protobuf.Root;
             protocolV2: protobuf.Root;
         }, frame: Uint8Array): {
-            message: {
-                version: any;
-                build_fingerprint: string;
-                supported_messages: any;
-                protobuf_definition: null;
-            };
-            messageName: string;
-            messageTypeId: number;
-            pbPayload: Uint8Array;
-            seq: number;
-            type: string;
-        } | {
             message: {
                 [key: string]: any;
             };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAG7C,OAAO,EAKL,cAAc,EACf,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,eAAe,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAEL,wBAAwB,EACxB,iBAAiB,EACjB,UAAU,EAEV,eAAe,EACf,UAAU,EACV,eAAe,EACf,mBAAmB,EACpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,KAAK,MAAM,0BAA0B,CAAC;AAKlD,YAAY,EACV,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,EACtB,2BAA2B,EAC3B,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,6BAA6B,EAC7B,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,YAAY,EACZ,8BAA8B,GAC/B,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AACpD,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAErC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,OAAO,KAAK,UAAU,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,UAAU,MAAM,gBAAgB,CAAC;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD,wBAsBE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAG7C,OAAO,EAKL,cAAc,EACf,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,eAAe,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,0BAA0B,EAAE,MAAM,mCAAmC,CAAC;AAC/E,OAAO,EAEL,wBAAwB,EACxB,iBAAiB,EACjB,UAAU,EAEV,eAAe,EACf,UAAU,EACV,eAAe,EACf,mBAAmB,EACpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,KAAK,MAAM,0BAA0B,CAAC;AAKlD,YAAY,EACV,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,EACtB,2BAA2B,EAC3B,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,EACrB,6BAA6B,EAC7B,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,YAAY,EACZ,8BAA8B,GAC/B,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AACpD,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAErC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,OAAO,KAAK,UAAU,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,UAAU,MAAM,gBAAgB,CAAC;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,mCAAmC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD,wBAsBE"}

package/dist/index.js

@@ -667,81 +667,6 @@ var protocolV2Codec = /*#__PURE__*/Object.freeze({
 });
 
 const PROTOCOL_V2_SYS_MESSAGE_THRESHOLD = 60000;
-const LEGACY_PROTOCOL_V2_PROTOCOL_INFO = protobuf.Type.fromJSON('LegacyProtocolInfo', {
-    fields: {
-        version: {
-            rule: 'required',
-            type: 'uint32',
-            id: 1,
-        },
-        supported_messages: {
-            rule: 'repeated',
-            type: 'uint32',
-            id: 2,
-            options: {
-                packed: false,
-            },
-        },
-        protobuf_definition: {
-            type: 'string',
-            id: 3,
-        },
-    },
-});
-const decodeLegacyProtocolV2ProtocolInfo = (pbPayload) => {
-    var _a;
-    const byteBuffer = ByteBuffer__default["default"].wrap(Buffer.from(pbPayload));
-    const legacy = decode(LEGACY_PROTOCOL_V2_PROTOCOL_INFO, byteBuffer);
-    return {
-        version: legacy.version,
-        build_fingerprint: '',
-        supported_messages: (_a = legacy.supported_messages) !== null && _a !== void 0 ? _a : [],
-        protobuf_definition: null,
-    };
-};
-const isLegacyProtocolV2ProtocolInfoWireLayout = (pbPayload) => {
-    const reader = protobuf.Reader.create(pbPayload);
-    let hasVersion = false;
-    try {
-        while (reader.pos < reader.len) {
-            const tag = reader.uint32();
-            const fieldNumber = tag >>> 3;
-            const wireType = tag & 0x07;
-            if (fieldNumber === 1) {
-                if (wireType !== 0)
-                    return false;
-                hasVersion = true;
-            }
-            else if (fieldNumber === 2) {
-                if (wireType !== 0)
-                    return false;
-            }
-            else if (fieldNumber === 3) {
-                if (wireType !== 2)
-                    return false;
-            }
-            else {
-                return false;
-            }
-            reader.skipType(wireType);
-        }
-    }
-    catch (_a) {
-        return false;
-    }
-    return hasVersion;
-};
-const tryDecodeLegacyProtocolV2ProtocolInfo = (messageName, pbPayload) => {
-    if (messageName !== 'ProtocolInfo' || !isLegacyProtocolV2ProtocolInfoWireLayout(pbPayload)) {
-        return undefined;
-    }
-    try {
-        return decodeLegacyProtocolV2ProtocolInfo(pbPayload);
-    }
-    catch (_a) {
-        return undefined;
-    }
-};
 const resolveProtocolV2EncodeSchema = (name, schemas) => {
     try {
         schemas.protocolV2.lookupType(name);
@@ -820,17 +745,6 @@ const ProtocolV2 = {
             message = decode(Message, rxByteBuffer);
         }
         catch (cause) {
-            const legacyProtocolInfo = tryDecodeLegacyProtocolV2ProtocolInfo(messageName, pbPayload);
-            if (legacyProtocolInfo) {
-                return {
-                    message: legacyProtocolInfo,
-                    messageName,
-                    messageTypeId,
-                    pbPayload,
-                    seq,
-                    type: messageName,
-                };
-            }
             const error = new Error(`Protocol V2 protobuf decode failed for "${messageName}" ` +
                 `(${messageTypeId}, ${pbPayload.length}-byte payload); ` +
                 'the payload is malformed or incompatible with the active SDK schema.');

package/dist/protocols/index.d.ts

@@ -40,18 +40,6 @@ export declare const ProtocolV2: {
     };
     encodeFrame(schemas: ProtocolV2Schemas, name: string, data: Record<string, unknown>, options?: ProtocolV2FrameOptions): Uint8Array;
     decodeFrame(schemas: ProtocolV2Schemas, frame: Uint8Array): {
-        message: {
-            version: any;
-            build_fingerprint: string;
-            supported_messages: any;
-            protobuf_definition: null;
-        };
-        messageName: string;
-        messageTypeId: number;
-        pbPayload: Uint8Array;
-        seq: number;
-        type: string;
-    } | {
         message: {
             [key: string]: any;
         };

package/dist/protocols/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/protocols/index.ts"],"names":[],"mappings":";AAAA,OAAO,UAAU,MAAM,YAAY,CAAC;AAGpC,OAAO,EAAE,qBAAqB,EAA+C,MAAM,cAAc,CAAC;AAElG,OAAO,EAAE,aAAa,IAAI,eAAe,EAAE,MAAM,cAAc,CAAC;AAIhE,OAAO,EAGL,kBAAkB,EAClB,UAAU,EACX,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C,eAAO,MAAM,iCAAiC,QAAQ,CAAC;AAEvD,KAAK,iBAAiB,GAAG;IACvB,UAAU,EAAE,IAAI,CAAC;IACjB,UAAU,EAAE,IAAI,CAAC;CAClB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAqHF,eAAO,MAAM,UAAU;;;;;;;;;;CAOtB,CAAC;AAEF,eAAO,MAAM,UAAU;;;0BAIC,iBAAiB,SAAS,UAAU;;;;;;;;;;yBAgB/C,iBAAiB,QACpB,MAAM,QACN,OAAO,MAAM,EAAE,OAAO,CAAC,YACpB,sBAAsB;yBAkBZ,iBAAiB,SAAS,UAAU;;;;;;;;;;;;;;;;;;;;;;CAqC1D,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/protocols/index.ts"],"names":[],"mappings":";AAAA,OAAO,UAAU,MAAM,YAAY,CAAC;AAEpC,OAAO,EAAE,qBAAqB,EAA+C,MAAM,cAAc,CAAC;AAElG,OAAO,EAAE,aAAa,IAAI,eAAe,EAAE,MAAM,cAAc,CAAC;AAIhE,OAAO,EAGL,kBAAkB,EAClB,UAAU,EACX,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C,eAAO,MAAM,iCAAiC,QAAQ,CAAC;AAEvD,KAAK,iBAAiB,GAAG;IACvB,UAAU,EAAE,IAAI,CAAC;IACjB,UAAU,EAAE,IAAI,CAAC;CAClB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAsCF,eAAO,MAAM,UAAU;;;;;;;;;;CAOtB,CAAC;AAEF,eAAO,MAAM,UAAU;;;0BAIC,iBAAiB,SAAS,UAAU;;;;;;;;;;yBAgB/C,iBAAiB,QACpB,MAAM,QACN,OAAO,MAAM,EAAE,OAAO,CAAC,YACpB,sBAAsB;yBAkBZ,iBAAiB,SAAS,UAAU;;;;;;;;;;CA0B1D,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport",
-  "version": "1.2.0-alpha.105",
+  "version": "1.2.0-alpha.107",
   "description": "Transport layer abstractions and utilities for OneKey hardware SDK.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -28,5 +28,5 @@
     "long": "^4.0.0",
     "protobufjs": "^6.11.2"
   },
-  "gitHead": "06431636d7bf40ab8ae28fd44a01893c0f220a74"
+  "gitHead": "23fe3be6f7b41066a704b4149b49bbc64d883c55"
 }

package/src/protocols/index.ts

@@ -1,5 +1,4 @@
 import ByteBuffer from 'bytebuffer';
-import { Reader, Type } from 'protobufjs/light';
 
 import { encodeEnvelopeMessage, encodeMessageChunks, encodeTransportPackets } from './v1/packets';
 import { decodeFirstChunk } from './v1/decode';
@@ -30,85 +29,6 @@ type ProtocolV2FrameOptions = {
   seq?: number;
 };
 
-const LEGACY_PROTOCOL_V2_PROTOCOL_INFO = Type.fromJSON('LegacyProtocolInfo', {
-  fields: {
-    version: {
-      rule: 'required',
-      type: 'uint32',
-      id: 1,
-    },
-    supported_messages: {
-      rule: 'repeated',
-      type: 'uint32',
-      id: 2,
-      options: {
-        packed: false,
-      },
-    },
-    protobuf_definition: {
-      type: 'string',
-      id: 3,
-    },
-  },
-});
-
-const decodeLegacyProtocolV2ProtocolInfo = (pbPayload: Uint8Array) => {
-  const byteBuffer = ByteBuffer.wrap(Buffer.from(pbPayload) as unknown as ArrayBuffer);
-  const legacy = decodeProtobuf(LEGACY_PROTOCOL_V2_PROTOCOL_INFO, byteBuffer);
-
-  return {
-    version: legacy.version,
-    build_fingerprint: '',
-    supported_messages: legacy.supported_messages ?? [],
-    // Presence of this legacy field lets Core keep the fallback recovery-only.
-    protobuf_definition: null,
-  };
-};
-
-const isLegacyProtocolV2ProtocolInfoWireLayout = (pbPayload: Uint8Array) => {
-  const reader = Reader.create(pbPayload);
-  let hasVersion = false;
-  try {
-    while (reader.pos < reader.len) {
-      const tag = reader.uint32();
-      // eslint-disable-next-line no-bitwise
-      const fieldNumber = tag >>> 3;
-      // eslint-disable-next-line no-bitwise
-      const wireType = tag & 0x07;
-      if (fieldNumber === 1) {
-        if (wireType !== 0) return false;
-        hasVersion = true;
-      } else if (fieldNumber === 2) {
-        // Legacy field 2 is repeated uint32; current field 2 is a string.
-        if (wireType !== 0) return false;
-      } else if (fieldNumber === 3) {
-        // Legacy field 3 is protobuf_definition; current field 3 is uint32.
-        if (wireType !== 2) return false;
-      } else {
-        return false;
-      }
-      reader.skipType(wireType);
-    }
-  } catch {
-    return false;
-  }
-  return hasVersion;
-};
-
-const tryDecodeLegacyProtocolV2ProtocolInfo = (messageName: string, pbPayload: Uint8Array) => {
-  // TEMPORARY COMPATIBILITY: Remove this fallback after all supported Pro2 and Neo
-  // firmware versions return ProtocolInfo with the current build_fingerprint layout.
-  if (messageName !== 'ProtocolInfo' || !isLegacyProtocolV2ProtocolInfoWireLayout(pbPayload)) {
-    return undefined;
-  }
-
-  try {
-    return decodeLegacyProtocolV2ProtocolInfo(pbPayload);
-  } catch {
-    return undefined;
-  }
-};
-
 const resolveProtocolV2EncodeSchema = (name: string, schemas: ProtocolV2Schemas) => {
   try {
     schemas.protocolV2.lookupType(name);
@@ -203,17 +123,6 @@ export const ProtocolV2 = {
     try {
       message = decodeProtobuf(Message, rxByteBuffer);
     } catch (cause) {
-      const legacyProtocolInfo = tryDecodeLegacyProtocolV2ProtocolInfo(messageName, pbPayload);
-      if (legacyProtocolInfo) {
-        return {
-          message: legacyProtocolInfo,
-          messageName,
-          messageTypeId,
-          pbPayload,
-          seq,
-          type: messageName,
-        };
-      }
       const error = new Error(
         `Protocol V2 protobuf decode failed for "${messageName}" ` +
           `(${messageTypeId}, ${pbPayload.length}-byte payload); ` +