@trezor/connect 9.6.0 → 9.6.1-beta.2

package/lib/data/firmwareInfo.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRelease = exports.getReleaseInfo = exports.getFirmwareStatus = exports.getInfo = exports.getReleases = exports.parseFirmwareReleases = void 0;
+exports.getRelease = exports.getReleaseInfo = exports.getFirmwareStatus = exports.getInfo = exports.getOnlineReleases = exports.getReleases = exports.parseFirmwareReleases = void 0;
 const device_utils_1 = require("@trezor/device-utils");
 const utils_1 = require("@trezor/utils");
+const assets_1 = require("../utils/assets");
 const firmwareUtils_1 = require("../utils/firmwareUtils");
 const releases = Object.values(device_utils_1.DeviceModelInternal).reduce((acc, key) => ({ ...acc, [key]: [] }), {});
 const parseFirmwareReleases = (json, deviceModel) => {
@@ -16,6 +17,18 @@ const parseFirmwareReleases = (json, deviceModel) => {
 exports.parseFirmwareReleases = parseFirmwareReleases;
 const getReleases = (deviceModel) => releases[deviceModel] || [];
 exports.getReleases = getReleases;
+const getOnlineReleases = async (internalModel) => {
+    const url = `https://data.trezor.io/firmware/${internalModel.toLowerCase()}/releases.json`;
+    const response = await (0, assets_1.httpRequest)(url, 'json', {
+        signal: AbortSignal.timeout(10000),
+        skipLocalForceDownload: true,
+    });
+    if ((0, firmwareUtils_1.isValidReleases)(response)) {
+        return response;
+    }
+    return [];
+};
+exports.getOnlineReleases = getOnlineReleases;
 const getChangelog = (releases2, features) => {
     if (features.bootloader_mode) {
         if (features.firmware_present && features.major_version === 1) {

package/lib/data/version.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "9.6.0";
+export declare const VERSION = "9.6.1-beta.2";
 export declare const DEFAULT_DOMAIN: string;
 export declare const CONTENT_SCRIPT_VERSION = 1;
 export declare const DEEPLINK_VERSION = 1;

package/lib/data/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEEPLINK_VERSION = exports.CONTENT_SCRIPT_VERSION = exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
-exports.VERSION = '9.6.0';
+exports.VERSION = '9.6.1-beta.2';
 const versionN = exports.VERSION.split('.').map(s => parseInt(s, 10));
 const isBeta = exports.VERSION.includes('beta');
 exports.DEFAULT_DOMAIN = isBeta

package/lib/device/Device.d.ts

@@ -1,11 +1,11 @@
-import { TransportProtocol } from '@trezor/protocol';
+import { TransportProtocol, thp as protocolThp } from '@trezor/protocol';
 import { Session } from '@trezor/transport';
 import { type Descriptor, type Transport } from '@trezor/transport';
 import { TypedEmitter } from '@trezor/utils';
 import { PROTO } from '../constants';
 import { TypedCallProvider } from './DeviceCurrentSession';
 import { IStateStorage } from './StateStorage';
-import { DEVICE, DeviceButtonRequestPayload, DeviceVersionChanged, UiResponsePassphrase, UiResponsePin, UiResponseWord } from '../events';
+import { DEVICE, DeviceButtonRequestPayload, DeviceThpCredentialsChangedPayload, DeviceThpPairingPayload, DeviceVersionChanged, UiResponsePassphrase, UiResponsePin, UiResponseThpPairingTag, UiResponseWord } from '../events';
 import { DeviceFirmwareStatus, DeviceState, Device as DeviceTyped, DeviceUniquePath, FirmwareType, ReleaseInfo, UnavailableCapabilities, VersionArray } from '../types';
 type RunOptions = {
     skipFinalReload?: boolean;
@@ -42,6 +42,11 @@ export interface DeviceEvents {
         payload: DeviceButtonRequestPayload;
     };
     [DEVICE.FIRMWARE_VERSION_CHANGED]: DeviceVersionChanged['payload'];
+    [DEVICE.THP_PAIRING]: {
+        payload: DeviceThpPairingPayload;
+        callback: (response: Result<UiResponseThpPairingTag['payload']>) => void;
+    };
+    [DEVICE.THP_CREDENTIALS_CHANGED]: DeviceThpCredentialsChangedPayload;
 }
 type DeviceLifecycle = typeof DEVICE.CONNECT | typeof DEVICE.CONNECT_UNACQUIRED | typeof DEVICE.DISCONNECT | typeof DEVICE.CHANGED;
 type DeviceLifecycleListener = (lifecycle: DeviceLifecycle) => void;
@@ -53,16 +58,16 @@ type DeviceParams = {
 };
 export declare class Device extends TypedEmitter<DeviceEvents> {
     readonly transport: Transport;
-    readonly protocol: TransportProtocol;
     readonly transportPath: import("@trezor/transport/lib/types").PathPublic;
     readonly bluetoothProps: {
         id: string;
     } | undefined;
     private thp;
-    private readonly transportDescriptorType;
-    private session;
-    private transportSessionOwner;
-    private lastAcquiredHere;
+    private readonly possibleHIDdevice;
+    private sessionAcquired;
+    private _protocol;
+    get protocol(): TransportProtocol;
+    getThpState(): protocolThp.ThpState | undefined;
     private unreadableError?;
     private _firmwareStatus;
     get firmwareStatus(): DeviceFirmwareStatus;
@@ -123,14 +128,13 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
         experimental_features: boolean | null;
         internal_model: PROTO.DeviceModelInternal;
     };
-    private _featuresNeedsReload;
+    private wasUsedElsewhere;
     private acquirePromise?;
     private releasePromise?;
     private runAbort?;
     private runPromise?;
     private keepTransportSession;
     private currentSession?;
-    private inconsistent;
     private instance;
     private state;
     private stateStorage?;
@@ -147,20 +151,18 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private sessionDfd?;
     handshakeFinished: boolean;
     constructor({ id, transport, descriptor, listener }: DeviceParams);
+    private readonly onTransportStopped;
+    private readonly onTransportDeviceEvent;
     private getSessionChangePromise;
     private waitAndCompareSession;
     acquire(): import("@trezor/transport/lib/types").AsyncResultWithTypedError<Session, "Network request failed" | "Wrong result type." | "device disconnected during action" | "unexpected error" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "wrong previous session" | "LIBUSB_ERROR_ACCESS">;
-    release(): Promise<import("@trezor/transport/lib/types").Success<null> | {
-        success: false;
-        error: "Network request failed" | "Wrong result type." | "device disconnected during action" | "unexpected error" | "session not found" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "wrong previous session";
-        message?: string;
-    } | undefined>;
+    release(): import("@trezor/transport/lib/types").AsyncResultWithTypedError<null, "Network request failed" | "Wrong result type." | "device disconnected during action" | "unexpected error" | "session not found" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "wrong previous session"> | undefined;
     handshake(delay?: number): Promise<void>;
-    updateDescriptor(descriptor: Descriptor): Promise<void>;
+    private updateDescriptor;
     run(fn?: () => Promise<void>, options?: RunOptions): Promise<void>;
     interrupt(reason: Error): Promise<void>;
     get currentRun(): Promise<void> | undefined;
-    usedElsewhere(): void;
+    private usedElsewhere;
     private _runInner;
     getCurrentSession(): TypedCallProvider;
     getCommands(): {
@@ -228,7 +230,6 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     getInstance(): number;
     getState(): DeviceState | undefined;
     setState(state?: Partial<DeviceState>): void;
-    validateState(preauthorized?: boolean): Promise<`${string}@${string}:${number}` | undefined>;
     initialize(useCardanoDerivation: boolean): Promise<void>;
     initStorage(storage: IStateStorage): void;
     getFeatures(): Promise<void>;
@@ -247,14 +248,13 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     }>;
     private _uploadTranslationData;
     private _updateFeatures;
-    prompt<T extends typeof DEVICE.PIN | typeof DEVICE.PASSPHRASE | typeof DEVICE.WORD>(type: T, args: Omit<DeviceEvents[T], 'callback'>): Promise<Parameters<DeviceEvents[T]["callback"]>[0]>;
+    prompt<T extends typeof DEVICE.PIN | typeof DEVICE.PASSPHRASE | typeof DEVICE.WORD | typeof DEVICE.THP_PAIRING>(type: T, args: Omit<DeviceEvents[T], 'callback'>): Promise<Parameters<DeviceEvents[T]["callback"]>[0]>;
     isUnacquired(): boolean;
     isUnreadable(): boolean;
-    disconnect(): Promise<void>;
+    private disconnect;
     isBootloader(): boolean;
     isInitialized(): boolean;
     isSeedless(): boolean;
-    isInconsistent(): boolean;
     getVersion(): VersionArray | undefined;
     atLeast(versions: string[] | string): boolean;
     isUsed(): boolean;
@@ -263,7 +263,6 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     getUniquePath(): DeviceUniquePath;
     isT1(): boolean;
     hasUnexpectedMode(allow: string[], require: string[]): "ui-device_bootloader_mode" | "ui-device_not_in_bootloader_mode" | "ui-device_not_initialized" | "ui-device_seedless" | null;
-    dispose(): void;
     private getMode;
     toMessageObject(): DeviceTyped;
 }

package/lib/device/Device.js

@@ -15,26 +15,28 @@ const DataManager_1 = require("../data/DataManager");
 const coinInfo_1 = require("../data/coinInfo");
 const firmwareInfo_1 = require("../data/firmwareInfo");
 const getLanguage_1 = require("../data/getLanguage");
-const models_1 = require("../data/models");
 const events_1 = require("../events");
 const types_1 = require("../types");
 const debug_1 = require("../utils/debug");
 const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
-const pathUtils_1 = require("../utils/pathUtils");
 const _log = (0, debug_1.initLog)('Device');
 exports.CANCEL_TIMEOUT = 1_000;
 exports.GET_FEATURES_TIMEOUT = 3_000;
 exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = 20_000;
 class Device extends utils_1.TypedEmitter {
     transport;
-    protocol;
     transportPath;
     bluetoothProps;
     thp;
-    transportDescriptorType;
-    session;
-    transportSessionOwner;
-    lastAcquiredHere;
+    possibleHIDdevice;
+    sessionAcquired;
+    _protocol;
+    get protocol() {
+        return this._protocol;
+    }
+    getThpState() {
+        return this.thp;
+    }
     unreadableError;
     _firmwareStatus;
     get firmwareStatus() {
@@ -48,14 +50,13 @@ class Device extends utils_1.TypedEmitter {
     get features() {
         return this._features;
     }
-    _featuresNeedsReload = false;
+    wasUsedElsewhere = false;
     acquirePromise;
     releasePromise;
     runAbort;
     runPromise;
     keepTransportSession = false;
     currentSession;
-    inconsistent = false;
     instance = 0;
     state = [];
     stateStorage = undefined;
@@ -81,16 +82,28 @@ class Device extends utils_1.TypedEmitter {
     constructor({ id, transport, descriptor, listener }) {
         super();
         this.emitLifecycle = listener;
-        this.protocol = protocol_1.v1;
+        this._protocol = protocol_1.v1;
         this.uniquePath = id;
         this.transport = transport;
         this.transportPath = descriptor.path;
-        this.transportSessionOwner = descriptor.sessionOwner;
-        this.transportDescriptorType = descriptor.type;
+        this.possibleHIDdevice = [0, 2].includes(descriptor.type);
         this.bluetoothProps = descriptor.id ? { id: descriptor.id } : undefined;
-        this.session = descriptor.session;
-        this.lastAcquiredHere = false;
-    }
+        this.sessionAcquired = null;
+        transport.on(transport_1.TRANSPORT.STOPPED, this.onTransportStopped);
+        transport.deviceEvents.on(this.transportPath, this.onTransportDeviceEvent);
+    }
+    onTransportStopped = () => this.disconnect();
+    onTransportDeviceEvent = (event) => {
+        switch (event.type) {
+            case transport_1.TRANSPORT.DEVICE_SESSION_CHANGED:
+                return this.updateDescriptor(event.descriptor);
+            case transport_1.TRANSPORT.DEVICE_REQUEST_RELEASE:
+                return this.usedElsewhere();
+            case transport_1.TRANSPORT.DEVICE_DISCONNECTED: {
+                return this.disconnect();
+            }
+        }
+    };
     getSessionChangePromise() {
         if (!this.sessionDfd) {
             this.sessionDfd = (0, utils_1.createDeferred)();
@@ -123,15 +136,15 @@ class Device extends utils_1.TypedEmitter {
     }
     acquire() {
         const sessionPromise = this.getSessionChangePromise();
+        const previous = this.transport.getDescriptor(this.transportPath)?.session ?? null;
         this.acquirePromise = this.transport
-            .acquire({ input: { path: this.transportPath, previous: this.session } })
+            .acquire({ input: { path: this.transportPath, previous } })
             .then(result => this.waitAndCompareSession(result, sessionPromise))
             .then(result => {
             if (result.success) {
-                this.session = result.payload;
-                this.lastAcquiredHere = true;
-                this.currentSession?.dispose();
-                this.currentSession = new DeviceCurrentSession_1.DeviceCurrentSession(this, this.transport, this.protocol, this.session);
+                this.wasUsedElsewhere = false;
+                this.sessionAcquired = result.payload;
+                this.currentSession = new DeviceCurrentSession_1.DeviceCurrentSession(this, this.transport, this.sessionAcquired);
                 return result;
             }
             else {
@@ -143,19 +156,17 @@ class Device extends utils_1.TypedEmitter {
         });
         return this.acquirePromise;
     }
-    async release() {
-        const localSession = this.lastAcquiredHere ? this.session : null;
-        if (!localSession || this.keepTransportSession || this.releasePromise) {
+    release() {
+        if (!this.sessionAcquired || this.keepTransportSession || this.releasePromise) {
             return;
         }
-        await this.currentSession?.dispose();
         const sessionPromise = this.getSessionChangePromise();
         this.releasePromise = this.transport
-            .release({ session: localSession, path: this.transportPath })
+            .release({ session: this.sessionAcquired, path: this.transportPath })
             .then(result => this.waitAndCompareSession(result, sessionPromise))
             .then(result => {
             if (result.success) {
-                this.session = null;
+                this.sessionAcquired = null;
             }
             return result;
         })
@@ -184,15 +195,17 @@ class Device extends utils_1.TypedEmitter {
                         error.message === transport_1.TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION ||
                         error.message === transport_1.TRANSPORT_ERROR.HTTP_ERROR) {
                     }
-                    else if (error.message === transport_1.TRANSPORT_ERROR.UNEXPECTED_ERROR ||
-                        error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS ||
-                        error.code === 'Device_UsedElsewhere' ||
-                        error.code === 'Device_InitializeFailed') {
+                    else if ((this.possibleHIDdevice &&
+                        error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE) ||
+                        error.message === transport_1.TRANSPORT_ERROR.LIBUSB_ERROR_ACCESS) {
+                        this.unreadableError = error.message;
                         this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
                     }
                     else if (error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE ||
-                        error.message?.indexOf(constants_1.ERRORS.LIBUSB_ERROR_MESSAGE) >= 0) {
-                        this.unreadableError = error?.message;
+                        error.message === transport_1.TRANSPORT_ERROR.UNEXPECTED_ERROR ||
+                        error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS ||
+                        error.code === 'Device_UsedElsewhere' ||
+                        error.code === 'Device_InitializeFailed') {
                         this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
                     }
                     else {
@@ -208,17 +221,12 @@ class Device extends utils_1.TypedEmitter {
     async updateDescriptor(descriptor) {
         this.sessionDfd?.resolve(descriptor.session);
         await Promise.all([this.acquirePromise, this.releasePromise]);
-        if (descriptor.session && descriptor.session !== this.session) {
+        if (descriptor.session && descriptor.session !== this.sessionAcquired) {
             this.usedElsewhere();
         }
         if (!descriptor.session) {
-            const methodStillRunning = !this.currentSession?.isDisposed();
-            if (methodStillRunning) {
-                this.keepTransportSession = false;
-            }
+            this.keepTransportSession = false;
         }
-        this.session = descriptor.session;
-        this.transportSessionOwner = descriptor.sessionOwner;
         this.emitLifecycle(events_1.DEVICE.CHANGED);
     }
     run(fn, options = {}) {
@@ -230,7 +238,7 @@ class Device extends utils_1.TypedEmitter {
         this.runAbort = new AbortController();
         const { signal } = this.runAbort;
         this.runPromise = Promise.race([
-            this._runInner(fn, options),
+            this._runInner(fn, options, signal),
             new Promise((_, reject) => {
                 signal.addEventListener('abort', () => reject(signal.reason));
             }),
@@ -253,7 +261,7 @@ class Device extends utils_1.TypedEmitter {
         return this.runPromise;
     }
     async interrupt(reason) {
-        await this.currentSession?.abort(reason, true);
+        await this.currentSession?.abort(reason);
         this.runAbort?.abort(reason);
         await this.currentRun;
     }
@@ -261,19 +269,16 @@ class Device extends utils_1.TypedEmitter {
         return this.runPromise?.catch(() => { });
     }
     usedElsewhere() {
-        if (!this.lastAcquiredHere) {
+        this.wasUsedElsewhere = true;
+        if (!this.sessionAcquired) {
             return;
         }
-        this.lastAcquiredHere = false;
-        this._featuresNeedsReload = true;
+        this.transport.releaseDevice(this.sessionAcquired);
+        this.sessionAcquired = null;
         _log.debug('interruptionFromOutside');
-        this.currentSession?.dispose();
         this.runAbort?.abort(constants_1.ERRORS.TypedError('Device_UsedElsewhere'));
-        if (this.session) {
-            this.transport.releaseDevice(this.session);
-        }
     }
-    async _runInner(fn, options) {
+    async _runInner(fn, options, abortSignal) {
         if (this.releasePromise) {
             await this.releasePromise;
         }
@@ -281,6 +286,8 @@ class Device extends utils_1.TypedEmitter {
         if (acquireNeeded) {
             await this.acquire();
         }
+        if (abortSignal.aborted)
+            throw abortSignal.reason;
         const { staticSessionId, deriveCardano } = this.getState() || {};
         if (acquireNeeded || !staticSessionId || (!deriveCardano && options.useCardanoDerivation)) {
             try {
@@ -289,43 +296,21 @@ class Device extends utils_1.TypedEmitter {
                 }
                 else {
                     const isNative = DataManager_1.DataManager.getSettings('env') === 'react-native';
-                    const getFeaturesTimeout = isNative
-                        ? exports.GET_FEATURES_TIMEOUT_REACT_NATIVE
-                        : exports.GET_FEATURES_TIMEOUT;
                     const cancelTimeout = isNative
                         ? exports.GET_FEATURES_TIMEOUT_REACT_NATIVE
                         : exports.CANCEL_TIMEOUT;
-                    if (['v1', 'bridge'].includes(this.protocol.name) &&
-                        ![0, 2].includes(this.transportDescriptorType)) {
+                    if (['v1', 'bridge'].includes(this.protocol.name) && !this.possibleHIDdevice) {
                         _log.debug('sending a preventive cancel on the first encounter with the device');
                         await Promise.race([
                             this.getCurrentSession().cancelCall(),
                             new Promise((_, reject) => setTimeout(reject, cancelTimeout)),
                         ]).catch(() => this.acquire());
                     }
-                    let getFeaturesTimeoutId;
-                    await Promise.race([
-                        this.getFeatures().finally(() => clearTimeout(getFeaturesTimeoutId)),
-                        new Promise((_resolve, reject) => {
-                            getFeaturesTimeoutId = setTimeout(async () => {
-                                await this.getCurrentSession().cancelCall(false);
-                                reject(new Error('GetFeatures timeout'));
-                            }, getFeaturesTimeout);
-                        }),
-                    ]);
+                    await this.getFeatures();
                 }
             }
             catch (error) {
                 _log.warn('Device._runInner error: ', error.message);
-                if (!this.inconsistent &&
-                    (error.message === 'GetFeatures timeout' || error.message === 'Unknown message')) {
-                    this.inconsistent = true;
-                    return this._runInner(() => Promise.resolve({}), options);
-                }
-                if (transport_1.TRANSPORT_ERROR.ABORTED_BY_TIMEOUT === error.message) {
-                    this.unreadableError = 'Connection timeout';
-                }
-                this.inconsistent = true;
                 return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}${error.code ? `, code: ${error.code}` : ''}`));
             }
         }
@@ -372,7 +357,7 @@ class Device extends utils_1.TypedEmitter {
     setInstance(instance = 0) {
         if (this.instance !== instance) {
             if (this.keepTransportSession) {
-                this.lastAcquiredHere = false;
+                this.sessionAcquired = null;
                 this.keepTransportSession = false;
             }
         }
@@ -398,31 +383,6 @@ class Device extends utils_1.TypedEmitter {
             this.stateStorage?.saveState(this, newState);
         }
     }
-    async validateState(preauthorized = false) {
-        if (!this.features)
-            return;
-        if (!this.features.unlocked && preauthorized) {
-            if (await this.getCommands().preauthorize(false)) {
-                return;
-            }
-        }
-        const expectedState = this.getState()?.staticSessionId;
-        const { message } = await this.getCurrentSession().typedCall('GetAddress', 'Address', {
-            address_n: [(0, pathUtils_1.toHardened)(44), (0, pathUtils_1.toHardened)(1), (0, pathUtils_1.toHardened)(0), 0, 0],
-            coin_name: 'Testnet',
-            script_type: 'SPENDADDRESS',
-        });
-        const uniqueState = `${message.address}@${this.features.device_id}:${this.instance}`;
-        if (this.features.session_id) {
-            this.setState({ sessionId: this.features.session_id });
-        }
-        if (expectedState && expectedState !== uniqueState) {
-            return uniqueState;
-        }
-        if (!expectedState) {
-            this.setState({ staticSessionId: uniqueState });
-        }
-    }
     async initialize(useCardanoDerivation) {
         let payload;
         if (this.features) {
@@ -570,12 +530,12 @@ class Device extends utils_1.TypedEmitter {
             return response.message;
         }
         const length = payload.byteLength;
-        let response = await this.getCurrentSession().typedCall('ChangeLanguage', ['TranslationDataRequest', 'Success'], { data_length: length });
+        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('TranslationDataAck', ['TranslationDataRequest', 'Success'], {
+            response = await this.getCurrentSession().typedCall('DataChunkAck', ['DataChunkRequest', 'Success'], {
                 data_chunk: Buffer.from(chunk).toString('hex'),
             });
         }
@@ -616,7 +576,6 @@ class Device extends utils_1.TypedEmitter {
             this.availableTranslations = this.firmwareRelease?.translations ?? [];
         }
         this._features = feat;
-        this._featuresNeedsReload = false;
         if (feat.fw_vendor === 'Trezor Bitcoin-only') {
             this._firmwareType = types_1.FirmwareType.BitcoinOnly;
         }
@@ -631,7 +590,7 @@ class Device extends utils_1.TypedEmitter {
                     ? types_1.FirmwareType.BitcoinOnly
                     : types_1.FirmwareType.Regular;
         }
-        const deviceInfo = models_1.models[feat.internal_model] ?? {
+        const deviceInfo = device_utils_1.models[feat.internal_model] ?? {
             name: `Unknown ${feat.internal_model}`,
             colors: {},
         };
@@ -665,8 +624,14 @@ class Device extends utils_1.TypedEmitter {
     }
     disconnect() {
         _log.debug('Disconnect cleanup');
+        this.transport.off(transport_1.TRANSPORT.STOPPED, this.onTransportStopped);
+        this.transport.deviceEvents.off(this.transportPath, this.onTransportDeviceEvent);
+        this.removeAllListeners();
         this.sessionDfd?.reject(new Error());
-        this.lastAcquiredHere = false;
+        if (this.sessionAcquired) {
+            this.transport.releaseSync(this.sessionAcquired);
+            this.sessionAcquired = null;
+        }
         this.emitLifecycle(events_1.DEVICE.DISCONNECT);
         this.emitLifecycle = () => { };
         return this.interrupt(constants_1.ERRORS.TypedError('Device_Disconnected'));
@@ -680,9 +645,6 @@ class Device extends utils_1.TypedEmitter {
     isSeedless() {
         return this.features && !!this.features.no_backup;
     }
-    isInconsistent() {
-        return this.inconsistent;
-    }
     getVersion() {
         if (!this.features)
             return;
@@ -700,13 +662,13 @@ class Device extends utils_1.TypedEmitter {
         return utils_1.versionUtils.isNewerOrEqual(version, modelVersion);
     }
     isUsed() {
-        return typeof this.session === 'string';
+        return !!this.transport.getDescriptor(this.transportPath)?.session;
     }
     isUsedHere() {
-        return this.isUsed() && this.lastAcquiredHere;
+        return !!this.sessionAcquired;
     }
     isUsedElsewhere() {
-        return this.isUsed() && !this.lastAcquiredHere;
+        return this.isUsed() && !this.isUsedHere();
     }
     getUniquePath() {
         return this.uniquePath;
@@ -731,12 +693,6 @@ class Device extends utils_1.TypedEmitter {
         }
         return null;
     }
-    dispose() {
-        this.removeAllListeners();
-        if (this.session && this.lastAcquiredHere) {
-            this.transport.releaseSync(this.session);
-        }
-    }
     getMode() {
         if (this.features.bootloader_mode)
             return 'bootloader';
@@ -755,27 +711,26 @@ class Device extends utils_1.TypedEmitter {
                 type: 'unreadable',
                 error: this.unreadableError,
                 label: 'Unreadable device',
-                transportDescriptorType: this.transportDescriptorType,
+                hid: this.possibleHIDdevice,
             };
         }
         if (this.isUnacquired()) {
+            const sessionOwner = this.transport.getDescriptor(this.transportPath)?.sessionOwner;
             return {
                 ...base,
                 type: 'unacquired',
                 label: 'Unacquired device',
                 name: this.name,
-                transportSessionOwner: this.lastAcquiredHere
-                    ? undefined
-                    : this.transportSessionOwner,
+                transportSessionOwner: this.sessionAcquired ? undefined : sessionOwner,
                 bluetoothProps: this.bluetoothProps,
                 thp: this.thp?.serialize(),
             };
         }
         const defaultLabel = 'My Trezor';
         const label = this.features.label === '' || !this.features.label ? defaultLabel : this.features.label;
-        let status = this.isUsedElsewhere() ? 'occupied' : 'available';
-        if (this._featuresNeedsReload)
-            status = 'used';
+        const status = this.isUsedElsewhere()
+            ? 'occupied'
+            : (this.wasUsedElsewhere && 'used') || 'available';
         return {
             ...base,
             type: 'acquired',