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

package/scripts/protobuf-static-csp.js

@@ -1,103 +0,0 @@
-// 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

@@ -1,85 +0,0 @@
-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/serialization/protobuf/generated/codecs.d.ts

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