@onekeyfe/hd-transport 1.2.7 → 1.2.8-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport",
-  "version": "1.2.7",
+  "version": "1.2.8-alpha.10",
   "description": "Transport layer abstractions and utilities for OneKey hardware SDK.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -11,9 +11,9 @@
     "access": "public"
   },
   "scripts": {
-    "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
-    "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
-    "test": "jest",
+    "dev": "node scripts/protobuf-static.js && rimraf dist && rollup -c ../../build/rollup.config.js -w",
+    "build": "node scripts/protobuf-static.js && rimraf dist && rollup -c ../../build/rollup.config.js",
+    "test": "node scripts/protobuf-static.js && jest",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "update:protobuf": "./scripts/protobuf-build.sh"
@@ -28,5 +28,5 @@
     "long": "^4.0.0",
     "protobufjs": "^6.11.2"
   },
-  "gitHead": "6cf9b7d76b905f168169fd0442af8636afd2b469"
+  "gitHead": "47d2f63acb8e5fa9ee623c060af7c9f83ad6f939"
 }

package/scripts/protobuf-build.sh

@@ -54,6 +54,36 @@ grep -hv -e '^import ' -e '^syntax' -e '^package' -e 'option java_' "$SRC_PATH"/
 | sed 's/^option /\/\/ option /' \
 | grep -v '    reserved ' >> "$V1_TMP_PROTO"
 
+# Classic 1s exposes these messages before the shared firmware submodule includes them.
+# Wire contract: https://onekeygroup.slack.com/archives/C0A7BUG1DT6/p1791598732003599
+node - "$V1_TMP_PROTO" <<'NODE'
+const fs = require('fs');
+const protoPath = process.argv[2];
+let proto = fs.readFileSync(protoPath, 'utf8');
+proto = proto.replace('enum MessageType {', `enum MessageType {
+    MessageType_BabylonDeriveContextHash = 10054 [(bitcoin_only) = true, (wire_in) = true];
+    MessageType_BabylonDerivedContextHash = 10055 [(bitcoin_only) = true, (wire_out) = true];`);
+proto += `
+enum CanonicalBitcoinNetwork {
+    BITCOIN_MAINNET = 0;
+    BITCOIN_TESTNET = 1;
+    BITCOIN_SIGNET = 2;
+    BITCOIN_REGTEST = 3;
+}
+message BabylonDeriveContextHash {
+    repeated uint32 address_n = 1;
+    required InputScriptType script_type = 2;
+    required bytes app_name = 3;
+    required bytes context = 4;
+    required CanonicalBitcoinNetwork network = 5;
+}
+message BabylonDerivedContextHash {
+    required bytes secret = 1;
+}
+`;
+fs.writeFileSync(protoPath, proto);
+NODE
+
 npx pbjs -t json -p "$DIST_PATH" -o "$DIST_PATH/messages.json" --keep-case "$V1_TMP_PROTO"
 cp "$DIST_PATH/messages.json" "$CORE_MESSAGES_DIR/messages.json"
 

package/scripts/protobuf-static.js

@@ -0,0 +1,105 @@
+const fs = require('fs');
+const path = require('path');
+const protobuf = require('protobufjs/light');
+const pbjs = require('protobufjs/cli/pbjs');
+
+const packageRoot = path.resolve(__dirname, '..');
+const outputDirectory = path.join(packageRoot, 'lib');
+const legacyProtocolInfoSchema = {
+  nested: {
+    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 },
+      },
+    },
+  },
+};
+
+// Match descriptors independent of JSON property order, without a hash collision risk.
+function schemaKey(schema) {
+  return JSON.stringify(schema, (_key, value) => {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      return Object.keys(value)
+        .sort()
+        .reduce((result, key) => {
+          result[key] = value[key];
+          return result;
+        }, {});
+    }
+    return value;
+  });
+}
+
+async function generate() {
+  fs.mkdirSync(outputDirectory, { recursive: true });
+  const legacyPath = path.join(outputDirectory, 'legacy-protocol-info.json');
+  fs.writeFileSync(legacyPath, JSON.stringify(legacyProtocolInfoSchema));
+  const sources = [
+    path.resolve(packageRoot, '../core/src/data/messages/messages.json'),
+    path.resolve(packageRoot, '../core/src/data/messages/messages_legacy_v1.json'),
+    path.join(packageRoot, 'messages-protocol-v2.json'),
+    legacyPath,
+  ];
+  const entries = [];
+  for (const [index, source] of sources.entries()) {
+    const schema = JSON.parse(fs.readFileSync(source, 'utf8'));
+    const code = await new Promise((resolve, reject) => {
+      pbjs.main(
+        ['-t', 'static', '--no-comments', '--no-service', '--root', `onekey-csp-${index}`, source],
+        (error, output) => (error ? reject(error) : resolve(output))
+      );
+    });
+    const types = [];
+    const collect = namespace => {
+      if (namespace instanceof protobuf.Type) {
+        const reference = namespace.fullName
+          .split('.')
+          .slice(1)
+          .map(name => `[${JSON.stringify(name)}]`)
+          .join('');
+        types.push(`${JSON.stringify(namespace.fullName)}: $root${reference}`);
+      }
+      (namespace.nestedArray || []).forEach(collect);
+    };
+    collect(protobuf.Root.fromJSON(schema));
+    entries.push(
+      `${JSON.stringify(
+        schemaKey(schema)
+      )}: function () {\nconst $protobuf = { ...protobuf, roots: {} };\n${code}\nreturn {${types.join(
+        ',\n'
+      )}};\n}`
+    );
+  }
+  fs.writeFileSync(
+    path.join(outputDirectory, 'protobuf-static.js'),
+    `// Generated by scripts/protobuf-static.js. Do not edit.\n` +
+      `/* istanbul ignore file */\n` +
+      `const protobuf = require('protobufjs/minimal');\n` +
+      `protobuf.util.Long = require('long');\nprotobuf.configure();\n` +
+      `${schemaKey.toString()}\n` +
+      `module.exports = { schemaKey, legacyProtocolInfoSchema: ${JSON.stringify(
+        legacyProtocolInfoSchema
+      )}, schemas: {\n${entries.join(',\n')}\n} };\n`
+  );
+  fs.writeFileSync(
+    path.join(outputDirectory, 'protobuf-static.d.ts'),
+    `import type { Constructor, INamespace, Type } from 'protobufjs/light';\n` +
+      `type StaticMessageConstructor = Constructor<{}> & Pick<Type, 'encode' | 'decode' | 'verify' | 'fromObject' | 'toObject'>;\n` +
+      `export function schemaKey(schema: INamespace): string;\n` +
+      `export const schemas: Partial<Record<string, () => Record<string, StaticMessageConstructor>>>;\n` +
+      `export const legacyProtocolInfoSchema: INamespace;\n`
+  );
+  fs.unlinkSync(legacyPath);
+}
+
+generate().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/protobuf-types.js

@@ -55,6 +55,7 @@ const hasParsedType = name => types.some(t => t && t.name === name);
 // enums used as keys (string), used as values (number) by default
 const ENUM_KEYS = [
   'InputScriptType',
+  'CanonicalBitcoinNetwork',
   'OutputScriptType',
   'RequestType',
   'KaspaInputScriptType',

package/src/protocols/index.ts

@@ -1,12 +1,17 @@
 import ByteBuffer from 'bytebuffer';
-import { Reader, Type } from 'protobufjs/light';
+import { Reader } from 'protobufjs/light';
 
 import { encodeEnvelopeMessage, encodeMessageChunks, encodeTransportPackets } from './v1/packets';
 import { decodeFirstChunk } from './v1/decode';
 import { decodeMessage as decodeV1Message } from './v1/receive';
-import { createMessageFromName, createMessageFromType } from '../serialization/protobuf/messages';
+import {
+  createMessageFromName,
+  createMessageFromType,
+  parseConfigure,
+} from '../serialization/protobuf/messages';
 import { encode as encodeProtobuf } from '../serialization/protobuf/encode';
 import { decode as decodeProtobuf } from '../serialization/protobuf/decode';
+import { legacyProtocolInfoSchema } from '../../lib/protobuf-static';
 import {
   decodeFrame as decodeV2Frame,
   encodeProtobufFrame,
@@ -30,27 +35,8 @@ 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 LEGACY_PROTOCOL_V2_PROTOCOL_INFO =
+  parseConfigure(legacyProtocolInfoSchema).lookupType('LegacyProtocolInfo');
 
 const decodeLegacyProtocolV2ProtocolInfo = (pbPayload: Uint8Array) => {
   const byteBuffer = ByteBuffer.wrap(Buffer.from(pbPayload) as unknown as ArrayBuffer);

package/src/serialization/protobuf/messages.ts

@@ -1,11 +1,42 @@
 import * as protobuf from 'protobufjs/light';
 
+import { schemaKey, schemas } from '../../../lib/protobuf-static';
+
 export function parseConfigure(data: protobuf.INamespace) {
   // @ts-ignore [compatiblity]: connect is sending stringified json
-  if (typeof data === 'string') {
-    return protobuf.Root.fromJSON(JSON.parse(data));
+  const schema = typeof data === 'string' ? JSON.parse(data) : data;
+  const key = schemaKey(schema);
+  const createConstructors = schemas[key];
+  // Field resolution mutates options; keep built-in descriptors reusable across connections.
+  const messages = protobuf.Root.fromJSON(
+    createConstructors ? JSON.parse(JSON.stringify(schema)) : schema
+  );
+  if (createConstructors) {
+    const constructors = createConstructors();
+    const types: protobuf.Type[] = [];
+    const collect = (namespace: protobuf.Namespace) => {
+      if (namespace instanceof protobuf.Type) types.push(namespace);
+      namespace.nestedArray.forEach(child => {
+        if (child instanceof protobuf.Namespace) collect(child);
+      });
+    };
+    collect(messages);
+    // Register every constructor before resolving fields, which access parent.ctor.
+    types.forEach(type => {
+      type.ctor = constructors[type.fullName];
+    });
+    types.forEach(type => {
+      const constructor = constructors[type.fullName];
+      type.encode = constructor.encode;
+      type.decode = constructor.decode;
+      type.verify = constructor.verify;
+      type.fromObject = constructor.fromObject;
+      type.toObject = constructor.toObject;
+      type.setup = () => type;
+    });
+    messages.resolveAll();
   }
-  return protobuf.Root.fromJSON(data);
+  return messages;
 }
 
 export const createMessageFromName = (messages: protobuf.Root, name: string) => {

package/src/types/messages.ts

@@ -4554,6 +4554,28 @@ export enum CommandFlags {
   Factory_Only = 1,
 }
 
+export enum Enum_CanonicalBitcoinNetwork {
+  BITCOIN_MAINNET = 0,
+  BITCOIN_TESTNET = 1,
+  BITCOIN_SIGNET = 2,
+  BITCOIN_REGTEST = 3,
+}
+export type CanonicalBitcoinNetwork = keyof typeof Enum_CanonicalBitcoinNetwork;
+
+// BabylonDeriveContextHash
+export type BabylonDeriveContextHash = {
+  address_n: number[];
+  script_type: InputScriptType;
+  app_name: string;
+  context: string;
+  network: CanonicalBitcoinNetwork;
+};
+
+// BabylonDerivedContextHash
+export type BabylonDerivedContextHash = {
+  secret: string;
+};
+
 export type TextMemo = {
   text: string;
 };
@@ -5949,6 +5971,8 @@ export type MessageType = {
   TronSignMessage: TronSignMessage;
   TronMessageSignature: TronMessageSignature;
   facotry: facotry;
+  BabylonDeriveContextHash: BabylonDeriveContextHash;
+  BabylonDerivedContextHash: BabylonDerivedContextHash;
   TextMemo: TextMemo;
   RefundMemo: RefundMemo;
   CoinPurchaseMemo: CoinPurchaseMemo;

package/src/utils/transportLog.ts

@@ -19,6 +19,7 @@ const SENSITIVE_LOG_KEYS = new Set([
   'privatekey',
   'publickey',
   'seed',
+  'secret',
   'serialnumber',
   'session',
   'sessionid',