@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/device/Device.js

@@ -1,30 +1,22 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Device = void 0;
-const device_utils_1 = require("@trezor/device-utils");
-const protocol_1 = require("@trezor/protocol");
-const transport_1 = require("@trezor/transport");
-const utils_1 = require("@trezor/utils");
-const DeviceCommands_1 = require("./DeviceCommands");
-const constants_1 = require("../constants");
-const DeviceCurrentSession_1 = require("./DeviceCurrentSession");
-const checkFirmwareRevision_1 = require("./checkFirmwareRevision");
-const thp_1 = require("./thp");
-const checkFirmwareHashWithRetries_1 = require("./workflow/checkFirmwareHashWithRetries");
-const coinInfo_1 = require("../data/coinInfo");
-const firmwareInfo_1 = require("../data/firmwareInfo");
-const events_1 = require("../events");
-const types_1 = require("../types");
-const handshake_1 = require("./workflow/handshake");
-const assetUtils_1 = require("../utils/assetUtils");
-const debug_1 = require("../utils/debug");
-const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
-const firmwareUtils_1 = require("../utils/firmwareUtils");
-const _log = (0, debug_1.initLog)('Device');
-class Device extends utils_1.TypedEmitter {
+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;
@@ -62,7 +54,6 @@ class Device extends utils_1.TypedEmitter {
   currentSession;
   instance = 0;
   state = [];
-  stateStorage = undefined;
   busy;
   _unavailableCapabilities = {};
   get unavailableCapabilities() {
@@ -86,25 +77,32 @@ class Device extends utils_1.TypedEmitter {
     firmwareHash: null
   };
   uniquePath;
-  lifecycle = new utils_1.TypedEmitter();
+  createLogger;
+  logger;
+  lifecycle = new TypedEmitter();
+  lastEmittedMessage;
   sessionDfd;
   constructor({
     id,
     transport,
-    descriptor
+    descriptor,
+    createLogger
   }) {
     super();
-    this._protocol = protocol_1.v1;
+    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
+      path: descriptor.path,
+      model: descriptor.model
     };
     this.sessionAcquired = null;
-    transport.on(transport_1.TRANSPORT.STOPPED, this.onTransportStopped);
+    transport.on(TRANSPORT.STOPPED, this.onTransportStopped);
     transport.deviceEvents.on(this.descriptor.path, this.onTransportDeviceEvent);
   }
   get transportPath() {
@@ -113,11 +111,11 @@ class Device extends utils_1.TypedEmitter {
   onTransportStopped = () => this.disconnect();
   onTransportDeviceEvent = event => {
     switch (event.type) {
-      case transport_1.TRANSPORT.DEVICE_SESSION_CHANGED:
+      case TRANSPORT.DEVICE_SESSION_CHANGED:
         return this.updateDescriptor(event.descriptor);
-      case transport_1.TRANSPORT.DEVICE_REQUEST_RELEASE:
+      case TRANSPORT.DEVICE_REQUEST_RELEASE:
         return this.usedElsewhere();
-      case transport_1.TRANSPORT.DEVICE_DISCONNECTED:
+      case TRANSPORT.DEVICE_DISCONNECTED:
         {
           return this.disconnect();
         }
@@ -125,7 +123,7 @@ class Device extends utils_1.TypedEmitter {
   };
   getSessionChangePromise() {
     if (!this.sessionDfd) {
-      this.sessionDfd = (0, utils_1.createDeferred)();
+      this.sessionDfd = createDeferred();
       this.sessionDfd.promise.catch(() => {}).finally(() => {
         this.sessionDfd = undefined;
       });
@@ -138,13 +136,17 @@ class Device extends utils_1.TypedEmitter {
         if ((await sessionPromise) !== response.payload) {
           return {
             success: false,
-            error: transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS
+            error: {
+              code: TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS
+            }
           };
         }
       } catch {
         return {
           success: false,
-          error: transport_1.TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION
+          error: {
+            code: TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION
+          }
         };
       }
     }
@@ -162,10 +164,10 @@ class Device extends utils_1.TypedEmitter {
       if (result.success) {
         this.wasUsedElsewhere = false;
         this.sessionAcquired = result.payload;
-        this.currentSession = new DeviceCurrentSession_1.DeviceCurrentSession(this, this.transport, this.sessionAcquired);
+        this.currentSession = new DeviceCurrentSession(this, this.transport, this.sessionAcquired, this.createLogger('DeviceCommands'));
         return result;
       } else {
-        throw new Error(result.error);
+        throw new Error(result.error.code);
       }
     }).finally(() => {
       this.acquirePromise = undefined;
@@ -173,11 +175,12 @@ class Device extends utils_1.TypedEmitter {
     return this.acquirePromise;
   }
   reset() {
-    _log.info(`Resetting Features and ThpState`);
+    this.logger.info(`Resetting Features and ThpState`);
     this._features = undefined;
-    this._protocol = protocol_1.v1;
+    this._protocol = protocolV1;
     this.thp?.resetState();
     this.thp = undefined;
+    this.lastEmittedMessage = undefined;
   }
   setBusy(value) {
     this.busy = value;
@@ -200,15 +203,14 @@ class Device extends utils_1.TypedEmitter {
     });
     return this.releasePromise;
   }
-  async setupThp() {
-    _log.info('Setup THP device');
-    this._protocol = protocol_1.v2;
-    if (this.transport.name === 'BridgeTransport' && !utils_1.versionUtils.isNewerOrEqual(this.transport.version, '3.0.0')) {
+  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 {
-        await this.transport.loadMessages('thp', protocol_1.thp.getProtobufDefinitions);
-        this.thp = new protocol_1.thp.ThpState();
+        this.thp = new protocolThp.ThpState();
       } catch (error) {
         this.unreadableError = error.message;
       }
@@ -221,11 +223,11 @@ class Device extends utils_1.TypedEmitter {
     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_1.TRANSPORT_ERROR.DEVICE_NOT_FOUND || error.message === transport_1.TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION || error.message === transport_1.TRANSPORT_ERROR.HTTP_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_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE || error.message === transport_1.TRANSPORT_ERROR.LIBUSB_ERROR_ACCESS) {
+      if (this.possibleHIDdevice && error.message === TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE || error.message === TRANSPORT_ERROR.LIBUSB_ERROR_ACCESS) {
         this.unreadableError = error.message;
       }
     }
@@ -240,12 +242,31 @@ class Device extends utils_1.TypedEmitter {
     if (!descriptor.session) {
       this.keepTransportSession = false;
     }
-    this.lifecycle.emit(events_1.DEVICE.CHANGED);
+    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) {
-      _log.warn('Previous call is still running');
-      throw constants_1.ERRORS.TypedError('Device_CallInProgress');
+      this.logger.warn('Previous call is still running');
+      throw ERRORS.TypedError('Device_CallInProgress');
     }
     const wasUnacquired = this.isUnacquired();
     this.runAbort = new AbortController();
@@ -257,6 +278,7 @@ class Device extends utils_1.TypedEmitter {
     })]).catch(async err => {
       this.keepTransportSession = false;
       await this.acquirePromise;
+      await this.stopPiggybackAck();
       await this.release();
       throw err;
     }).finally(() => {
@@ -264,13 +286,13 @@ class Device extends utils_1.TypedEmitter {
       this.runPromise = undefined;
     }).then(() => {
       if (wasUnacquired && !this.isUnacquired()) {
-        this.lifecycle.emit(events_1.DEVICE.CONNECT);
+        this.lifecycle.emit(DEVICE.CONNECT);
       }
     });
     return this.runPromise;
   }
   async interrupt(reason) {
-    await (0, thp_1.abortThpWorkflow)(this);
+    await abortThpWorkflow(this);
     await this.currentSession?.abort(reason);
     this.runAbort?.abort(reason);
     await this.currentRun;
@@ -285,8 +307,8 @@ class Device extends utils_1.TypedEmitter {
     }
     this.transport.releaseDevice(this.sessionAcquired);
     this.sessionAcquired = null;
-    _log.debug('interruptionFromOutside');
-    this.runAbort?.abort(constants_1.ERRORS.TypedError('Device_UsedElsewhere'));
+    this.logger.debug('interruptionFromOutside');
+    this.runAbort?.abort(ERRORS.TypedError('Device_UsedElsewhere'));
   }
   async _runInner(fn, options, abortSignal) {
     if (this.releasePromise) {
@@ -303,14 +325,15 @@ class Device extends utils_1.TypedEmitter {
     } = this.getState() || {};
     if (acquireNeeded || !staticSessionId || !deriveCardano && options.useCardanoDerivation) {
       try {
-        await (0, handshake_1.handshakeCancel)({
+        await handshakeCancel({
           device: this,
-          logger: _log,
+          logger: this.logger,
           signal: abortSignal
         });
         if (this.protocol.name === 'v2') {
           const withInteraction = !!fn;
-          this.busy = await (0, thp_1.getThpChannel)(this, withInteraction);
+          this.busy = await getThpChannel(this, withInteraction);
+          this.updateNameAndColor();
           if (!this.busy) {
             await this.getFeatures();
           }
@@ -320,34 +343,35 @@ class Device extends utils_1.TypedEmitter {
           await this.getFeatures();
         }
       } catch (error) {
-        _log.warn('Device._runInner error: ', error.message);
+        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') {
+        if (error.code === 'Device_ThpPairingTagInvalid' || error.code === 'Failure_ActionCancelled') {
           return Promise.reject(error);
         }
-        return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}${error.code ? `, code: ${error.code}` : ''}`));
+        return Promise.reject(ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}${error.code ? `, code: ${error.code}` : ''}`));
       }
     }
     if (!options.skipFirmwareChecks) {
-      await (0, checkFirmwareHashWithRetries_1.checkFirmwareHashWithRetries)({
+      await checkFirmwareHashWithRetries({
         device: this,
-        logger: _log
+        logger: this.logger
       });
       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...');
+      this.logger.info('language version mismatch. silently updating...');
       try {
-        await this.changeLanguage({
+        await changeLanguage({
+          device: this,
           language: this.features.language
         });
       } catch (err) {
-        _log.error('change language failed silently', err);
+        this.logger.error('change language failed silently', err);
       }
     }
     if (options.keepSession) {
@@ -361,17 +385,18 @@ class Device extends utils_1.TypedEmitter {
     }
     if (!this.keepTransportSession && typeof options.keepSession !== 'boolean' || options.keepSession === false) {
       this.keepTransportSession = false;
+      await this.stopPiggybackAck();
       await this.release();
     }
   }
   getCurrentSession() {
     if (!this.currentSession) {
-      throw constants_1.ERRORS.TypedError('Runtime', `Device: commands not defined`);
+      throw ERRORS.TypedError('Runtime', `Device: commands not defined`);
     }
     return this.currentSession;
   }
   getCommands() {
-    return (0, DeviceCommands_1.DeviceCommands)(this.getCurrentSession());
+    return DeviceCommands(this.getCurrentSession());
   }
   setInstance(instance = 0) {
     if (this.instance !== instance) {
@@ -398,7 +423,6 @@ class Device extends utils_1.TypedEmitter {
         ...state
       };
       this.state[this.instance] = newState;
-      this.stateStorage?.saveState(this, newState);
     }
   }
   async initialize(useCardanoDerivation) {
@@ -419,21 +443,17 @@ class Device extends utils_1.TypedEmitter {
       message
     } = await this.getCurrentSession().typedCall('Initialize', 'Features', payload);
     this._updateFeatures(message);
-    this._updateCurrentRelease(message);
+    await this._updateCurrentRelease(message);
     this.setState({
       deriveCardano: payload?.derive_cardano
     });
   }
-  initStorage(storage) {
-    this.stateStorage = storage;
-    this.setState(storage.loadState(this));
-  }
   async getFeatures() {
     const {
       message
     } = await this.getCurrentSession().typedCall('GetFeatures', 'Features', {});
     this._updateFeatures(message);
-    this._updateCurrentRelease(message);
+    await this._updateCurrentRelease(message);
   }
   getAuthenticityChecks() {
     return this.authenticityChecks;
@@ -445,7 +465,7 @@ class Device extends utils_1.TypedEmitter {
     const lastResult = this.authenticityChecks.firmwareRevision;
     const notDoneYet = lastResult === null;
     const wasError = lastResult !== null && !lastResult.success;
-    const wasErrorRetriable = wasError && (0, utils_1.isArrayMember)(lastResult.error, constants_1.FIRMWARE.REVISION_CHECK_RETRIABLE_ERRORS);
+    const wasErrorRetriable = wasError && isArrayMember(lastResult.error, FIRMWARE.REVISION_CHECK_RETRIABLE_ERRORS);
     if (notDoneYet || wasErrorRetriable) {
       await this.checkFirmwareRevision();
     }
@@ -455,15 +475,17 @@ class Device extends utils_1.TypedEmitter {
     if (!firmwareVersion || !this.features || !this.firmwareType) {
       return;
     }
-    if (this.features && this.features.bootloader_mode === true) {
+    if (this.features?.bootloader_mode === true) {
       return;
     }
-    const release = (0, assetUtils_1.getReleaseAsset)(this.features.internal_model, firmwareVersion, this.firmwareType);
-    const result = await (0, checkFirmwareRevision_1.checkFirmwareRevision)({
+    const release = getReleaseAsset(this.features.internal_model, firmwareVersion, this.firmwareType);
+    const result = await checkFirmwareRevision({
       internalModel: this.features.internal_model,
-      deviceRevision: this.features.revision,
       firmwareVersion,
+      deviceRevision: this.features.revision,
       expectedRevision: release?.firmware_revision,
+      deviceBootloaderHash: this.features.bootloader_hash,
+      expectedBootloaderHash: release?.bootloader_hash,
       firmwareType: this.firmwareType
     });
     this.authenticityChecks = {
@@ -471,116 +493,104 @@ class Device extends utils_1.TypedEmitter {
       firmwareRevision: result
     };
   }
-  async changeLanguage({
-    language,
-    binary
-  }) {
-    if (language === 'en-US') {
-      return this._uploadTranslationData(null);
-    }
-    if (binary) {
-      return this._uploadTranslationData(binary);
-    }
-    const version = this.getVersion();
-    if (!version) {
-      throw constants_1.ERRORS.TypedError('Runtime', 'changeLanguage: device version unknown');
-    }
-    if (!this.firmwareType) {
-      throw constants_1.ERRORS.TypedError('Runtime', 'changeLanguage: firmware type unknown');
-    }
-    if (!this._currentRelease) {
-      throw constants_1.ERRORS.TypedError('Runtime', 'changeLanguage: release not found');
-    }
-    const languageBinPath = this._currentRelease.translations[language];
-    const downloadedBinary = await (0, firmwareInfo_1.getLanguage)(languageBinPath);
-    if (!downloadedBinary) {
-      throw constants_1.ERRORS.TypedError('Runtime', 'changeLanguage: translation not found');
-    }
-    let dataToSend;
-    if (Buffer.isBuffer(downloadedBinary)) {
-      dataToSend = new Uint8Array(downloadedBinary).buffer;
-    } else {
-      dataToSend = downloadedBinary;
-    }
-    return this._uploadTranslationData(dataToSend);
-  }
-  async _uploadTranslationData(payload) {
-    if (payload === null) {
-      const response = await this.getCurrentSession().typedCall('ChangeLanguage', ['Success'], {
-        data_length: 0
-      });
-      return response.message;
-    }
-    const length = payload.byteLength;
-    let response = await this.getCurrentSession().typedCall('ChangeLanguage', ['DataChunkRequest', 'Success'], {
-      data_length: length
-    });
-    while (response.type !== 'Success') {
-      const start = response.message.data_offset;
-      const end = response.message.data_offset + response.message.data_length;
-      const chunk = payload.slice(start, end);
-      response = await this.getCurrentSession().typedCall('DataChunkAck', ['DataChunkRequest', 'Success'], {
-        data_chunk: Buffer.from(chunk).toString('hex')
-      });
-    }
-    return response.message;
-  }
   async _updateCurrentRelease(feat) {
-    const {
-      firmwareVersion
-    } = (0, firmwareInfo_1.getCurrentVersion)(feat);
-    const newFirmwareType = (0, firmwareUtils_1.getFirmwareType)(feat);
+    const firmwareVersion = getFirmwareVersionArray({
+      features: feat
+    });
+    const newFirmwareType = getFirmwareType(feat);
     if (!firmwareVersion) {
       return;
     }
-    if (this._currentRelease && newFirmwareType === this.firmwareType && utils_1.versionUtils.isEqual(this._currentRelease.version, firmwareVersion)) {
+    if (this._currentRelease && newFirmwareType === this.firmwareType && versionUtils.isEqual(this._currentRelease.version, firmwareVersion) && isProductionFirmwareChannel(settingsStore.get('firmwareChannel'))) {
       return;
     }
-    const release = await (0, firmwareInfo_1.getReleaseByVersion)(feat, firmwareVersion, newFirmwareType);
+    const release = await getReleaseByVersion(feat, firmwareVersion, newFirmwareType);
     this._currentRelease = release;
     this.availableTranslations = this._currentRelease?.translations ?? {};
   }
   _updateFeatures(feat) {
-    const capabilities = (0, deviceFeaturesUtils_1.parseCapabilities)(feat);
+    const capabilities = parseCapabilities(feat);
     feat.capabilities = capabilities;
-    if (this.features && this.features.session_id && !feat.session_id) {
+    if (this.features?.session_id && !feat.session_id) {
       feat.session_id = this.features.session_id;
     }
     feat.unlocked = feat.unlocked ?? true;
-    const revision = (0, deviceFeaturesUtils_1.parseRevision)(feat);
+    const revision = parseRevision(feat);
     feat.revision = revision;
     if (!feat.model && feat.major_version === 1) {
       feat.model = '1';
     }
-    if (!feat.internal_model || !device_utils_1.DeviceModelInternal[feat.internal_model]) {
-      feat.internal_model = (0, deviceFeaturesUtils_1.ensureInternalModelFeature)(feat.model);
+    if (!feat.internal_model || !DeviceModelInternal[feat.internal_model]) {
+      feat.internal_model = ensureInternalModelFeature(feat.model);
     }
     const version = this.getVersion();
-    const newVersion = [feat.major_version, feat.minor_version, feat.patch_version];
-    if (!version || !utils_1.versionUtils.isEqual(version, newVersion)) {
-      if (version) {
-        this.emit(events_1.DEVICE.FIRMWARE_VERSION_CHANGED, {
-          oldVersion: version,
-          newVersion,
-          device: this.toMessageObject()
-        });
+    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._unavailableCapabilities = (0, deviceFeaturesUtils_1.getUnavailableCapabilities)(feat, (0, coinInfo_1.getAllNetworks)());
-      this._firmwareStatus = (0, firmwareInfo_1.getFirmwareStatus)(feat, (0, firmwareUtils_1.getFirmwareType)(feat));
-      this._firmwareReleaseConfigInfo = (0, firmwareInfo_1.getFirmwareReleaseConfigInfo)(feat, (0, firmwareUtils_1.getFirmwareType)(feat));
-      this._currentRelease = (0, assetUtils_1.getReleaseAsset)(feat.internal_model, newVersion, (0, firmwareUtils_1.getFirmwareType)(feat));
-      this.availableTranslations = this._currentRelease?.translations ?? {};
     }
     this._features = feat;
-    this._firmwareType = (0, firmwareUtils_1.getFirmwareType)(feat);
-    const deviceInfo = device_utils_1.models[feat.internal_model] ?? {
-      name: `Unknown ${feat.internal_model}`,
+    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;
-    this.busy = undefined;
-    if (feat?.unit_color) {
-      const deviceUnitColor = feat.unit_color.toString();
+    if (unitColor) {
+      const deviceUnitColor = unitColor.toString();
       if (deviceUnitColor in deviceInfo.colors) {
         this.color = deviceInfo.colors[deviceUnitColor];
       }
@@ -592,7 +602,7 @@ class Device extends utils_1.TypedEmitter {
         ...this._features,
         [key]: value
       };
-      this.lifecycle.emit(events_1.DEVICE.CHANGED);
+      this.emitDeviceChanged();
     }
   }
   prompt(type, args) {
@@ -614,12 +624,9 @@ class Device extends utils_1.TypedEmitter {
   isUnacquired() {
     return this.features === undefined;
   }
-  isUnreadable() {
-    return !!this.unreadableError;
-  }
   disconnect() {
-    _log.debug('Disconnect cleanup');
-    this.transport.off(transport_1.TRANSPORT.STOPPED, this.onTransportStopped);
+    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());
@@ -627,8 +634,8 @@ class Device extends utils_1.TypedEmitter {
       this.transport.releaseSync(this.sessionAcquired);
       this.sessionAcquired = null;
     }
-    this.lifecycle.emit(events_1.DEVICE.DISCONNECT);
-    return this.interrupt(constants_1.ERRORS.TypedError('Device_Disconnected'));
+    this.lifecycle.emit(DEVICE.DISCONNECT);
+    return this.interrupt(ERRORS.TypedError('Device_Disconnected'));
   }
   isBootloader() {
     return this.features && !!this.features.bootloader_mode;
@@ -640,14 +647,17 @@ class Device extends utils_1.TypedEmitter {
     return this.features && !!this.features.no_backup;
   }
   getVersion() {
-    if (!this.features) return;
-    return [this.features.major_version, this.features.minor_version, this.features.patch_version];
+    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 utils_1.versionUtils.isNewerOrEqual(version, modelVersion);
+    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;
@@ -655,28 +665,25 @@ class Device extends utils_1.TypedEmitter {
   isUsedHere() {
     return !!this.sessionAcquired;
   }
+  getBusy() {
+    return this.busy;
+  }
   isUsedElsewhere() {
     return this.isUsed() && !this.isUsedHere();
   }
   getUniquePath() {
     return this.uniquePath;
   }
-  isT1() {
-    return this.features ? this.features.major_version === 1 : false;
-  }
-  hasUnexpectedMode(allow, require) {
+  hasUnexpectedMode(allow) {
     if (this.features) {
-      if (this.isBootloader() && !allow.includes(events_1.UI.BOOTLOADER)) {
-        return events_1.UI.BOOTLOADER;
-      }
-      if (!this.isInitialized() && !allow.includes(events_1.UI.INITIALIZE)) {
-        return events_1.UI.INITIALIZE;
+      if (this.isBootloader() && !allow.includes(UI_REQUEST.BOOTLOADER)) {
+        return UI_REQUEST.BOOTLOADER;
       }
-      if (this.isSeedless() && !allow.includes(events_1.UI.SEEDLESS)) {
-        return events_1.UI.SEEDLESS;
+      if (!this.isInitialized() && !allow.includes(UI_REQUEST.INITIALIZE)) {
+        return UI_REQUEST.INITIALIZE;
       }
-      if (!this.isBootloader() && require.includes(events_1.UI.BOOTLOADER)) {
-        return events_1.UI.NOT_IN_BOOTLOADER;
+      if (this.isSeedless() && !allow.includes(UI_REQUEST.SEEDLESS)) {
+        return UI_REQUEST.SEEDLESS;
       }
     }
     return null;
@@ -713,9 +720,6 @@ class Device extends utils_1.TypedEmitter {
         id
       }
     };
-    const bluetoothProps = this.descriptor.id && this.descriptor.apiType === 'bluetooth' ? {
-      id: (0, types_1.asBluetoothDeviceId)(this.descriptor.id)
-    } : undefined;
     if (this.unreadableError) {
       return {
         ...base,
@@ -733,7 +737,6 @@ class Device extends utils_1.TypedEmitter {
         label: 'Unacquired device',
         name: this.name,
         transportSessionOwner: this.sessionAcquired ? undefined : sessionOwner,
-        bluetoothProps,
         thp: this.getDeviceThp(),
         status: this.busy ? this.busy : undefined
       };
@@ -745,10 +748,9 @@ class Device extends utils_1.TypedEmitter {
       type: 'acquired',
       id: this.features.device_id,
       label,
-      _state: this.getState(),
-      state: this.getState()?.staticSessionId,
+      state: this.getState(),
       status: this.getStatus(),
-      mode: (0, firmwareUtils_1.getFirmwareMode)(this.features),
+      mode: getFirmwareMode(this.features),
       color: this.color,
       firmware: this.firmwareStatus,
       firmwareReleaseConfigInfo: this.firmwareReleaseConfigInfo,
@@ -757,10 +759,7 @@ class Device extends utils_1.TypedEmitter {
       unavailableCapabilities: this.unavailableCapabilities,
       availableTranslations: this.availableTranslations,
       authenticityChecks: this.authenticityChecks,
-      bluetoothProps,
       thp: this.getDeviceThp()
     };
   }
-}
-exports.Device = Device;
-//# sourceMappingURL=Device.js.map
+}