@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.2

package/libESM/device/Device.mjs

@@ -1,729 +0,0 @@
-import { DEVICE, ERRORS, FIRMWARE, UI_REQUEST } from "@trezor/connect-common";
-import { initLog } from "@trezor/connect-common/libESM/utils/debug.mjs";
-import { DeviceModelInternal, getFirmwareOrBootloaderVersionArray, getFirmwareVersionArray, models } from "@trezor/device-utils";
-import { thp as protocolThp, v1 as protocolV1, v2 as protocolV2 } from "@trezor/protocol";
-import { TRANSPORT, TRANSPORT_ERROR } from "@trezor/transport";
-import { TypedEmitter, createDeferred, isArrayMember, versionUtils } from "@trezor/utils";
-import { DeviceCommands } from "./DeviceCommands.mjs";
-import { DeviceCurrentSession } from "./DeviceCurrentSession.mjs";
-import { checkFirmwareRevision } from "./checkFirmwareRevision.mjs";
-import { abortThpWorkflow, getThpChannel } from "./thp/index.mjs";
-import { getAllNetworks } from "../data/coinInfo.mjs";
-import { getFirmwareReleaseConfigInfo, getFirmwareStatus, getReleaseByVersion } from "../data/firmwareInfo.mjs";
-import { getReleaseAsset } from "../utils/assetUtils.mjs";
-import { ensureInternalModelFeature, getUnavailableCapabilities, parseCapabilities, parseRevision } from "../utils/deviceFeaturesUtils.mjs";
-import { getFirmwareMode, getFirmwareType } from "../utils/firmwareUtils.mjs";
-import { changeLanguage } from "./workflow/changeLanguage.mjs";
-import { checkFirmwareHashWithRetries } from "./workflow/checkFirmwareHashWithRetries.mjs";
-import { handshakeCancel } from "./workflow/handshake.mjs";
-const _log = initLog('Device');
-export class Device extends TypedEmitter {
-  transport;
-  thp;
-  descriptor;
-  sessionAcquired;
-  _protocol;
-  get protocol() {
-    return this._protocol;
-  }
-  getThpState() {
-    return this.thp;
-  }
-  unreadableError;
-  _firmwareStatus;
-  get firmwareStatus() {
-    return this._firmwareStatus;
-  }
-  _currentRelease;
-  get currentRelease() {
-    return this._currentRelease;
-  }
-  _firmwareReleaseConfigInfo;
-  get firmwareReleaseConfigInfo() {
-    return this._firmwareReleaseConfigInfo;
-  }
-  _features;
-  get features() {
-    return this._features;
-  }
-  wasUsedElsewhere = false;
-  acquirePromise;
-  releasePromise;
-  runAbort;
-  runPromise;
-  keepTransportSession = false;
-  currentSession;
-  instance = 0;
-  state = [];
-  busy;
-  _unavailableCapabilities = {};
-  get unavailableCapabilities() {
-    return this._unavailableCapabilities;
-  }
-  _firmwareType;
-  get firmwareType() {
-    return this._firmwareType;
-  }
-  get possibleHIDdevice() {
-    return this.descriptor.type === 0 || this.descriptor.type === 2;
-  }
-  get possibleT1() {
-    return (this.descriptor.type ?? 0) <= 2;
-  }
-  name = 'Trezor';
-  color;
-  availableTranslations = {};
-  authenticityChecks = {
-    firmwareRevision: null,
-    firmwareHash: null
-  };
-  uniquePath;
-  lifecycle = new TypedEmitter();
-  sessionDfd;
-  constructor({
-    id,
-    transport,
-    descriptor
-  }) {
-    super();
-    this._protocol = protocolV1;
-    this.uniquePath = id;
-    this.transport = transport;
-    this.descriptor = {
-      id: descriptor.id,
-      apiType: descriptor.apiType,
-      type: descriptor.type,
-      path: descriptor.path,
-      model: descriptor.model
-    };
-    this.sessionAcquired = null;
-    transport.on(TRANSPORT.STOPPED, this.onTransportStopped);
-    transport.deviceEvents.on(this.descriptor.path, this.onTransportDeviceEvent);
-  }
-  get transportPath() {
-    return this.descriptor.path;
-  }
-  onTransportStopped = () => this.disconnect();
-  onTransportDeviceEvent = event => {
-    switch (event.type) {
-      case TRANSPORT.DEVICE_SESSION_CHANGED:
-        return this.updateDescriptor(event.descriptor);
-      case TRANSPORT.DEVICE_REQUEST_RELEASE:
-        return this.usedElsewhere();
-      case TRANSPORT.DEVICE_DISCONNECTED:
-        {
-          return this.disconnect();
-        }
-    }
-  };
-  getSessionChangePromise() {
-    if (!this.sessionDfd) {
-      this.sessionDfd = createDeferred();
-      this.sessionDfd.promise.catch(() => {}).finally(() => {
-        this.sessionDfd = undefined;
-      });
-    }
-    return this.sessionDfd.promise;
-  }
-  async waitAndCompareSession(response, sessionPromise) {
-    if (response.success) {
-      try {
-        if ((await sessionPromise) !== response.payload) {
-          return {
-            success: false,
-            error: {
-              code: TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS
-            }
-          };
-        }
-      } catch {
-        return {
-          success: false,
-          error: {
-            code: TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION
-          }
-        };
-      }
-    }
-    return response;
-  }
-  acquire() {
-    const sessionPromise = this.getSessionChangePromise();
-    const previous = this.transport.getDescriptor(this.descriptor.path)?.session ?? null;
-    this.acquirePromise = this.transport.acquire({
-      input: {
-        path: this.descriptor.path,
-        previous
-      }
-    }).then(result => this.waitAndCompareSession(result, sessionPromise)).then(result => {
-      if (result.success) {
-        this.wasUsedElsewhere = false;
-        this.sessionAcquired = result.payload;
-        this.currentSession = new DeviceCurrentSession(this, this.transport, this.sessionAcquired);
-        return result;
-      } else {
-        throw new Error(result.error.code);
-      }
-    }).finally(() => {
-      this.acquirePromise = undefined;
-    });
-    return this.acquirePromise;
-  }
-  reset() {
-    _log.info(`Resetting Features and ThpState`);
-    this._features = undefined;
-    this._protocol = protocolV1;
-    this.thp?.resetState();
-    this.thp = undefined;
-  }
-  setBusy(value) {
-    this.busy = value;
-  }
-  release() {
-    if (!this.sessionAcquired || this.keepTransportSession || this.releasePromise) {
-      return;
-    }
-    const sessionPromise = this.getSessionChangePromise();
-    this.releasePromise = this.transport.release({
-      session: this.sessionAcquired,
-      path: this.descriptor.path
-    }).then(result => this.waitAndCompareSession(result, sessionPromise)).then(result => {
-      if (result.success) {
-        this.sessionAcquired = null;
-      }
-      return result;
-    }).finally(() => {
-      this.releasePromise = undefined;
-    });
-    return this.releasePromise;
-  }
-  setupThp() {
-    _log.info('Setup THP device');
-    this._protocol = protocolV2;
-    if (this.transport.name === 'BridgeTransport' && !versionUtils.isNewerOrEqual(this.transport.version, '3.0.0')) {
-      this.unreadableError = 'THP incompatible with bridge ' + this.transport.version;
-    } else {
-      try {
-        this.thp = new protocolThp.ThpState();
-      } catch (error) {
-        this.unreadableError = error.message;
-      }
-    }
-  }
-  async handshake() {
-    if (this.isUsedElsewhere()) {
-      return true;
-    }
-    try {
-      await this.run();
-    } catch (error) {
-      _log.warn(`device.run error.message: ${error.message}, code: ${error.code}`);
-      if (error.code === 'Device_NotFound' || error.code === 'Device_Disconnected' || error.message === TRANSPORT_ERROR.DEVICE_NOT_FOUND || error.message === TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION || error.message === TRANSPORT_ERROR.HTTP_ERROR) {
-        return false;
-      }
-      if (this.possibleHIDdevice && error.message === TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE || error.message === TRANSPORT_ERROR.LIBUSB_ERROR_ACCESS) {
-        this.unreadableError = error.message;
-      }
-    }
-    return true;
-  }
-  async updateDescriptor(descriptor) {
-    this.sessionDfd?.resolve(descriptor.session);
-    await Promise.all([this.acquirePromise, this.releasePromise]);
-    if (descriptor.session && descriptor.session !== this.sessionAcquired) {
-      this.usedElsewhere();
-    }
-    if (!descriptor.session) {
-      this.keepTransportSession = false;
-    }
-    this.lifecycle.emit(DEVICE.CHANGED);
-  }
-  startPiggybackAck() {
-    _log.debug('start PiggybackAck');
-    this.thp?.enablePiggybackAck(true);
-  }
-  async stopPiggybackAck() {
-    if (this.currentSession && this.thp?.isPiggybackAckEnabled) {
-      _log.debug('stop PiggybackAck');
-      await this.currentSession.send('ThpAck', {});
-      this.thp?.enablePiggybackAck(false);
-    }
-  }
-  run(fn, options = {}) {
-    if (this.runPromise) {
-      _log.warn('Previous call is still running');
-      throw ERRORS.TypedError('Device_CallInProgress');
-    }
-    const wasUnacquired = this.isUnacquired();
-    this.runAbort = new AbortController();
-    const {
-      signal
-    } = this.runAbort;
-    this.runPromise = Promise.race([this._runInner(fn, options, signal), new Promise((_, reject) => {
-      signal.addEventListener('abort', () => reject(signal.reason));
-    })]).catch(async err => {
-      this.keepTransportSession = false;
-      await this.acquirePromise;
-      await this.stopPiggybackAck();
-      await this.release();
-      throw err;
-    }).finally(() => {
-      this.runAbort = undefined;
-      this.runPromise = undefined;
-    }).then(() => {
-      if (wasUnacquired && !this.isUnacquired()) {
-        this.lifecycle.emit(DEVICE.CONNECT);
-      }
-    });
-    return this.runPromise;
-  }
-  async interrupt(reason) {
-    await abortThpWorkflow(this);
-    await this.currentSession?.abort(reason);
-    this.runAbort?.abort(reason);
-    await this.currentRun;
-  }
-  get currentRun() {
-    return this.runPromise?.catch(() => {});
-  }
-  usedElsewhere() {
-    this.wasUsedElsewhere = true;
-    if (!this.sessionAcquired) {
-      return;
-    }
-    this.transport.releaseDevice(this.sessionAcquired);
-    this.sessionAcquired = null;
-    _log.debug('interruptionFromOutside');
-    this.runAbort?.abort(ERRORS.TypedError('Device_UsedElsewhere'));
-  }
-  async _runInner(fn, options, abortSignal) {
-    if (this.releasePromise) {
-      await this.releasePromise;
-    }
-    const acquireNeeded = !this.isUsedHere() || this.currentSession?.isDisposed();
-    if (acquireNeeded) {
-      await this.acquire();
-    }
-    if (abortSignal.aborted) throw abortSignal.reason;
-    const {
-      staticSessionId,
-      deriveCardano
-    } = this.getState() || {};
-    if (acquireNeeded || !staticSessionId || !deriveCardano && options.useCardanoDerivation) {
-      try {
-        await handshakeCancel({
-          device: this,
-          logger: _log,
-          signal: abortSignal
-        });
-        if (this.protocol.name === 'v2') {
-          const withInteraction = !!fn;
-          this.busy = await getThpChannel(this, withInteraction);
-          this.updateNameAndColor();
-          if (!this.busy) {
-            await this.getFeatures();
-          }
-        } else if (fn) {
-          await this.initialize(!!options.useCardanoDerivation);
-        } else {
-          await this.getFeatures();
-        }
-      } catch (error) {
-        _log.warn('Device._runInner error: ', error.message);
-        if (error.code === 'Failure_Busy') {
-          this.busy = 'busy';
-        }
-        if (error.code === 'ThpDeviceLocked') {
-          this.busy = 'pin-locked';
-        }
-        if (error.code === 'Device_ThpPairingTagInvalid' || error.code === 'Failure_ActionCancelled') {
-          return Promise.reject(error);
-        }
-        return Promise.reject(ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}${error.code ? `, code: ${error.code}` : ''}`));
-      }
-    }
-    if (!options.skipFirmwareChecks) {
-      await checkFirmwareHashWithRetries({
-        device: this,
-        logger: _log
-      });
-      await this.checkFirmwareRevisionWithRetries();
-    }
-    if (!options.skipLanguageChecks && this.features?.language && !this.features.language_version_matches && this.atLeast('2.7.0')) {
-      _log.info('language version mismatch. silently updating...');
-      try {
-        await changeLanguage({
-          device: this,
-          language: this.features.language
-        });
-      } catch (err) {
-        _log.error('change language failed silently', err);
-      }
-    }
-    if (options.keepSession) {
-      this.keepTransportSession = true;
-    }
-    if (fn) {
-      await fn();
-      if (!options.skipFinalReload) {
-        await this.getFeatures();
-      }
-    }
-    if (!this.keepTransportSession && typeof options.keepSession !== 'boolean' || options.keepSession === false) {
-      this.keepTransportSession = false;
-      await this.stopPiggybackAck();
-      await this.release();
-    }
-  }
-  getCurrentSession() {
-    if (!this.currentSession) {
-      throw ERRORS.TypedError('Runtime', `Device: commands not defined`);
-    }
-    return this.currentSession;
-  }
-  getCommands() {
-    return DeviceCommands(this.getCurrentSession());
-  }
-  setInstance(instance = 0) {
-    if (this.instance !== instance) {
-      if (this.keepTransportSession) {
-        this.sessionAcquired = null;
-        this.keepTransportSession = false;
-      }
-    }
-    this.instance = instance;
-  }
-  getInstance() {
-    return this.instance;
-  }
-  getState() {
-    return this.state[this.instance];
-  }
-  setState(state) {
-    if (!state) {
-      delete this.state[this.instance];
-    } else {
-      const prevState = this.state[this.instance];
-      const newState = {
-        ...prevState,
-        ...state
-      };
-      this.state[this.instance] = newState;
-    }
-  }
-  async initialize(useCardanoDerivation) {
-    let payload;
-    if (this.features) {
-      const {
-        sessionId,
-        deriveCardano
-      } = this.getState() || {};
-      payload = {
-        derive_cardano: deriveCardano || useCardanoDerivation
-      };
-      if (sessionId) {
-        payload.session_id = sessionId;
-      }
-    }
-    const {
-      message
-    } = await this.getCurrentSession().typedCall('Initialize', 'Features', payload);
-    this._updateFeatures(message);
-    this._updateCurrentRelease(message);
-    this.setState({
-      deriveCardano: payload?.derive_cardano
-    });
-  }
-  async getFeatures() {
-    const {
-      message
-    } = await this.getCurrentSession().typedCall('GetFeatures', 'Features', {});
-    this._updateFeatures(message);
-    this._updateCurrentRelease(message);
-  }
-  getAuthenticityChecks() {
-    return this.authenticityChecks;
-  }
-  setAuthenticityChecks(firmwareHash) {
-    this.authenticityChecks.firmwareHash = firmwareHash;
-  }
-  async checkFirmwareRevisionWithRetries() {
-    const lastResult = this.authenticityChecks.firmwareRevision;
-    const notDoneYet = lastResult === null;
-    const wasError = lastResult !== null && !lastResult.success;
-    const wasErrorRetriable = wasError && isArrayMember(lastResult.error, FIRMWARE.REVISION_CHECK_RETRIABLE_ERRORS);
-    if (notDoneYet || wasErrorRetriable) {
-      await this.checkFirmwareRevision();
-    }
-  }
-  async checkFirmwareRevision() {
-    const firmwareVersion = this.getVersion();
-    if (!firmwareVersion || !this.features || !this.firmwareType) {
-      return;
-    }
-    if (this.features && this.features.bootloader_mode === true) {
-      return;
-    }
-    const release = getReleaseAsset(this.features.internal_model, firmwareVersion, this.firmwareType);
-    const result = await checkFirmwareRevision({
-      internalModel: this.features.internal_model,
-      deviceRevision: this.features.revision,
-      firmwareVersion,
-      expectedRevision: release?.firmware_revision,
-      firmwareType: this.firmwareType
-    });
-    this.authenticityChecks = {
-      ...this.authenticityChecks,
-      firmwareRevision: result
-    };
-  }
-  async _updateCurrentRelease(feat) {
-    const firmwareVersion = getFirmwareVersionArray({
-      features: feat
-    });
-    const newFirmwareType = getFirmwareType(feat);
-    if (!firmwareVersion) {
-      return;
-    }
-    if (this._currentRelease && newFirmwareType === this.firmwareType && versionUtils.isEqual(this._currentRelease.version, firmwareVersion)) {
-      return;
-    }
-    const release = await getReleaseByVersion(feat, firmwareVersion, newFirmwareType);
-    this._currentRelease = release;
-    this.availableTranslations = this._currentRelease?.translations ?? {};
-  }
-  _updateFeatures(feat) {
-    const capabilities = parseCapabilities(feat);
-    feat.capabilities = capabilities;
-    if (this.features && this.features.session_id && !feat.session_id) {
-      feat.session_id = this.features.session_id;
-    }
-    feat.unlocked = feat.unlocked ?? true;
-    const revision = parseRevision(feat);
-    feat.revision = revision;
-    if (!feat.model && feat.major_version === 1) {
-      feat.model = '1';
-    }
-    if (!feat.internal_model || !DeviceModelInternal[feat.internal_model]) {
-      feat.internal_model = ensureInternalModelFeature(feat.model);
-    }
-    const version = this.getVersion();
-    const newVersion = getFirmwareOrBootloaderVersionArray(feat);
-    this.deviceVersionCheck(feat);
-    if (!version || !versionUtils.isEqual(version, newVersion)) {
-      this._unavailableCapabilities = getUnavailableCapabilities(feat, getAllNetworks());
-      this._firmwareStatus = getFirmwareStatus(feat, getFirmwareType(feat));
-      this._firmwareReleaseConfigInfo = getFirmwareReleaseConfigInfo(feat, getFirmwareType(feat));
-      this._currentRelease = getReleaseAsset(feat.internal_model, newVersion, getFirmwareType(feat));
-      this.availableTranslations = this._currentRelease?.translations ?? {};
-    }
-    this._features = feat;
-    this._firmwareType = getFirmwareType(feat);
-    this.updateNameAndColor();
-    this.busy = undefined;
-  }
-  deviceVersionCheck(feat) {
-    const version = this.getVersion();
-    const oldId = this.features?.device_id;
-    if (!oldId || !!feat.bootloader_mode || !version) return;
-    const newVersion = getFirmwareOrBootloaderVersionArray(feat);
-    if (feat.device_id !== oldId) {
-      if (feat.initialized === this.features?.initialized) {
-        const oldDevice = this.toMessageObject();
-        this.transport.enumerate().then(res => {
-          const descriptors = res.success ? res.payload : undefined;
-          console.error('getFeatures device id mismatch', oldDevice, feat, descriptors);
-        });
-      }
-      return;
-    }
-    if (!versionUtils.isEqual(version, newVersion)) {
-      this.emit(DEVICE.FIRMWARE_VERSION_CHANGED, {
-        oldVersion: version,
-        newVersion,
-        device: this.toMessageObject()
-      });
-    }
-  }
-  updateNameAndColor() {
-    const {
-      internal_model,
-      model_variant
-    } = this.thp?.properties ?? {};
-    const internalModel = this._features?.internal_model ?? internal_model;
-    const unitColor = this._features?.unit_color ?? (model_variant ?? 0) % 256;
-    const deviceInfo = models[internalModel] ?? {
-      name: `Unknown ${internalModel}`,
-      colors: {}
-    };
-    this.name = deviceInfo.name;
-    if (unitColor) {
-      const deviceUnitColor = unitColor.toString();
-      if (deviceUnitColor in deviceInfo.colors) {
-        this.color = deviceInfo.colors[deviceUnitColor];
-      }
-    }
-  }
-  updateFeature(key, value) {
-    if (this._features) {
-      this._features = {
-        ...this._features,
-        [key]: value
-      };
-      this.lifecycle.emit(DEVICE.CHANGED);
-    }
-  }
-  prompt(type, args) {
-    return new Promise(callback => {
-      if (!this.listenerCount(type)) {
-        const payload = {
-          success: false,
-          error: new Error(`${type} callback not configured`)
-        };
-        callback(payload);
-      } else {
-        this.emit(type, {
-          callback,
-          ...args
-        });
-      }
-    });
-  }
-  isUnacquired() {
-    return this.features === undefined;
-  }
-  disconnect() {
-    _log.debug('Disconnect cleanup');
-    this.transport.off(TRANSPORT.STOPPED, this.onTransportStopped);
-    this.transport.deviceEvents.off(this.descriptor.path, this.onTransportDeviceEvent);
-    this.removeAllListeners();
-    this.sessionDfd?.reject(new Error());
-    if (this.sessionAcquired) {
-      this.transport.releaseSync(this.sessionAcquired);
-      this.sessionAcquired = null;
-    }
-    this.lifecycle.emit(DEVICE.DISCONNECT);
-    return this.interrupt(ERRORS.TypedError('Device_Disconnected'));
-  }
-  isBootloader() {
-    return this.features && !!this.features.bootloader_mode;
-  }
-  isInitialized() {
-    return this.features && !!this.features.initialized;
-  }
-  isSeedless() {
-    return this.features && !!this.features.no_backup;
-  }
-  getVersion() {
-    return this.features ? getFirmwareOrBootloaderVersionArray(this.features) : undefined;
-  }
-  atLeast(versions) {
-    const version = this.getVersion();
-    if (!this.features || !version) return false;
-    const modelVersion = typeof versions === 'string' ? versions : versions[this.features.major_version - 1];
-    return versionUtils.isNewerOrEqual(version, modelVersion);
-  }
-  isUsed() {
-    return !!this.transport.getDescriptor(this.descriptor.path)?.session;
-  }
-  isUsedHere() {
-    return !!this.sessionAcquired;
-  }
-  getBusy() {
-    return this.busy;
-  }
-  isUsedElsewhere() {
-    return this.isUsed() && !this.isUsedHere();
-  }
-  getUniquePath() {
-    return this.uniquePath;
-  }
-  hasUnexpectedMode(allow) {
-    if (this.features) {
-      if (this.isBootloader() && !allow.includes(UI_REQUEST.BOOTLOADER)) {
-        return UI_REQUEST.BOOTLOADER;
-      }
-      if (!this.isInitialized() && !allow.includes(UI_REQUEST.INITIALIZE)) {
-        return UI_REQUEST.INITIALIZE;
-      }
-      if (this.isSeedless() && !allow.includes(UI_REQUEST.SEEDLESS)) {
-        return UI_REQUEST.SEEDLESS;
-      }
-    }
-    return null;
-  }
-  getStatus() {
-    if (this.isUsedElsewhere()) return 'occupied';
-    if (this.wasUsedElsewhere) return 'used';
-    if (this.busy) return this.busy;
-    return 'available';
-  }
-  getDeviceThp() {
-    const state = this.thp?.serialize();
-    return state ? {
-      properties: state.properties,
-      credentials: state.credentials,
-      channel: state.channel
-    } : undefined;
-  }
-  toMessageObject() {
-    const {
-      name,
-      uniquePath: path,
-      descriptor
-    } = this;
-    const {
-      apiType,
-      id
-    } = descriptor;
-    const base = {
-      path,
-      name,
-      descriptor: {
-        apiType,
-        id
-      }
-    };
-    if (this.unreadableError) {
-      return {
-        ...base,
-        type: 'unreadable',
-        error: this.unreadableError,
-        label: 'Unreadable device',
-        hid: this.possibleHIDdevice
-      };
-    }
-    if (this.isUnacquired()) {
-      const sessionOwner = this.transport.getDescriptor(this.descriptor.path)?.sessionOwner;
-      return {
-        ...base,
-        type: 'unacquired',
-        label: 'Unacquired device',
-        name: this.name,
-        transportSessionOwner: this.sessionAcquired ? undefined : sessionOwner,
-        thp: this.getDeviceThp(),
-        status: this.busy ? this.busy : undefined
-      };
-    }
-    const defaultLabel = 'My Trezor';
-    const label = this.features.label === '' || !this.features.label ? defaultLabel : this.features.label;
-    return {
-      ...base,
-      type: 'acquired',
-      id: this.features.device_id,
-      label,
-      state: this.getState(),
-      status: this.getStatus(),
-      mode: getFirmwareMode(this.features),
-      color: this.color,
-      firmware: this.firmwareStatus,
-      firmwareReleaseConfigInfo: this.firmwareReleaseConfigInfo,
-      firmwareType: this.firmwareType,
-      features: this.features,
-      unavailableCapabilities: this.unavailableCapabilities,
-      availableTranslations: this.availableTranslations,
-      authenticityChecks: this.authenticityChecks,
-      thp: this.getDeviceThp()
-    };
-  }
-}