@onekeyfe/hd-transport 1.2.10-alpha.1 → 1.2.10-alpha.2

package/messages-protocol-v2.json

@@ -11034,6 +11034,94 @@
         }
       }
     },
+    "ZcashAddressType": {
+      "values": {
+        "UNIFIED_ORCHARD_P2PKH": 0,
+        "TRANSPARENT_P2PKH": 1,
+        "UNIFIED_ORCHARD": 2
+      }
+    },
+    "ZcashAddressScope": {
+      "values": {
+        "EXTERNAL": 0,
+        "INTERNAL": 1
+      }
+    },
+    "ZcashGetAddress": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "show_display": {
+          "type": "bool",
+          "id": 2
+        },
+        "include_seed_fingerprint": {
+          "type": "bool",
+          "id": 3
+        },
+        "diversifier_index": {
+          "type": "uint32",
+          "id": 5,
+          "options": {
+            "default": 0
+          }
+        },
+        "address_type": {
+          "type": "ZcashAddressType",
+          "id": 6,
+          "options": {
+            "default": "UNIFIED_ORCHARD_P2PKH"
+          }
+        },
+        "scope": {
+          "type": "ZcashAddressScope",
+          "id": 7,
+          "options": {
+            "default": "EXTERNAL"
+          }
+        }
+      }
+    },
+    "ZcashAddress": {
+      "fields": {
+        "address": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        },
+        "seed_fingerprint": {
+          "type": "bytes",
+          "id": 3
+        }
+      }
+    },
+    "ZcashGetFullViewingKey": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        }
+      }
+    },
+    "ZcashFullViewingKey": {
+      "fields": {
+        "ufvk": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
     "ZcashSignPczt": {
       "fields": {
         "pczt_length": {
@@ -11514,11 +11602,15 @@
         "MessageType_NeoAddress": 12302,
         "MessageType_NeoSignTx": 12303,
         "MessageType_NeoSignedTx": 12304,
+        "MessageType_ZcashGetAddress": 12400,
+        "MessageType_ZcashAddress": 12401,
         "MessageType_ZcashSignPczt": 12402,
         "MessageType_ZcashSignedPczt": 12403,
         "MessageType_ZcashPcztChunkRequest": 12404,
         "MessageType_ZcashPcztChunkAck": 12405,
         "MessageType_ZcashSignedPcztChunkRequest": 12406,
+        "MessageType_ZcashGetFullViewingKey": 12407,
+        "MessageType_ZcashFullViewingKey": 12408,
         "MessageType_DeviceFactoryInfoSet": 60000,
         "MessageType_DeviceFactoryInfoGet": 60001,
         "MessageType_DeviceFactoryInfo": 60002,
@@ -11571,9 +11663,7 @@
         "MessageType_PortfolioUpdate": 61400,
         "MessageType_NftUpdate": 61500,
         "MessageType_OnboardingStatusGet": 61600,
-        "MessageType_OnboardingStatus": 61601,
-        "MessageType_ZcashGetAddress": 12400,
-        "MessageType_ZcashAddress": 12401
+        "MessageType_OnboardingStatus": 61601
       },
       "reserved": [
         [90, 92],
@@ -13792,81 +13882,6 @@
           }
         }
       }
-    },
-    "ZcashAddressType": {
-      "values": {
-        "UNIFIED_ORCHARD_P2PKH": 0,
-        "TRANSPARENT_P2PKH": 1,
-        "UNIFIED_ORCHARD": 2
-      }
-    },
-    "ZcashAddressScope": {
-      "values": {
-        "EXTERNAL": 0,
-        "INTERNAL": 1
-      }
-    },
-    "ZcashGetAddress": {
-      "fields": {
-        "address_n": {
-          "rule": "repeated",
-          "type": "uint32",
-          "id": 1,
-          "options": {
-            "packed": false
-          }
-        },
-        "show_display": {
-          "type": "bool",
-          "id": 2
-        },
-        "include_seed_fingerprint": {
-          "type": "bool",
-          "id": 3
-        },
-        "include_ufvk": {
-          "type": "bool",
-          "id": 4
-        },
-        "diversifier_index": {
-          "type": "uint32",
-          "id": 5,
-          "options": {
-            "default": 0
-          }
-        },
-        "address_type": {
-          "type": "ZcashAddressType",
-          "id": 6,
-          "options": {
-            "default": "UNIFIED_ORCHARD_P2PKH"
-          }
-        },
-        "scope": {
-          "type": "ZcashAddressScope",
-          "id": 7,
-          "options": {
-            "default": "EXTERNAL"
-          }
-        }
-      }
-    },
-    "ZcashAddress": {
-      "fields": {
-        "address": {
-          "rule": "required",
-          "type": "string",
-          "id": 1
-        },
-        "ufvk": {
-          "type": "string",
-          "id": 2
-        },
-        "seed_fingerprint": {
-          "type": "bytes",
-          "id": 3
-        }
-      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport",
-  "version": "1.2.10-alpha.1",
+  "version": "1.2.10-alpha.2",
   "description": "Transport layer abstractions and utilities for OneKey hardware SDK.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -12,8 +12,10 @@
   },
   "scripts": {
     "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
-    "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "build": "node scripts/protobuf-static.js --check && rimraf dist && rollup -c ../../build/rollup.config.js",
     "test": "jest",
+    "test:static-csp": "node --disallow-code-generation-from-strings scripts/protobuf-static-csp.js",
+    "check:static": "node scripts/protobuf-static.js --check",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "update:protobuf": "./scripts/protobuf-build.sh"
@@ -26,7 +28,7 @@
   "dependencies": {
     "bytebuffer": "^5.0.1",
     "long": "^4.0.0",
-    "protobufjs": "^6.11.2"
+    "protobufjs": "6.11.6"
   },
-  "gitHead": "df785eba29f144fac2cfdcbd808426e0a2c259b2"
+  "gitHead": "2bcc72a43379abb005405f18f914330f3f2dbfd7"
 }

package/scripts/protobuf-build.sh

@@ -7,6 +7,11 @@ PACKAGE_ROOT="$PARENT_PATH/.."
 REPO_ROOT="$PARENT_PATH/../../.."
 CORE_MESSAGES_DIR="$REPO_ROOT/packages/core/src/data/messages"
 
+if [[ "${1:-}" == "--static-only" ]]; then
+    node "$PARENT_PATH/protobuf-static.js"
+    exit 0
+fi
+
 SRC="../../submodules/firmware/common/protob"
 DIST="."
 LANG="typescript"
@@ -166,3 +171,5 @@ yarn --cwd "$PACKAGE_ROOT" prettier --write "$CORE_MESSAGES_DIR/messages.json"
 yarn --cwd "$PACKAGE_ROOT" prettier --write "$PACKAGE_ROOT/messages-protocol-v2.json"
 yarn --cwd "$PACKAGE_ROOT" prettier --write "$CORE_MESSAGES_DIR/messages-protocol-v2.json"
 yarn --cwd "$PACKAGE_ROOT" prettier --write "$PACKAGE_ROOT/src/types/messages.ts"
+
+node "$PARENT_PATH/protobuf-static.js"

package/scripts/protobuf-static-csp.js

@@ -0,0 +1,103 @@
+// Run after lerna run build, with --disallow-code-generation-from-strings.
+const assert = require('assert');
+const path = require('path');
+const vm = require('vm');
+const { readFileSync } = require('fs');
+const { build } = require('tsup');
+const protobuf = require('protobufjs/light');
+const { default: transport } = require('../dist');
+
+const v1 = require('../../core/src/data/messages/messages.json');
+const legacy = require('../../core/src/data/messages/messages_legacy_v1.json');
+const v2 = require('../messages-protocol-v2.json');
+
+const schemas = [v1, legacy, v2];
+function collectTypes(namespace) {
+  return [
+    ...(namespace instanceof protobuf.Type ? [namespace] : []),
+    ...(namespace.nestedArray || []).flatMap(collectTypes),
+  ];
+}
+let blocked = 0;
+const dynamic = () => {
+  blocked += 1;
+  throw new Error('Unexpected dynamic protobuf setup');
+};
+protobuf.Type.prototype.setup = dynamic;
+protobuf.Type.generateConstructor = dynamic;
+let count = 0;
+for (const schema of schemas) {
+  const root = transport.parseConfigure(schema);
+  for (const type of collectTypes(root)) {
+    // Missing required fields can throw; no constructor or codec may fall back to codegen.
+    for (const operation of [
+      () => type.fromObject({}),
+      () => type.encode(type.create()).finish(),
+      () => type.decode(new Uint8Array()),
+      () => type.verify({}),
+      () => type.toObject(type.create()),
+    ]) {
+      try {
+        operation();
+      } catch (error) {
+        if (error instanceof EvalError) throw error;
+      }
+      count += 1;
+    }
+  }
+}
+assert.strictEqual(blocked, 0);
+console.log(`CSP static protobuf: ${count} operations, no dynamic setup`);
+
+async function checkBrowser() {
+  const outDir = path.resolve(__dirname, '../../../node_modules/.cache/protobuf-static/browser');
+  await build({
+    entry: { browser: path.resolve(__dirname, '../dist/index.js') },
+    outDir,
+    format: ['iife'],
+    globalName: 'transport',
+    platform: 'browser',
+    noExternal: [/.*/],
+    splitting: false,
+    silent: true,
+    config: false,
+  });
+  const code = readFileSync(path.join(outDir, 'browser.global.js'), 'utf8');
+  const context = vm.createContext(
+    { schemas },
+    { codeGeneration: { strings: false, wasm: false } }
+  );
+  vm.runInContext(code, context);
+  const operations = vm.runInContext(
+    `
+      let count = 0;
+      function visit(namespace) {
+        if (namespace.fields) {
+          if (!Object.hasOwn(namespace, 'encode')) throw Error('Missing static codec');
+          for (const operation of [
+            () => namespace.fromObject({}),
+            () => namespace.encode(namespace.create()).finish(),
+            () => namespace.decode(new Uint8Array()),
+            () => namespace.verify({}),
+            () => namespace.toObject(namespace.create())
+          ]) {
+            try { operation(); } catch (error) {
+              if (error instanceof EvalError) throw error;
+            }
+            count += 1;
+          }
+        }
+        for (const child of namespace.nestedArray || []) visit(child);
+      }
+      for (const schema of schemas) visit(transport.default.parseConfigure(schema));
+      count;
+    `,
+    context
+  );
+  assert.strictEqual(operations, count);
+  console.log(`Browser CSP: ${operations} operations, ${code.length} bytes before minification`);
+}
+checkBrowser().catch(error => {
+  console.error(error.message);
+  process.exitCode = 1;
+});

package/scripts/protobuf-static.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+const protobuf = require('protobufjs/light');
+const Long = require('long');
+
+protobuf.util.Long = Long;
+protobuf.configure();
+
+const packageRoot = path.resolve(__dirname, '..');
+const outputDirectory = path.join(packageRoot, 'src/serialization/protobuf/generated');
+const schemaPaths = [
+  '../core/src/data/messages/messages.json',
+  '../core/src/data/messages/messages_legacy_v1.json',
+  'messages-protocol-v2.json',
+  'src/serialization/protobuf/legacy-protocol-info.json',
+];
+const methods = ['encode', 'decode', 'verify', 'fromObject', 'toObject'];
+const factories = new Map();
+const registrations = [];
+
+function collectTypes(namespace) {
+  return [
+    ...(namespace instanceof protobuf.Type ? [namespace] : []),
+    ...(namespace.nestedArray || []).flatMap(collectTypes),
+  ];
+}
+
+for (const schemaPath of schemaPaths) {
+  const schema = JSON.parse(fs.readFileSync(path.join(packageRoot, schemaPath), 'utf8'));
+  const root = protobuf.Root.fromJSON(schema);
+  // Capture before resolution, which can normalize field options in place.
+  const signature = JSON.stringify(root.toJSON());
+  const registrationsForSchema = [];
+  for (const type of collectTypes(root)) {
+    type.setup();
+    const source = [
+      `type.ctor = ${type.ctor.toString()};`,
+      'const types = type.fieldsArray.map(field => field.resolvedType);',
+      ...methods.map(method => `type.${method} = ${type[method].toString()};`),
+    ].join('\n');
+    if (!factories.has(source)) factories.set(source, factories.size);
+    registrationsForSchema.push([type.fullName, factories.get(source)]);
+  }
+  registrations.push({ signature, types: registrationsForSchema });
+}
+
+// Keep the exact generated algorithms, including legacy conversion quirks.
+const source = [
+  '// @generated by scripts/protobuf-static.js. DO NOT EDIT.',
+  `const { Reader, Writer, util } = require('protobufjs/minimal');`,
+  'const factories = [',
+  ...Array.from(factories.keys(), body => `function(type) {\n${body}\n},`),
+  '];',
+  `const schemas = ${JSON.stringify(registrations)};`,
+  'exports.installStaticCodecs = function(root) {',
+  '  const signature = JSON.stringify(root.toJSON());',
+  '  const schema = schemas.find(candidate => candidate.signature === signature);',
+  '  if (!schema) return false;',
+  '  for (const [name, factory] of schema.types) factories[factory](root.lookupType(name));',
+  '  return true;',
+  '};',
+  '',
+].join('\n');
+const declaration = [
+  '// @generated by scripts/protobuf-static.js. DO NOT EDIT.',
+  "import type { Root } from 'protobufjs/light';",
+  'export declare function installStaticCodecs(root: Root): boolean;',
+  '',
+].join('\n');
+
+for (const [name, content] of [
+  ['codecs.js', source],
+  ['codecs.d.ts', declaration],
+]) {
+  const destination = path.join(outputDirectory, name);
+  if (process.argv.includes('--check')) {
+    if (!fs.existsSync(destination) || fs.readFileSync(destination, 'utf8') !== content) {
+      throw new Error(`Static protobuf is stale: run yarn update-protobuf:static (${name})`);
+    }
+  } else {
+    fs.mkdirSync(outputDirectory, { recursive: true });
+    fs.writeFileSync(destination, content);
+  }
+}
+console.log(`Static protobuf: ${registrations.length} schemas, ${factories.size} shared codecs`);

package/src/protocols/index.ts

@@ -1,10 +1,14 @@
 import ByteBuffer from 'bytebuffer';
-import { Reader, Type } from 'protobufjs/light';
+import { Reader } from 'protobufjs/minimal';
 
 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 {
@@ -14,6 +18,8 @@ import {
   isAckFrame,
 } from './v2';
 
+import legacyProtocolInfo from '../serialization/protobuf/legacy-protocol-info.json';
+
 import type { Root } from 'protobufjs/light';
 
 export const PROTOCOL_V2_SYS_MESSAGE_THRESHOLD = 60000;
@@ -30,27 +36,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(legacyProtocolInfo).lookupType('LegacyProtocolInfo');
 
 const decodeLegacyProtocolV2ProtocolInfo = (pbPayload: Uint8Array) => {
   const byteBuffer = ByteBuffer.wrap(Buffer.from(pbPayload) as unknown as ArrayBuffer);

package/src/serialization/protobuf/generated/codecs.d.ts

@@ -0,0 +1,3 @@
+// @generated by scripts/protobuf-static.js. DO NOT EDIT.
+import type { Root } from 'protobufjs/light';
+export declare function installStaticCodecs(root: Root): boolean;