@trezor/connect 9.4.2 → 9.4.3-beta.2

package/lib/device/Device.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = exports.GET_FEATURES_TIMEOUT = void 0;
+const crypto_1 = require("crypto");
 const utils_1 = require("@trezor/utils");
 const protocol_1 = require("@trezor/protocol");
+const transport_1 = require("@trezor/transport");
 const DeviceCommands_1 = require("./DeviceCommands");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
@@ -11,11 +13,11 @@ const DataManager_1 = require("../data/DataManager");
 const firmwareInfo_1 = require("../data/firmwareInfo");
 const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
 const debug_1 = require("../utils/debug");
-const transport_1 = require("@trezor/transport");
 const types_1 = require("../types");
 const models_1 = require("../data/models");
 const getLanguage_1 = require("../data/getLanguage");
 const checkFirmwareRevision_1 = require("./checkFirmwareRevision");
+const firmware_1 = require("../api/firmware");
 const _log = (0, debug_1.initLog)('Device');
 exports.GET_FEATURES_TIMEOUT = 3000;
 exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = 20000;
@@ -25,98 +27,192 @@ const parseRunOptions = (options) => {
     return options;
 };
 class Device extends utils_1.TypedEmitter {
-    constructor(transport, descriptor) {
+    get firmwareStatus() {
+        return this._firmwareStatus;
+    }
+    get firmwareRelease() {
+        return this._firmwareRelease;
+    }
+    get features() {
+        return this._features;
+    }
+    get unavailableCapabilities() {
+        return this._unavailableCapabilities;
+    }
+    get firmwareType() {
+        return this._firmwareType;
+    }
+    constructor({ id, transport, descriptor, listener }) {
         super();
-        this.featuresNeedsReload = false;
+        this._featuresNeedsReload = false;
         this.keepTransportSession = false;
         this.loaded = false;
         this.inconsistent = false;
         this.instance = 0;
         this.state = [];
         this.stateStorage = undefined;
-        this.unavailableCapabilities = {};
-        this.networkTypeState = [];
+        this._unavailableCapabilities = {};
         this.name = 'Trezor';
         this.availableTranslations = [];
         this.authenticityChecks = {
             firmwareRevision: null,
+            firmwareHash: null,
         };
-        this.useCardanoDerivation = false;
+        this.emitLifecycle = listener;
         this.protocol = protocol_1.v1;
+        this.uniquePath = id;
         this.transport = transport;
-        this.originalDescriptor = descriptor;
+        this.transportPath = descriptor.path;
+        this.transportSessionOwner = descriptor.sessionOwner;
+        this.transportDescriptorType = descriptor.type;
+        this.session = descriptor.session;
+        this.lastAcquiredHere = false;
         this.firstRunPromise = (0, utils_1.createDeferred)();
     }
-    static fromDescriptor(transport, originalDescriptor) {
-        const descriptor = { ...originalDescriptor, session: null };
-        try {
-            const device = new Device(transport, descriptor);
-            return device;
-        }
-        catch (error) {
-            _log.error('Device.fromDescriptor', error);
-            throw error;
+    getSessionChangePromise() {
+        if (!this.sessionDfd) {
+            this.sessionDfd = (0, utils_1.createDeferred)();
+            this.sessionDfd.promise.finally(() => {
+                this.sessionDfd = undefined;
+            });
         }
+        return this.sessionDfd.promise;
     }
-    static createUnacquired(transport, descriptor, unreadableError) {
-        const device = new Device(transport, descriptor);
-        device.unreadableError = unreadableError;
-        return device;
-    }
-    async acquire() {
-        this.acquirePromise = this.transport.acquire({
-            input: {
-                path: this.originalDescriptor.path,
-                previous: this.originalDescriptor.session,
-            },
-        });
-        const acquireResult = await this.acquirePromise;
-        this.acquirePromise = undefined;
-        if (!acquireResult.success) {
-            if (this.runPromise) {
-                this.runPromise.reject(new Error(acquireResult.error));
-                delete this.runPromise;
+    async waitAndCompareSession(response, sessionPromise) {
+        if (response.success) {
+            try {
+                if ((await sessionPromise) !== response.payload) {
+                    return {
+                        success: false,
+                        error: transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS,
+                    };
+                }
+            }
+            catch {
+                return {
+                    success: false,
+                    error: transport_1.TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION,
+                };
+            }
+        }
+        return response;
+    }
+    acquire() {
+        const sessionPromise = this.getSessionChangePromise();
+        this.acquirePromise = this.transport
+            .acquire({ input: { path: this.transportPath, previous: this.session } })
+            .then(result => this.waitAndCompareSession(result, sessionPromise))
+            .then(result => {
+            var _a;
+            if (result.success) {
+                this.session = result.payload;
+                this.lastAcquiredHere = true;
+                (_a = this.commands) === null || _a === void 0 ? void 0 : _a.dispose();
+                this.commands = new DeviceCommands_1.DeviceCommands(this, this.transport, this.session);
+                return result;
+            }
+            else {
+                if (this.runPromise) {
+                    this.runPromise.reject(new Error(result.error));
+                    delete this.runPromise;
+                }
+                throw result.error;
             }
-            throw acquireResult.error;
+        })
+            .finally(() => {
+            this.acquirePromise = undefined;
+        });
+        return this.acquirePromise;
+    }
+    async release() {
+        const localSession = this.getLocalSession();
+        if (!localSession || this.keepTransportSession || this.releasePromise) {
+            return;
         }
-        const transportSession = acquireResult.payload;
-        _log.debug('Expected workflow id:', transportSession);
-        this.transportSession = transportSession;
-        this.originalDescriptor.session = transportSession;
         if (this.commands) {
             this.commands.dispose();
+            if (this.commands.callPromise) {
+                await this.commands.callPromise;
+            }
         }
-        this.commands = new DeviceCommands_1.DeviceCommands(this, this.transport, transportSession);
-    }
-    async release() {
-        if (this.isUsedHere() &&
-            this.transportSession &&
-            !this.keepTransportSession &&
-            !this.releasePromise) {
-            if (this.commands) {
-                this.commands.dispose();
-                if (this.commands.callPromise) {
-                    await this.commands.callPromise;
-                }
+        const sessionPromise = this.getSessionChangePromise();
+        this.releasePromise = this.transport
+            .release({ session: localSession, path: this.transportPath })
+            .then(result => this.waitAndCompareSession(result, sessionPromise))
+            .then(result => {
+            if (result.success) {
+                this.session = null;
             }
-            this.releasePromise = this.transport.release({
-                session: this.transportSession,
-                path: this.originalDescriptor.path,
-            });
-            const releaseResponse = await this.releasePromise;
+            return result;
+        })
+            .finally(() => {
             this.releasePromise = undefined;
-            if (releaseResponse.success) {
-                this.transportSession = null;
-                this.originalDescriptor.session = null;
-            }
-        }
+        });
+        return this.releasePromise;
+    }
+    releaseTransportSession() {
+        this.keepTransportSession = false;
     }
     async cleanup() {
-        const acquiredListeners = this.listeners(events_1.DEVICE.ACQUIRED);
-        this.removeAllListeners();
+        this.eventNames().forEach(e => this.removeAllListeners(e));
         delete this.runPromise;
         await this.release();
-        acquiredListeners.forEach(l => this.once(events_1.DEVICE.ACQUIRED, l));
+    }
+    async handshake(delay) {
+        var _a;
+        if (delay) {
+            await (0, utils_1.createTimeoutPromise)(501 + delay);
+        }
+        while (true) {
+            if (this.isUsedElsewhere()) {
+                this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
+            }
+            else {
+                try {
+                    await this.run();
+                }
+                catch (error) {
+                    if (error.code === 'Device_NotFound' ||
+                        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.UNEXPECTED_ERROR ||
+                        error.message === transport_1.TRANSPORT_ERROR.DESCRIPTOR_NOT_FOUND ||
+                        error.message === transport_1.TRANSPORT_ERROR.HTTP_ERROR) {
+                    }
+                    else if (error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS ||
+                        error.code === 'Device_UsedElsewhere') {
+                        this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
+                    }
+                    else if (error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE ||
+                        ((_a = error.message) === null || _a === void 0 ? void 0 : _a.indexOf(constants_1.ERRORS.LIBUSB_ERROR_MESSAGE)) >= 0 ||
+                        error.code === 'Device_InitializeFailed') {
+                        this.unreadableError = error === null || error === void 0 ? void 0 : error.message;
+                        this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
+                    }
+                    else {
+                        await (0, utils_1.createTimeoutPromise)(501);
+                        continue;
+                    }
+                }
+            }
+            return;
+        }
+    }
+    async updateDescriptor(descriptor) {
+        var _a, _b;
+        (_a = this.sessionDfd) === null || _a === void 0 ? void 0 : _a.resolve(descriptor.session);
+        await Promise.all([this.acquirePromise, this.releasePromise]);
+        if (descriptor.session && descriptor.session !== this.session) {
+            this.usedElsewhere();
+        }
+        if (!descriptor.session) {
+            const methodStillRunning = !((_b = this.commands) === null || _b === void 0 ? void 0 : _b.isDisposed());
+            if (methodStillRunning) {
+                this.releaseTransportSession();
+            }
+        }
+        this.session = descriptor.session;
+        this.emitLifecycle(events_1.DEVICE.CHANGED);
     }
     run(fn, options) {
         if (this.runPromise) {
@@ -124,9 +220,16 @@ class Device extends utils_1.TypedEmitter {
             throw constants_1.ERRORS.TypedError('Device_CallInProgress');
         }
         options = parseRunOptions(options);
+        const wasUnacquired = this.isUnacquired();
         const runPromise = (0, utils_1.createDeferred)();
         this.runPromise = runPromise;
-        this._runInner(fn, options).catch(err => {
+        this._runInner(fn, options)
+            .then(() => {
+            if (wasUnacquired && !this.isUnacquired()) {
+                this.emitLifecycle(events_1.DEVICE.CONNECT);
+            }
+        })
+            .catch(err => {
             runPromise.reject(err);
         });
         return runPromise.promise;
@@ -164,7 +267,12 @@ class Device extends utils_1.TypedEmitter {
             delete this.runPromise;
         }
     }
-    interruptionFromOutside() {
+    usedElsewhere() {
+        if (!this.lastAcquiredHere) {
+            return;
+        }
+        this.lastAcquiredHere = false;
+        this._featuresNeedsReload = true;
         _log.debug('interruptionFromOutside');
         if (this.commands) {
             this.commands.dispose();
@@ -173,19 +281,20 @@ class Device extends utils_1.TypedEmitter {
             this.runPromise.reject(constants_1.ERRORS.TypedError('Device_UsedElsewhere'));
             delete this.runPromise;
         }
-        if (this.originalDescriptor.session) {
-            this.transport.releaseDevice(this.originalDescriptor.session);
+        if (this.session) {
+            this.transport.releaseDevice(this.session);
         }
     }
     async _runInner(fn, options) {
-        var _a, _b;
+        var _a;
         if (this.releasePromise) {
             await this.releasePromise;
         }
+        const { staticSessionId, deriveCardano } = this.getState() || {};
         if (!this.isUsedHere() ||
             ((_a = this.commands) === null || _a === void 0 ? void 0 : _a.disposed) ||
-            !((_b = this.getState()) === null || _b === void 0 ? void 0 : _b.staticSessionId) ||
-            this.useCardanoDerivation != !!options.useCardanoDerivation) {
+            !staticSessionId ||
+            (!deriveCardano && options.useCardanoDerivation)) {
             await this.acquire();
             try {
                 if (fn) {
@@ -218,9 +327,6 @@ class Device extends utils_1.TypedEmitter {
         if (options.keepSession) {
             this.keepTransportSession = true;
         }
-        if (this.listeners(events_1.DEVICE.ACQUIRED).length > 0) {
-            this.emit(events_1.DEVICE.ACQUIRED);
-        }
         if (fn) {
             await fn();
         }
@@ -250,7 +356,7 @@ class Device extends utils_1.TypedEmitter {
     setInstance(instance = 0) {
         if (this.instance !== instance) {
             if (this.keepTransportSession) {
-                this.transportSession = null;
+                this.lastAcquiredHere = false;
                 this.keepTransportSession = false;
             }
         }
@@ -300,19 +406,19 @@ class Device extends utils_1.TypedEmitter {
         }
     }
     async initialize(useCardanoDerivation) {
-        var _a;
         let payload;
         if (this.features) {
-            const sessionId = (_a = this.getState()) === null || _a === void 0 ? void 0 : _a.sessionId;
-            payload = {};
-            payload.derive_cardano = useCardanoDerivation;
-            this.useCardanoDerivation = useCardanoDerivation;
+            const { sessionId, deriveCardano } = this.getState() || {};
+            payload = {
+                derive_cardano: deriveCardano || useCardanoDerivation,
+            };
             if (sessionId) {
                 payload.session_id = sessionId;
             }
         }
         const { message } = await this.getCommands().typedCall('Initialize', 'Features', payload);
         this._updateFeatures(message);
+        this.setState({ deriveCardano: payload === null || payload === void 0 ? void 0 : payload.derive_cardano });
     }
     initStorage(storage) {
         this.stateStorage = storage;
@@ -321,9 +427,12 @@ class Device extends utils_1.TypedEmitter {
     async getFeatures() {
         const { message } = await this.getCommands().typedCall('GetFeatures', 'Features', {});
         this._updateFeatures(message);
+        if (this.authenticityChecks.firmwareHash === null) {
+            this.authenticityChecks.firmwareHash = await this.checkFirmwareHash();
+        }
         if (this.authenticityChecks.firmwareRevision === null ||
             (this.authenticityChecks.firmwareRevision.success === false &&
-                this.authenticityChecks.firmwareRevision.error === 'cannot-perform-check-offline')) {
+                ['cannot-perform-check-offline', 'other-error'].includes(this.authenticityChecks.firmwareRevision.error))) {
             await this.checkFirmwareRevision();
         }
         if (!this.features.language_version_matches &&
@@ -338,6 +447,51 @@ class Device extends utils_1.TypedEmitter {
             }
         }
     }
+    async checkFirmwareHash() {
+        var _a;
+        const createFailResult = (error) => ({ success: false, error });
+        const baseUrl = DataManager_1.DataManager.getSettings('binFilesBaseUrl');
+        const enabled = DataManager_1.DataManager.getSettings('enableFirmwareHashCheck');
+        if (!enabled || baseUrl === undefined)
+            return createFailResult('check-skipped');
+        const firmwareVersion = this.getVersion();
+        if (firmwareVersion === undefined || !this.features || this.features.bootloader_mode) {
+            return null;
+        }
+        const checkSupported = this.atLeast(constants_1.FIRMWARE.FW_HASH_SUPPORTED_VERSIONS);
+        if (!checkSupported)
+            return createFailResult('check-unsupported');
+        const release = (0, firmwareInfo_1.getReleases)(this.features.internal_model).find(r => utils_1.versionUtils.isEqual(r.version, firmwareVersion));
+        if (release === undefined)
+            return createFailResult('unknown-release');
+        const btcOnly = this.firmwareType === types_1.FirmwareType.BitcoinOnly;
+        const binary = await (0, firmware_1.getBinaryOptional)({ baseUrl, btcOnly, release });
+        if (binary === null) {
+            return createFailResult('check-unsupported');
+        }
+        if (binary.byteLength < 200) {
+            _log.warn(`Firmware binary for hash check suspiciously small (< 200 b)`);
+            return createFailResult('check-unsupported');
+        }
+        const strippedBinary = (0, firmware_1.stripFwHeaders)(binary);
+        const { hash: expectedHash, challenge } = (0, firmware_1.calculateFirmwareHash)(this.features.major_version, strippedBinary, (0, crypto_1.randomBytes)(32));
+        const getFirmwareHashOptional = async () => {
+            try {
+                return await this.getCommands().typedCall('GetFirmwareHash', 'FirmwareHash', {
+                    challenge,
+                });
+            }
+            catch {
+                return null;
+            }
+        };
+        const deviceResponse = await getFirmwareHashOptional();
+        if (!((_a = deviceResponse === null || deviceResponse === void 0 ? void 0 : deviceResponse.message) === null || _a === void 0 ? void 0 : _a.hash))
+            return createFailResult('other-error');
+        if (deviceResponse.message.hash !== expectedHash)
+            return createFailResult('hash-mismatch');
+        return { success: true };
+    }
     async checkFirmwareRevision() {
         const firmwareVersion = this.getVersion();
         if (!firmwareVersion || !this.features) {
@@ -421,21 +575,21 @@ class Device extends utils_1.TypedEmitter {
             feat.patch_version,
         ];
         if (!version || !utils_1.versionUtils.isEqual(version, newVersion)) {
-            this.unavailableCapabilities = (0, deviceFeaturesUtils_1.getUnavailableCapabilities)(feat, (0, coinInfo_1.getAllNetworks)());
-            this.firmwareStatus = (0, firmwareInfo_1.getFirmwareStatus)(feat);
-            this.firmwareRelease = (0, firmwareInfo_1.getRelease)(feat);
+            this._unavailableCapabilities = (0, deviceFeaturesUtils_1.getUnavailableCapabilities)(feat, (0, coinInfo_1.getAllNetworks)());
+            this._firmwareStatus = (0, firmwareInfo_1.getFirmwareStatus)(feat);
+            this._firmwareRelease = (0, firmwareInfo_1.getRelease)(feat);
             this.availableTranslations = (_c = (_b = this.firmwareRelease) === null || _b === void 0 ? void 0 : _b.translations) !== null && _c !== void 0 ? _c : [];
         }
-        this.features = feat;
-        this.featuresNeedsReload = false;
+        this._features = feat;
+        this._featuresNeedsReload = false;
         if (feat.fw_vendor === 'Trezor Bitcoin-only') {
-            this.firmwareType = types_1.FirmwareType.BitcoinOnly;
+            this._firmwareType = types_1.FirmwareType.BitcoinOnly;
         }
         else if (feat.fw_vendor === 'Trezor') {
-            this.firmwareType = types_1.FirmwareType.Regular;
+            this._firmwareType = types_1.FirmwareType.Regular;
         }
         else if (this.getMode() !== 'bootloader') {
-            this.firmwareType =
+            this._firmwareType =
                 feat.capabilities &&
                     feat.capabilities.length > 0 &&
                     !feat.capabilities.includes('Capability_Bitcoin_like')
@@ -457,9 +611,15 @@ class Device extends utils_1.TypedEmitter {
     isUnacquired() {
         return this.features === undefined;
     }
+    isUnreadable() {
+        return !!this.unreadableError;
+    }
     disconnect() {
+        var _a;
         _log.debug('Disconnect cleanup');
-        this.transportSession = null;
+        (_a = this.sessionDfd) === null || _a === void 0 ? void 0 : _a.reject(new Error());
+        this.lastAcquiredHere = false;
+        this.emitLifecycle(events_1.DEVICE.DISCONNECT);
         return this.interruptionFromUser(constants_1.ERRORS.TypedError('Device_Disconnected'));
     }
     isBootloader() {
@@ -491,13 +651,13 @@ class Device extends utils_1.TypedEmitter {
         return utils_1.versionUtils.isNewerOrEqual(version, modelVersion);
     }
     isUsed() {
-        return typeof this.originalDescriptor.session === 'string';
+        return typeof this.session === 'string';
     }
     isUsedHere() {
-        return this.isUsed() && this.originalDescriptor.session === this.transportSession;
+        return this.isUsed() && this.lastAcquiredHere;
     }
     isUsedElsewhere() {
-        return this.isUsed() && !this.isUsedHere();
+        return this.isUsed() && !this.lastAcquiredHere;
     }
     isRunning() {
         return !!this.runPromise;
@@ -508,8 +668,11 @@ class Device extends utils_1.TypedEmitter {
     waitForFirstRun() {
         return this.firstRunPromise.promise;
     }
-    getDevicePath() {
-        return this.originalDescriptor.path;
+    getLocalSession() {
+        return this.lastAcquiredHere ? this.session : null;
+    }
+    getUniquePath() {
+        return this.uniquePath;
     }
     isT1() {
         return this.features ? this.features.major_version === 1 : false;
@@ -531,28 +694,20 @@ class Device extends utils_1.TypedEmitter {
         }
         return null;
     }
-    updateDescriptor(descriptor) {
-        this.originalDescriptor = {
-            session: descriptor.session,
-            path: descriptor.path,
-            product: descriptor.product,
-            type: descriptor.type,
-        };
-    }
     async dispose() {
         var _a, _b;
         this.removeAllListeners();
-        if (this.isUsedHere() && this.transportSession) {
+        if (this.session && this.lastAcquiredHere) {
             try {
                 await ((_a = this.cancelableAction) === null || _a === void 0 ? void 0 : _a.call(this));
                 await ((_b = this.commands) === null || _b === void 0 ? void 0 : _b.cancel());
                 return this.transport.release({
-                    session: this.transportSession,
-                    path: this.originalDescriptor.path,
+                    session: this.session,
+                    path: this.transportPath,
                     onClose: true,
                 });
             }
-            catch (err) {
+            catch {
             }
         }
     }
@@ -567,38 +722,40 @@ class Device extends utils_1.TypedEmitter {
     }
     toMessageObject() {
         var _a;
+        const { name, uniquePath: path } = this;
+        const base = { path, name };
         if (this.unreadableError) {
             return {
+                ...base,
                 type: 'unreadable',
-                path: this.originalDescriptor.path,
                 error: this.unreadableError,
                 label: 'Unreadable device',
-                name: this.name,
+                transportDescriptorType: this.transportDescriptorType,
             };
         }
         if (this.isUnacquired()) {
             return {
+                ...base,
                 type: 'unacquired',
-                path: this.originalDescriptor.path,
                 label: 'Unacquired device',
                 name: this.name,
+                transportSessionOwner: this.transportSessionOwner,
             };
         }
         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)
+        if (this._featuresNeedsReload)
             status = 'used';
         return {
+            ...base,
             type: 'acquired',
             id: this.features.device_id,
-            path: this.originalDescriptor.path,
             label,
             _state: this.getState(),
             state: (_a = this.getState()) === null || _a === void 0 ? void 0 : _a.staticSessionId,
             status,
             mode: this.getMode(),
-            name: this.name,
             color: this.color,
             firmware: this.firmwareStatus,
             firmwareRelease: this.firmwareRelease,

package/lib/device/DeviceCommands.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const crypto_1 = require("crypto");
 const protobuf_1 = require("@trezor/protobuf");
 const utils_1 = require("@trezor/utils");
+const schema_utils_1 = require("@trezor/schema-utils");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const hdnodeUtils = tslib_1.__importStar(require("../utils/hdnodeUtils"));
@@ -12,7 +13,6 @@ const pathUtils_1 = require("../utils/pathUtils");
 const accountUtils_1 = require("../utils/accountUtils");
 const coinInfo_1 = require("../data/coinInfo");
 const debug_1 = require("../utils/debug");
-const schema_utils_1 = require("@trezor/schema-utils");
 const resolveDescriptorForTaproot_1 = require("./resolveDescriptorForTaproot");
 const prompts_1 = require("./prompts");
 const logger = (0, debug_1.initLog)('DeviceCommands');
@@ -26,7 +26,7 @@ const generateEntropy = (len) => {
     try {
         return (0, crypto_1.randomBytes)(len);
     }
-    catch (err) {
+    catch {
         throw constants_1.ERRORS.TypedError('Runtime', 'generateEntropy: Environment does not support crypto random');
     }
 };
@@ -236,10 +236,10 @@ class DeviceCommands {
         return response;
     }
     async _commonCall(type, msg) {
-        const resp = await this.call(type, msg);
         if (this.disposed) {
             throw constants_1.ERRORS.TypedError('Runtime', 'typedCall: DeviceCommands already disposed');
         }
+        const resp = await this.call(type, msg);
         return this._filterCommonTypes(resp);
     }
     _filterCommonTypes(res) {
@@ -361,7 +361,7 @@ class DeviceCommands {
                 await this.device.acquire();
                 await (0, prompts_1.cancelPrompt)(this.device, false);
             }
-            catch (err) {
+            catch {
             }
         }
         else {