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

package/lib/device/Device.js

@@ -0,0 +1,765 @@
+import { DEVICE, ERRORS, FIRMWARE, UI_REQUEST } from "@trezor/connect-common";
+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-common";
+import { TypedEmitter, cloneObject, createDeferred, deepEqual, isArrayMember, versionUtils } from "@trezor/utils";
+import { DeviceCommands } from "./DeviceCommands.js";
+import { DeviceCurrentSession } from "./DeviceCurrentSession.js";
+import { checkFirmwareRevision } from "./checkFirmwareRevision.js";
+import { abortThpWorkflow, getThpChannel } from "./thp/index.js";
+import { getAllNetworks } from "../data/coinInfo.js";
+import { getFirmwareReleaseConfigInfo, getFirmwareStatus, getReleaseByVersion } from "../data/firmwareInfo.js";
+import * as settingsStore from "../data/settingsStore.js";
+import { getReleaseAsset } from "../utils/assetUtils.js";
+import { ensureInternalModelFeature, getUnavailableCapabilities, parseCapabilities, parseRevision } from "../utils/deviceFeaturesUtils.js";
+import { getFirmwareMode, getFirmwareType, isProductionFirmwareChannel } from "../utils/firmwareUtils.js";
+import { changeLanguage } from "./workflow/changeLanguage.js";
+import { checkFirmwareHashWithRetries } from "./workflow/checkFirmwareHashWithRetries.js";
+import { handshakeCancel } from "./workflow/handshake.js";
+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;
+  createLogger;
+  logger;
+  lifecycle = new TypedEmitter();
+  lastEmittedMessage;
+  sessionDfd;
+  constructor({
+    id,
+    transport,
+    descriptor,
+    createLogger
+  }) {
+    super();
+    this._protocol = protocolV1;
+    this.createLogger = createLogger;
+    this.logger = createLogger('Device');
+    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, this.createLogger('DeviceCommands'));
+        return result;
+      } else {
+        throw new Error(result.error.code);
+      }
+    }).finally(() => {
+      this.acquirePromise = undefined;
+    });
+    return this.acquirePromise;
+  }
+  reset() {
+    this.logger.info(`Resetting Features and ThpState`);
+    this._features = undefined;
+    this._protocol = protocolV1;
+    this.thp?.resetState();
+    this.thp = undefined;
+    this.lastEmittedMessage = 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() {
+    this.logger.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) {
+      this.logger.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.emitDeviceChanged();
+  }
+  emitDeviceChanged() {
+    const message = this.toMessageObject();
+    if (this.lastEmittedMessage && deepEqual(this.lastEmittedMessage, message)) {
+      return;
+    }
+    this.lastEmittedMessage = cloneObject(message);
+    this.lifecycle.emit(DEVICE.CHANGED);
+  }
+  startPiggybackAck() {
+    this.logger.debug('start PiggybackAck');
+    this.thp?.enablePiggybackAck(true);
+  }
+  async stopPiggybackAck() {
+    if (this.currentSession && this.thp?.isPiggybackAckEnabled) {
+      this.logger.debug('stop PiggybackAck');
+      await this.currentSession.send('ThpAck', {});
+      this.thp?.enablePiggybackAck(false);
+    }
+  }
+  run(fn, options = {}) {
+    if (this.runPromise) {
+      this.logger.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;
+    this.logger.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: this.logger,
+          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) {
+        this.logger.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: this.logger
+      });
+      await this.checkFirmwareRevisionWithRetries();
+    }
+    if (!options.skipLanguageChecks && this.features?.language && !this.features.language_version_matches && this.atLeast('2.7.0')) {
+      this.logger.info('language version mismatch. silently updating...');
+      try {
+        await changeLanguage({
+          device: this,
+          language: this.features.language
+        });
+      } catch (err) {
+        this.logger.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);
+    await this._updateCurrentRelease(message);
+    this.setState({
+      deriveCardano: payload?.derive_cardano
+    });
+  }
+  async getFeatures() {
+    const {
+      message
+    } = await this.getCurrentSession().typedCall('GetFeatures', 'Features', {});
+    this._updateFeatures(message);
+    await 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?.bootloader_mode === true) {
+      return;
+    }
+    const release = getReleaseAsset(this.features.internal_model, firmwareVersion, this.firmwareType);
+    const result = await checkFirmwareRevision({
+      internalModel: this.features.internal_model,
+      firmwareVersion,
+      deviceRevision: this.features.revision,
+      expectedRevision: release?.firmware_revision,
+      deviceBootloaderHash: this.features.bootloader_hash,
+      expectedBootloaderHash: release?.bootloader_hash,
+      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) && isProductionFirmwareChannel(settingsStore.get('firmwareChannel'))) {
+      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?.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));
+      if (isProductionFirmwareChannel(settingsStore.get('firmwareChannel'))) {
+        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 stripConfidential = f => ({
+          ...f,
+          device_id: undefined,
+          session_id: undefined,
+          label: undefined
+        });
+        const oldFeatures = this.features;
+        const {
+          uniquePath: path
+        } = this;
+        this.transport.enumerate().then(res => {
+          const descriptors = res.success ? res.payload : undefined;
+          console.error('getFeatures device id mismatch', {
+            path,
+            oldFeatures: oldFeatures && stripConfidential(oldFeatures),
+            newFeatures: stripConfidential(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.emitDeviceChanged();
+    }
+  }
+  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() {
+    this.logger.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;
+    if (typeof versions === 'string') {
+      return versionUtils.isNewerOrEqual(version, versions);
+    }
+    const modelVersionIndex = this.features.major_version - 1;
+    const modelVersion = versions[modelVersionIndex];
+    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()
+    };
+  }
+}