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

package/__tests__/static-protobuf.test.js

@@ -1,436 +0,0 @@
-import { isDeepStrictEqual } from 'util';
-import { mkdirSync, writeFileSync } from 'fs';
-import path from 'path';
-import ByteBuffer from 'bytebuffer';
-import * as protobuf from 'protobufjs/light';
-import Long from 'long';
-
-import v1 from '@onekeyfe/hd-core/src/data/messages/messages.json';
-import legacy from '@onekeyfe/hd-core/src/data/messages/messages_legacy_v1.json';
-import v2 from '../messages-protocol-v2.json';
-import { parseConfigure, createMessageFromName } from '../src/serialization/protobuf/messages';
-import { encode } from '../src/serialization/protobuf/encode';
-import { decode } from '../src/serialization/protobuf/decode';
-import { installStaticCodecs } from '../src/serialization/protobuf/generated/codecs';
-import { ProtocolV1, ProtocolV2 } from '../src/protocols';
-
-import { patchFeatures } from '@onekeyfe/hd-core/src/utils/patch';
-import { fixFeaturesFirmwareVersion } from '@onekeyfe/hd-core/src/utils/deviceFeaturesUtils';
-import { buildProtocolV1FeaturesPayload } from '@onekeyfe/hd-core/src/deviceProfile/buildDeviceFeatures';
-import {
-  mapFeaturesToState,
-  mapProtocolV2DeviceInfoToState,
-  mapProtocolV2DeviceStatusToState,
-} from '@onekeyfe/hd-core/src/device/DeviceStateMapper';
-import { DeviceStateStore } from '@onekeyfe/hd-core/src/device/DeviceStateStore';
-import { projectFeatures } from '@onekeyfe/hd-core/src/device/DeviceStateProjector';
-
-jest.mock('@onekeyfe/hd-core/src/data/config', () => ({
-  getSDKVersion: () => '1.0.0-test',
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
-}));
-
-const constants = Object.values(Long)
-  .filter(value => value instanceof Long)
-  .map(value => ({ value, low: value.low, high: value.high, unsigned: value.unsigned }));
-const resetLong = () => {
-  constants.forEach(({ value, low, high, unsigned }) =>
-    Object.assign(value, { low, high, unsigned })
-  );
-};
-const collectTypes = namespace => [
-  ...(namespace instanceof protobuf.Type ? [namespace] : []),
-  ...(namespace.nestedArray || []).flatMap(collectTypes),
-];
-const capture = fn => {
-  try {
-    return { ok: true, value: fn() };
-  } catch (error) {
-    return { ok: false, name: error.name, message: error.message };
-  }
-};
-
-function seed(type, mode, depth = 0) {
-  const result = {};
-  if (depth > 5) return result;
-  type.fieldsArray.forEach(field => {
-    if (field.partOf && field.partOf.fieldsArray[0] !== field) return;
-    if (mode === 'required' && !field.required) return;
-    if (field.resolvedType instanceof protobuf.Type && !field.required && depth > 2) return;
-    let value;
-    if (field.resolvedType instanceof protobuf.Type)
-      value = seed(field.resolvedType, mode, depth + 1);
-    else if (field.resolvedType instanceof protobuf.Enum) {
-      const values = Object.values(field.resolvedType.values);
-      value = values[mode === 'values' ? Math.min(1, values.length - 1) : 0];
-    } else if (field.type === 'bytes') value = mode === 'values' ? '00ff' : '';
-    else if (field.type === 'string') value = mode === 'values' ? 'test-验证' : '';
-    else if (field.type === 'bool') value = mode === 'values';
-    else if (field.long) value = mode === 'values' ? '9007199254740993' : '0';
-    else value = mode === 'values' ? 1 : 0;
-    result[field.name] = field.repeated ? [value] : value;
-  });
-  return result;
-}
-
-function inputCases(type) {
-  const base = seed(type, 'required');
-  const cases = [
-    ['absent', {}],
-    ['required', base],
-    ['zeros', seed(type, 'zeros')],
-    ['values', seed(type, 'values')],
-  ];
-  type.fieldsArray.forEach(field => {
-    const add = (label, value) =>
-      cases.push([`${field.name}:${label}`, { ...base, [field.name]: value }]);
-    const scalar = value => (field.repeated ? [value] : value);
-    add('undefined', undefined);
-    if (!field.repeated) add('null', null);
-    let values = [];
-    if (field.resolvedType instanceof protobuf.Enum) {
-      values = [
-        ...Object.entries(field.resolvedType.values).flat(),
-        -1,
-        2147483647,
-        '0',
-        'UNKNOWN_ENUM',
-      ];
-    } else if (!field.resolvedType) {
-      if (field.type === 'bytes')
-        values = ['', '00', '0', 'zz', Buffer.alloc(0), new Uint8Array([0, 255])];
-      else if (field.type === 'string') values = [0, 1, false, '', '01'];
-      else if (field.type === 'bool') values = [false, true, 0, 1, 'false', 'true'];
-      else if (field.long)
-        values = [
-          '0',
-          '9007199254740991',
-          '9007199254740993',
-          '18446744073709551615',
-          '-9223372036854775808',
-          9007199254740992,
-        ];
-      else values = [0, -1, 1, '0', '1', '01', 1.5, NaN, Infinity];
-    }
-    values.forEach((value, index) => add(`coercion-${index}`, scalar(value)));
-    if (field.repeated) add('empty-array', []);
-    if (field.repeated && field.type === 'bytes') add('three-empty-bytes', ['', '', '']);
-  });
-  return cases;
-}
-
-// Do not print inputs or wire bytes on failures, even though all data here is synthetic.
-function compare(label, oldCall, newCall, reset = true) {
-  if (reset) resetLong();
-  const expected = capture(oldCall);
-  if (reset) resetLong();
-  const actual = capture(newCall);
-  if (!isDeepStrictEqual(expected, actual)) throw new Error(`Static protobuf differs: ${label}`);
-  return expected;
-}
-
-const toBytes = (type, input) => Buffer.from(encode(type, input).toBuffer());
-const fromBytes = (type, bytes) => decode(type, ByteBuffer.wrap(bytes));
-
-afterEach(() => {
-  resetLong();
-  jest.restoreAllMocks();
-});
-
-test.each([
-  ['v1', v1],
-  ['legacy-v1', legacy],
-  ['v2', v2],
-])(
-  '%s matches legacy bytes, own properties, scalar types, malformed input and framing',
-  (schemaName, schema) => {
-    const reference = protobuf.Root.fromJSON(schema);
-    const types = collectTypes(reference);
-    types.forEach(type => {
-      type.setup();
-      type.create();
-    });
-    // Baseline functions are ready. Every candidate constructor and codec must now be static.
-    jest.spyOn(protobuf.Type.prototype, 'setup').mockImplementation(() => {
-      throw new Error('Dynamic setup');
-    });
-    jest.spyOn(protobuf.Type, 'generateConstructor').mockImplementation(() => {
-      throw new Error('Dynamic constructor');
-    });
-    const candidate = parseConfigure(schema);
-    const stringCandidate = parseConfigure(JSON.stringify(schema));
-    expect(collectTypes(candidate)).toHaveLength(types.length);
-    let inputs = 0;
-    let wires = 0;
-    let frames = 0;
-    const rows = [];
-    types.forEach(type => {
-      const next = candidate.lookupType(type.fullName);
-      rows.push({ message: type.fullName, result: 'equal', inputs: inputCases(type).length });
-      inputCases(type).forEach(([label, input]) => {
-        const encoded = compare(
-          `${schemaName}/${type.name}/${label}/encode`,
-          () => toBytes(type, input),
-          () => toBytes(next, input)
-        );
-        inputs += 1;
-        if (encoded.ok) {
-          compare(
-            `${schemaName}/${type.name}/${label}/decode`,
-            () => fromBytes(type, encoded.value),
-            () => fromBytes(next, encoded.value)
-          );
-          wires += 1;
-        }
-      });
-      const base = capture(() => toBytes(type, seed(type, 'required')));
-      if (!base.ok) return;
-      const checkWire = (label, bytes) => {
-        compare(
-          `${schemaName}/${type.name}/${label}`,
-          () => fromBytes(type, bytes),
-          () => fromBytes(next, bytes)
-        );
-        wires += 1;
-      };
-      checkWire('empty-wire', Buffer.alloc(0));
-      const dense = capture(() => toBytes(type, seed(type, 'values')));
-      if (dense.ok) {
-        [0, 1, Math.floor(dense.value.length / 2), dense.value.length - 1]
-          .filter(length => length >= 0)
-          .forEach(length => checkWire(`truncated-${length}`, dense.value.subarray(0, length)));
-        for (let index = 0; index < Math.min(12, dense.value.length); index += 1) {
-          const bytes = Buffer.from(dense.value);
-          bytes[index] = (bytes[index] + 2 ** (index % 8)) % 256;
-          checkWire(`mutation-${index}`, bytes);
-        }
-      }
-      const tail = protobuf.Writer.create()
-        .uint32(500000 * 8)
-        .finish();
-      checkWire('battery-ff-fallback', Buffer.concat([base.value, tail, Buffer.from([255])]));
-      checkWire(
-        'unknown-field',
-        Buffer.concat([
-          base.value,
-          protobuf.Writer.create()
-            .uint32(500000 * 8 + 2)
-            .bytes([0, 255, 1])
-            .finish(),
-        ])
-      );
-      type.fieldsArray.forEach(field => {
-        if (field.resolvedType instanceof protobuf.Enum) {
-          const known = Object.values(field.resolvedType.values)[0];
-          [-1, 2147483647].forEach(unknown => {
-            const write = value =>
-              protobuf.Writer.create()
-                .uint32(field.id * 8)
-                .int32(value)
-                .finish();
-            checkWire(`${field.name}/unknown`, Buffer.concat([base.value, write(unknown)]));
-            checkWire(
-              `${field.name}/mixed`,
-              Buffer.concat([base.value, write(known), write(unknown), write(known)])
-            );
-            if (field.repeated) {
-              const packed = protobuf.Writer.create()
-                .int32(known)
-                .int32(unknown)
-                .int32(known)
-                .finish();
-              checkWire(
-                `${field.name}/packed-mixed`,
-                Buffer.concat([
-                  base.value,
-                  protobuf.Writer.create()
-                    .uint32(field.id * 8 + 2)
-                    .bytes(packed)
-                    .finish(),
-                ])
-              );
-            }
-          });
-        } else if (field.resolvedType instanceof protobuf.Type && !field.repeated) {
-          const first = capture(() =>
-            toBytes(field.resolvedType, seed(field.resolvedType, 'values'))
-          );
-          const second = capture(() =>
-            toBytes(field.resolvedType, seed(field.resolvedType, 'required'))
-          );
-          if (first.ok && second.ok) {
-            const wrap = bytes =>
-              protobuf.Writer.create()
-                .uint32(field.id * 8 + 2)
-                .bytes(bytes)
-                .finish();
-            checkWire(
-              `${field.name}/duplicate-message`,
-              Buffer.concat([base.value, wrap(first.value), wrap(second.value)])
-            );
-          }
-        }
-      });
-      const name = type.fullName.slice(1);
-      const message = capture(() => createMessageFromName(reference, name));
-      if (message.ok) {
-        const input = seed(type, 'values');
-        compare(
-          `${name}/id`,
-          () => message.value.messageTypeId,
-          () => createMessageFromName(candidate, name).messageTypeId
-        );
-        compare(
-          `${name}/v1-envelope`,
-          () => ProtocolV1.encodeEnvelope(reference, name, input).toBuffer(),
-          () => ProtocolV1.encodeEnvelope(candidate, name, input).toBuffer()
-        );
-        compare(
-          `${name}/v1-chunks`,
-          () => ProtocolV1.encodeMessageChunks(reference, name, input),
-          () => ProtocolV1.encodeMessageChunks(candidate, name, input)
-        );
-        if (schemaName === 'v2') {
-          compare(
-            `${name}/v2-frame`,
-            () =>
-              ProtocolV2.encodeFrame(
-                { protocolV1: reference, protocolV2: reference },
-                name,
-                input,
-                { seq: 23 }
-              ),
-            () =>
-              ProtocolV2.encodeFrame(
-                { protocolV1: candidate, protocolV2: candidate },
-                name,
-                input,
-                { seq: 23 }
-              )
-          );
-        }
-        frames += 1;
-      }
-      compare(
-        `${name}/string-config`,
-        () => toBytes(next, seed(type, 'required')),
-        () => toBytes(stringCandidate.lookupType(type.fullName), seed(type, 'required'))
-      );
-    });
-    const reportDirectory = path.resolve(__dirname, '../../../node_modules/.cache/protobuf-static');
-    mkdirSync(reportDirectory, { recursive: true });
-    writeFileSync(
-      path.join(reportDirectory, `${schemaName}.json`),
-      JSON.stringify({ schemaName, inputs, wires, frames, rows }, null, 2)
-    );
-    console.info(
-      `Static protobuf ${schemaName}: ${types.length} messages, ${inputs} inputs, ${wires} decodes, ${frames} message envelopes; zero differences`
-    );
-  },
-  120000
-);
-
-test('custom schemas retain reflection support instead of selecting a similar built-in message', () => {
-  const schema = { nested: { Features: { fields: { custom: { type: 'string', id: 1 } } } } };
-  const root = parseConfigure(schema);
-  expect(installStaticCodecs(root)).toBe(false);
-  expect(
-    fromBytes(root.lookupType('Features'), toBytes(root.lookupType('Features'), { custom: 'test' }))
-  ).toStrictEqual({ custom: 'test' });
-});
-
-test.each([
-  ['v1', v1],
-  ['legacy-v1', legacy],
-  ['v2', v2],
-])(
-  '%s preserves Features compatibility patches, state and projected own properties',
-  (schemaName, schema) => {
-    jest.spyOn(Date, 'now').mockReturnValue(1700000000000);
-    const reference = protobuf.Root.fromJSON(schema).resolveAll();
-    const candidate = parseConfigure(schema);
-    const names = schemaName === 'v2' ? ['Features', 'DeviceInfo', 'DeviceStatus'] : ['Features'];
-    let comparisons = 0;
-    names.forEach(name => {
-      const type = reference.lookupType(name);
-      const next = candidate.lookupType(name);
-      const pipeline = (decoded, cached, mode) => {
-        let payload = decoded;
-        let mapped;
-        if (name === 'Features') {
-          const patched = patchFeatures({ type: name, message: decoded }).message;
-          payload = buildProtocolV1FeaturesPayload(patched, cached?.previous);
-          payload.unlocked = payload.unlocked ?? true;
-          payload = fixFeaturesFirmwareVersion(payload);
-          mapped = mapFeaturesToState(payload);
-        } else {
-          mapped =
-            name === 'DeviceInfo'
-              ? mapProtocolV2DeviceInfoToState(decoded, mode)
-              : mapProtocolV2DeviceStatusToState(decoded);
-        }
-        const store = new DeviceStateStore(cached?.state);
-        const updated = store.update(mapped, 'initialize');
-        return { payload, mapped, ...updated, projected: projectFeatures(updated.state) };
-      };
-      const dense = toBytes(type, seed(type, 'values'));
-      const initial = pipeline(fromBytes(type, dense), undefined, 'normal');
-      const cache = { state: initial.state, previous: initial.projected };
-      const cases = inputCases(type);
-      const populated = seed(type, 'values');
-      type.fieldsArray.forEach(field => {
-        const omitted = { ...populated };
-        delete omitted[field.name];
-        cases.push([`${field.name}/omitted`, omitted]);
-      });
-      cases.forEach(([label, input]) => {
-        const encoded = capture(() => toBytes(type, input));
-        if (!encoded.ok) return;
-        [undefined, cache].forEach(cached => {
-          ['normal', 'bootloader'].forEach(mode => {
-            compare(
-              `${schemaName}/${name}/${label}/pipeline/${mode}/${!!cached}`,
-              () => pipeline(fromBytes(type, encoded.value), cached, mode),
-              () => pipeline(fromBytes(next, encoded.value), cached, mode)
-            );
-            comparisons += 1;
-          });
-        });
-      });
-    });
-    console.info(
-      `Static protobuf ${schemaName}: ${comparisons} Features pipeline comparisons; zero differences`
-    );
-  }
-);
-
-test('retains sequence-dependent Long conversion behavior', () => {
-  const reference = protobuf.Root.fromJSON(v2).resolveAll();
-  const candidate = parseConfigure(v2);
-  const signed = reference.lookupType('CardanoToken');
-  const unsigned = collectTypes(reference).find(type =>
-    type.fieldsArray.some(field => field.type === 'uint64' && !field.repeated)
-  );
-  const field = unsigned.fieldsArray.find(item => item.type === 'uint64' && !item.repeated);
-  const bytes = toBytes(signed, {
-    ...seed(signed, 'required'),
-    mint_amount: '-9223372036854775808',
-  });
-  const sequence = root => {
-    resetLong();
-    const before = capture(() => fromBytes(root.lookupType(signed.fullName), bytes));
-    const encoded = capture(() =>
-      toBytes(root.lookupType(unsigned.fullName), {
-        ...seed(unsigned, 'required'),
-        [field.name]: '-9223372036854775808',
-      })
-    );
-    const after = capture(() => fromBytes(root.lookupType(signed.fullName), bytes));
-    return { before, encoded, after };
-  };
-  compare(
-    'Long mutation sequence',
-    () => sequence(reference),
-    () => sequence(candidate)
-  );
-});

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;