@trezor/connect 9.2.3 → 9.2.4-beta.1

package/lib/core/onCallFirmwareUpdate.d.ts

@@ -0,0 +1,31 @@
+import { DeviceList } from '../device/DeviceList';
+import { CoreEventMessage } from '../events';
+import { CommonParams } from '../types';
+import type { Log } from '../utils/debug';
+import type { Device } from '../device/Device';
+type PostMessage = (message: CoreEventMessage) => void;
+export type Params = {
+    language?: string;
+    baseUrl?: string;
+    btcOnly?: boolean;
+    binary?: ArrayBuffer;
+} & CommonParams;
+type Context = {
+    deviceList: DeviceList;
+    postMessage: PostMessage;
+    initDevice: (path?: string) => Promise<Device>;
+    log: Log;
+    abortSignal: AbortSignal;
+};
+export declare const onCallFirmwareUpdate: ({ params, context: { deviceList, postMessage, initDevice, log, abortSignal }, }: {
+    params: Params;
+    context: Context;
+}) => Promise<{
+    check: "other-error";
+    checkError: any;
+} | {
+    check: string;
+    checkError?: undefined;
+}>;
+export {};
+//# sourceMappingURL=onCallFirmwareUpdate.d.ts.map

package/lib/core/onCallFirmwareUpdate.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onCallFirmwareUpdate = void 0;
+const crypto_1 = require("crypto");
+const utils_1 = require("@trezor/utils");
+const events_1 = require("../events");
+const firmware_1 = require("../api/firmware");
+const firmwareInfo_1 = require("../data/firmwareInfo");
+const constants_1 = require("../constants");
+const versionUtils_1 = require("@trezor/utils/lib/versionUtils");
+const registerEvents = (device, postMessage) => {
+    device.on(events_1.DEVICE.BUTTON, (_d, request) => {
+        postMessage((0, events_1.createDeviceMessage)(events_1.DEVICE.BUTTON, {
+            code: request.code,
+            device: device.toMessageObject(),
+        }));
+    });
+};
+const waitForReconnectedDevice = async ({ bootloader, method, intermediary }, { deviceList, device, postMessage, log, abortSignal }) => {
+    const target = intermediary || !bootloader ? 'normal' : 'bootloader';
+    let i = 0;
+    if (method !== 'auto') {
+        log.debug('onCallFirmwareUpdate', 'waiting for device to disconnect');
+        postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_RECONNECT, {
+            device: device.toMessageObject(),
+            disconnected: false,
+            method,
+            target,
+            i,
+        }));
+        await new Promise(resolve => {
+            deviceList.once('device-disconnect', resolve);
+        });
+    }
+    log.debug('onCallFirmwareUpdate', `waiting for device to reconnect in ${bootloader ? 'bootloader' : 'normal'} mode`);
+    let reconnectedDevice;
+    do {
+        postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_RECONNECT, {
+            device: device.toMessageObject(),
+            disconnected: true,
+            method,
+            target,
+            i,
+        }));
+        await (0, utils_1.createTimeoutPromise)(2000);
+        try {
+            const path = deviceList.getFirstDevicePath();
+            reconnectedDevice = deviceList.getDevice(path);
+        }
+        catch { }
+        i++;
+        log.debug('onCallFirmwareUpdate', 'waiting for device to reconnect', i);
+    } while (!abortSignal.aborted &&
+        (!(reconnectedDevice === null || reconnectedDevice === void 0 ? void 0 : reconnectedDevice.features) ||
+            bootloader === !reconnectedDevice.features.bootloader_mode ||
+            (intermediary &&
+                !(0, versionUtils_1.isNewer)([
+                    reconnectedDevice.features.major_version,
+                    reconnectedDevice.features.minor_version,
+                    reconnectedDevice.features.patch_version,
+                ], [
+                    device.features.major_version,
+                    device.features.minor_version,
+                    device.features.patch_version,
+                ]))));
+    if (!reconnectedDevice) {
+        throw constants_1.ERRORS.TypedError('Method_Interrupted');
+    }
+    registerEvents(reconnectedDevice, postMessage);
+    await reconnectedDevice.waitForFirstRun();
+    await reconnectedDevice.acquire();
+    return reconnectedDevice;
+};
+const getInstallationParams = (device, binary) => {
+    var _a;
+    if (!device.features.bootloader_mode) {
+        const version = binary ? (0, firmware_1.parseFirmwareHeaders)(Buffer.from(binary)).version : undefined;
+        const isUpdatingToNewerVersion = !version
+            ? (_a = device.firmwareRelease) === null || _a === void 0 ? void 0 : _a.isNewer
+            : (0, versionUtils_1.isNewer)(version, [
+                device.features.major_version,
+                device.features.minor_version,
+                device.features.patch_version,
+            ]);
+        const upgrade = device.atLeast('2.6.3') && isUpdatingToNewerVersion;
+        const manual = !device.atLeast(['1.10.0', '2.6.0']) && !upgrade;
+        const language = device.atLeast('2.7.0');
+        return {
+            manual,
+            upgrade,
+            language,
+        };
+    }
+    else {
+        return {
+            manual: false,
+            upgrade: false,
+            language: false,
+        };
+    }
+};
+const getFwHeader = (binary) => Buffer.from(binary.slice(0, 6000)).toString('hex');
+const getBinaryHelper = (device, params, log, postMessage, intermediaryVersion) => {
+    var _a;
+    if (!device.firmwareRelease) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'device.firmwareRelease is not set');
+    }
+    const btcOnly = params.btcOnly || (params.btcOnly === undefined && device.firmwareType === 'bitcoin-only');
+    log.debug('onCallFirmwareUpdate loading binary', 'intermediaryVersion', intermediaryVersion, 'version', device.firmwareRelease.release.version, 'btcOnly', btcOnly);
+    postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
+        device: device.toMessageObject(),
+        operation: 'downloading',
+        progress: 0,
+    }));
+    return (0, firmware_1.getBinary)({
+        features: device.features,
+        releases: (0, firmwareInfo_1.getReleases)((_a = device.features) === null || _a === void 0 ? void 0 : _a.internal_model),
+        baseUrl: params.baseUrl || 'https://data.trezor.io',
+        version: device.firmwareRelease.release.version,
+        btcOnly,
+        intermediaryVersion,
+    }).then(res => {
+        postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
+            device: device.toMessageObject(),
+            operation: 'downloading',
+            progress: 100,
+        }));
+        return res;
+    });
+};
+const firmwareCheck = async (reconnectedDevice, device, stripped, postMessage) => {
+    postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
+        device: device.toMessageObject(),
+        operation: 'validating',
+        progress: 0,
+    }));
+    const { hash, challenge } = (0, firmware_1.calculateFirmwareHash)(device.features.major_version, stripped, (0, crypto_1.randomBytes)(32));
+    const getFirmwareHashResponse = await reconnectedDevice
+        .getCommands()
+        .typedCall('GetFirmwareHash', 'FirmwareHash', { challenge });
+    postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
+        device: device.toMessageObject(),
+        operation: 'validating',
+        progress: 100,
+    }));
+    return (getFirmwareHashResponse.message !== 'Unknown message' &&
+        getFirmwareHashResponse.message !== 'Unexpected message' &&
+        getFirmwareHashResponse.message.hash === hash);
+};
+const onCallFirmwareUpdate = async ({ params, context: { deviceList, postMessage, initDevice, log, abortSignal }, }) => {
+    var _a;
+    log.debug('onCallFirmwareUpdate with params: ', params);
+    const device = await initDevice((_a = params === null || params === void 0 ? void 0 : params.device) === null || _a === void 0 ? void 0 : _a.path);
+    if (!device.firmwareRelease) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'device.firmwareRelease is not set');
+    }
+    if (deviceList.allDevices().length > 1) {
+        throw constants_1.ERRORS.TypedError('Device_MultipleNotSupported', 'Firmware update allowed with only 1 device connected');
+    }
+    log.debug('onCallFirmwareUpdate', 'device', device);
+    registerEvents(device, postMessage);
+    const { manual, upgrade, language } = getInstallationParams(device, params.binary);
+    log.debug('onCallFirmwareUpdate', 'installation params', { manual, upgrade, language });
+    const binary = params.binary ||
+        (await getBinaryHelper(device, params, log, postMessage, device.firmwareRelease.intermediaryVersion));
+    const deviceInitiallyConnectedInBootloader = device.features.bootloader_mode;
+    const deviceInitiallyConnectedWithoutFirmware = device.features.firmware_present === false;
+    let reconnectedDevice = device;
+    if (deviceInitiallyConnectedInBootloader) {
+        log.warn('onCallFirmwareUpdate', 'device is already in bootloader mode. language will not be updated');
+        await device.acquire();
+    }
+    else if (manual) {
+        reconnectedDevice = await waitForReconnectedDevice({ bootloader: true, method: 'manual' }, { deviceList, device, log, postMessage, abortSignal });
+    }
+    else {
+        const rebootParams = upgrade
+            ? {
+                boot_command: constants_1.PROTO.BootCommand.INSTALL_UPGRADE,
+                firmware_header: getFwHeader(binary),
+            }
+            : {};
+        await device.acquire();
+        const targetLanguage = params.language || device.features.language || 'en-US';
+        const languageBlob = language && targetLanguage !== 'en-US'
+            ? await (0, firmware_1.getLanguage)({
+                language: targetLanguage,
+                version: device.firmwareRelease.release.version,
+                internal_model: device.features.internal_model,
+            })
+            : null;
+        if (!languageBlob) {
+            await device.getCommands().typedCall('RebootToBootloader', 'Success', rebootParams);
+        }
+        else {
+            let rebootResponse = await device.getCommands().typedCall('RebootToBootloader', ['TranslationDataRequest', 'Success'], { ...rebootParams, language_data_length: languageBlob === null || languageBlob === void 0 ? void 0 : languageBlob.byteLength });
+            log.debug('onCallFirmwareUpdate', 'RebootToBootloader response', rebootResponse.message);
+            while (languageBlob && rebootResponse.type !== 'Success') {
+                const start = rebootResponse.message.data_offset;
+                const end = rebootResponse.message.data_offset + rebootResponse.message.data_length;
+                const chunk = languageBlob.slice(start, end);
+                rebootResponse = await device.getCommands().typedCall('TranslationDataAck', ['TranslationDataRequest', 'Success'], { data_chunk: Buffer.from(chunk).toString('hex') });
+            }
+        }
+        await device.release();
+        if (device.features.major_version === 1) {
+            await (0, utils_1.createTimeoutPromise)(2000);
+        }
+        reconnectedDevice = await waitForReconnectedDevice({ bootloader: true, method: 'auto' }, { deviceList, device, log, postMessage, abortSignal });
+    }
+    const intermediary = !params.binary && device.firmwareRelease.intermediaryVersion;
+    await reconnectedDevice.initialize(false, false);
+    let stripped = (0, firmware_1.stripFwHeaders)(binary);
+    await (0, firmware_1.uploadFirmware)(reconnectedDevice.getCommands().typedCall.bind(reconnectedDevice.getCommands()), postMessage, reconnectedDevice, { payload: !intermediary && (0, firmware_1.shouldStripFwHeaders)(device.features) ? stripped : binary });
+    await reconnectedDevice.release();
+    if (intermediary) {
+        reconnectedDevice = await waitForReconnectedDevice({ bootloader: true, method: 'manual', intermediary: true }, { deviceList, device: reconnectedDevice, log, postMessage, abortSignal });
+        stripped = (0, firmware_1.stripFwHeaders)(await getBinaryHelper(reconnectedDevice, params, log, postMessage));
+        await reconnectedDevice.initialize(false, false);
+        await (0, firmware_1.uploadFirmware)(reconnectedDevice.getCommands().typedCall.bind(reconnectedDevice.getCommands()), postMessage, reconnectedDevice, { payload: stripped });
+        await reconnectedDevice.release();
+    }
+    reconnectedDevice = await waitForReconnectedDevice({ bootloader: false, method: 'wait' }, { deviceList, device: reconnectedDevice, log, postMessage, abortSignal });
+    if (reconnectedDevice.atLeast('2.7.0') &&
+        deviceInitiallyConnectedWithoutFirmware &&
+        params.language) {
+        try {
+            log.info('onCallFirmwareUpdate', 'changing language for fresh device to: ', params.language);
+            await reconnectedDevice.changeLanguage({ language: params.language });
+        }
+        catch (err) {
+            log.error('onCallFirmwareUpdate', 'changeLanguage failed silently: ', err);
+        }
+    }
+    const checkSupported = reconnectedDevice.atLeast(['1.11.1', '2.5.1']) && !params.binary;
+    if (checkSupported) {
+        try {
+            log.debug('onCallFirmwareUpdate', 'getFirmwareHash supported, proceed with check', stripped);
+            const isValid = await firmwareCheck(reconnectedDevice, device, stripped, postMessage);
+            await reconnectedDevice.release();
+            if (isValid) {
+                log.debug('onCallFirmwareUpdate', 'installed fw hash and calculated hash match');
+                return { check: 'valid' };
+            }
+            else {
+                return { check: 'mismatch' };
+            }
+        }
+        catch (err) {
+            return { check: 'other-error', checkError: err.message };
+        }
+    }
+    else {
+        await reconnectedDevice.release();
+        return { check: 'omitted' };
+    }
+};
+exports.onCallFirmwareUpdate = onCallFirmwareUpdate;
+//# sourceMappingURL=onCallFirmwareUpdate.js.map

package/lib/data/analyticsInfo.d.ts

@@ -1,6 +1,6 @@
 import { CoreEventMessage } from '../events';
 import type { Device } from '../types';
-export declare const enhancePostMessageWithAnalytics: (callback: (message: CoreEventMessage) => void, message: CoreEventMessage, data: {
+export declare const enhanceMessageWithAnalytics: (message: CoreEventMessage, data: {
     device?: Device;
-}) => void;
+}) => CoreEventMessage;
 //# sourceMappingURL=analyticsInfo.d.ts.map

package/lib/data/analyticsInfo.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enhancePostMessageWithAnalytics = void 0;
+exports.enhanceMessageWithAnalytics = void 0;
 const events_1 = require("../events");
-const enhancePostMessageWithAnalytics = (callback, message, data) => {
+const enhanceMessageWithAnalytics = (message, data) => {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     switch (message.type) {
         case events_1.UI_REQUEST.REQUEST_CONFIRMATION:
             const { device } = data;
-            callback({
+            return {
                 ...message,
                 payload: {
                     ...message.payload,
@@ -27,11 +27,10 @@ const enhancePostMessageWithAnalytics = (callback, message, data) => {
                         },
                     },
                 },
-            });
-            break;
+            };
         default:
-            callback(message);
+            return message;
     }
 };
-exports.enhancePostMessageWithAnalytics = enhancePostMessageWithAnalytics;
+exports.enhanceMessageWithAnalytics = enhanceMessageWithAnalytics;
 //# sourceMappingURL=analyticsInfo.js.map

package/lib/data/deviceAuthenticityConfig.js

@@ -25,7 +25,7 @@ exports.DeviceAuthenticityConfig = schema_utils_1.Type.Intersect([
 ]);
 exports.deviceAuthenticityConfig = {
     version: 1,
-    timestamp: '2023-04-17T12:00:00+00:00',
+    timestamp: '2024-05-10T12:00:00+00:00',
     T2B1: {
         rootPubKeys: [
             '04ca97480ac0d7b1e6efafe518cd433cec2bf8ab9822d76eafd34363b55d63e60380bff20acc75cde03cffcb50ab6f8ce70c878e37ebc58ff7cca0a83b16b15fa5',
@@ -46,6 +46,12 @@ exports.deviceAuthenticityConfig = {
             '04c99f57eaaca8db0245a46dba5288a4c0b0d6acdd1346feef7770ec6b88d28d6640ee19c3f6d984e8fcfceda11b1e4accefda32b950dcd1785fbd16c2e45493a3',
             '049c288f4de8a239be83955ed260f40c1a4126fb7dc513601dde4cb11f7363d6a259e73cb1bd9283a450ae608d1832c5fd0cbd9526c0285e720fa45494cae981fd',
             '04ac1815177cc1f07700e5f18c05522427413f404bacc987eb1cf9d86f96b9e0cc53ef5941eafd483102eea321205d7dd9271ac2d0fca75a9a43deb824b51f1596',
+            '049f91ac8c7dac26fa7eb82ff3fb8c6d24978bbaeed1adb0751342a8c4c88152817d50bd0b4c16d8fb85bf12f46dca0674a398aeecbb3d1a01236cd3eb39d24c55',
+            '04c5225b6d8b84401c408ad0a5aa47888e9087451a2ca4440e46efed5765fd2f5bf8f068e1cfea18dddfc5b47b19076ce0a84fbcf7269f9578d9b978679dea4189',
+            '04e349de85981f8e7d95ca4b44346924a9df62875971cfc5e21fc042c3a8fb3e1ddfeac139c15fcf3f7968242a418fc80e92c98f5aef39672b13b60d0b2335c84c',
+            '04d7ddaf7e17a678bef305950f0f9d74b90553d8502fd02c439f07ac7ea494e9e0519a1c5782bf23be058162e706057d3b241d507f89b9e5518e3696a92128fa6d',
+            '0488cf1dbadb18df0a094da837b3eeb0c85489cc21e7c2b94f8f4df207edccfddbb58e428d9a6ce1e42081c38665d134c7ee6f1f524688ce7444bc1d1340a8b1f1',
+            '04ff0c6e817d7c00a0912cf1d293e4d3a8c25403dca4e8ced5e7323352e34604725ad67739d1b4bf538a3864e95d8311ebc91d522b1603da94061e82535edced56',
         ],
         debug: {
             rootPubKeys: [
@@ -67,12 +73,10 @@ exports.deviceAuthenticityConfig = {
         ],
         debug: {
             rootPubKeys: [
-                '047f77368dea2d4d61e989f474a56723c3212dacf8a808d8795595ef38441427c4389bc454f02089d7f08b873005e4c28d432468997871c0bf286fd3861e21e96a',
+                '04e48b69cd7962068d3cca3bcc6b1747ef496c1e28b5529e34ad7295215ea161dbe8fb08ae0479568f9d2cb07630cb3e52f4af0692102da5873559e45e9fa72959',
             ],
             caPubKeys: [
                 '04829e8965018feb542e9236c9b2ce08f864a55ed9183d0259564f0e05345b04676a0bef36c59d21d3c24868b5601f0b1193a6bfcf6d814e1cfb79c2256a05e953',
-                '046f64eff0dfa3ceeae9708a3881fc09a3dae62198559d022d120e96edc168f3991a9e9b016635a0d43997ee55d8c2b37d969e8abc84e75c791ec911108b52f3c7',
-                '041260c3c1fd4ddfc97ba19732d5dcbe6efab61d58af83281b95d6cdb30606bf08f0b817eb6db2825b5ce32d0cc2c275b7eadcedaa1805f00b3f5a11668b6c5cb5',
             ],
         },
     },

package/lib/data/firmwareInfo.js

@@ -117,7 +117,7 @@ const getInfo = ({ features, releases }) => {
         isRequired: isRequired(changelog),
         isNewer: isNewerResult,
         intermediaryVersion,
-        translations: isNewerResult ? prevRelease.translations : release.translations,
+        translations: isNewerResult ? prevRelease === null || prevRelease === void 0 ? void 0 : prevRelease.translations : release === null || release === void 0 ? void 0 : release.translations,
     };
 };
 exports.getInfo = getInfo;

package/lib/data/version.d.ts

@@ -1,3 +1,3 @@
-export declare const VERSION = "9.2.3";
+export declare const VERSION = "9.2.4-beta.1";
 export declare const DEFAULT_DOMAIN: string;
 //# sourceMappingURL=version.d.ts.map

package/lib/data/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
-exports.VERSION = '9.2.3';
+exports.VERSION = '9.2.4-beta.1';
 const versionN = exports.VERSION.split('.').map(s => parseInt(s, 10));
 exports.DEFAULT_DOMAIN = `https://connect.trezor.io/${versionN[0]}/`;
 //# sourceMappingURL=version.js.map

package/lib/device/Device.d.ts

@@ -102,7 +102,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     getDevicePath(): string;
     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(): import("@trezor/transport/lib/types").AbortableCall<void, "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" | "session not found"> | undefined;
+    dispose(): Promise<import("@trezor/transport/lib/types").AbortableCall<void, "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" | "session not found"> | undefined>;
     getMode(): "normal" | "bootloader" | "initialize" | "seedless";
     toMessageObject(): DeviceTyped;
     legacyForceRelease(): Promise<void>;

package/lib/device/Device.js

@@ -491,12 +491,12 @@ class Device extends utils_1.TypedEmitter {
         }
         return null;
     }
-    dispose() {
+    async dispose() {
         this.removeAllListeners();
         if (this.isUsedHere() && this.activitySessionID) {
             try {
                 if (this.commands) {
-                    this.commands.cancel();
+                    await this.commands.cancel();
                 }
                 return this.transport.release({
                     session: this.activitySessionID,

package/lib/device/DeviceCommands.d.ts

@@ -43,8 +43,8 @@ export declare class DeviceCommands {
         };
         xpub: string;
     }>;
-    getHDNode(params: Messages.GetPublicKey, options?: {
-        coinInfo?: BitcoinNetworkInfo;
+    getHDNode(params: Messages.GetPublicKey, options: {
+        coinInfo: BitcoinNetworkInfo;
         validation?: boolean;
         unlockPath?: Messages.UnlockPath;
     }): Promise<{
@@ -59,18 +59,6 @@ export declare class DeviceCommands {
         childNum: number;
         xpub: string;
     }>;
-    getBitcoinHDNode(path: number[], coinInfo?: BitcoinNetworkInfo, validation?: boolean): Promise<{
-        xpubSegwit?: string | undefined;
-        descriptorChecksum?: string | undefined;
-        path: number[];
-        publicKey: string;
-        serializedPath: string;
-        depth: number;
-        fingerprint: number;
-        chainCode: string;
-        childNum: number;
-        xpub: string;
-    }>;
     getAddress({ address_n, show_display, multisig, script_type, chunkify }: Messages.GetAddress, coinInfo: BitcoinNetworkInfo): Promise<{
         path: number[];
         serializedPath: string;

package/lib/device/DeviceCommands.js

@@ -67,13 +67,10 @@ class DeviceCommands {
         });
         return response.message;
     }
-    async getHDNode(params, options = {}) {
+    async getHDNode(params, options) {
         const path = params.address_n;
         const { coinInfo, unlockPath } = options;
         const validation = typeof options.validation === 'boolean' ? options.validation : true;
-        if (!this.device.atLeast(['1.7.2', '2.0.10']) || !coinInfo) {
-            return this.getBitcoinHDNode(path, coinInfo);
-        }
         let network = null;
         if (!params.script_type) {
             params.script_type = (0, pathUtils_1.getScriptType)(path);
@@ -125,42 +122,6 @@ class DeviceCommands {
         }
         return response;
     }
-    async getBitcoinHDNode(path, coinInfo, validation = true) {
-        let publicKey;
-        if (!validation) {
-            publicKey = await this.getPublicKey({ address_n: path });
-        }
-        else {
-            const suffix = 0;
-            const childPath = path.concat([suffix]);
-            const resKey = await this.getPublicKey({ address_n: path });
-            const childKey = await this.getPublicKey({ address_n: childPath });
-            publicKey = hdnodeUtils.xpubDerive(resKey, childKey, suffix);
-        }
-        const response = {
-            path,
-            serializedPath: (0, pathUtils_1.getSerializedPath)(path),
-            childNum: publicKey.node.child_num,
-            xpub: coinInfo
-                ? hdnodeUtils.convertBitcoinXpub(publicKey.xpub, coinInfo.network)
-                : publicKey.xpub,
-            chainCode: publicKey.node.chain_code,
-            publicKey: publicKey.node.public_key,
-            fingerprint: publicKey.node.fingerprint,
-            depth: publicKey.node.depth,
-        };
-        if (coinInfo) {
-            const bech32Network = (0, coinInfo_1.getBech32Network)(coinInfo);
-            const segwitNetwork = (0, coinInfo_1.getSegwitNetwork)(coinInfo);
-            if (bech32Network && (0, pathUtils_1.isBech32Path)(path)) {
-                response.xpubSegwit = hdnodeUtils.convertBitcoinXpub(publicKey.xpub, bech32Network);
-            }
-            else if (segwitNetwork && (0, pathUtils_1.isSegwitPath)(path)) {
-                response.xpubSegwit = hdnodeUtils.convertBitcoinXpub(publicKey.xpub, segwitNetwork);
-            }
-        }
-        return response;
-    }
     async getAddress({ address_n, show_display, multisig, script_type, chunkify }, coinInfo) {
         if (!script_type) {
             script_type = (0, pathUtils_1.getScriptType)(address_n);
@@ -203,9 +164,6 @@ class DeviceCommands {
         };
     }
     async ethereumGetPublicKey({ address_n, show_display, }) {
-        if (!this.device.atLeast(['1.8.1', '2.1.0'])) {
-            return this.getHDNode({ address_n });
-        }
         const suffix = 0;
         const childPath = address_n.concat([suffix]);
         const resKey = await this.typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {

package/lib/device/DeviceList.d.ts

@@ -42,7 +42,7 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
     length(): number;
     transportType(): "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport";
     getTransportInfo(): TransportInfo;
-    dispose(): Promise<void>;
+    dispose(): void;
     disconnectDevices(): void;
     enumerate(): Promise<void>;
     addAuthPenalty(device: Device): void;

package/lib/device/DeviceList.js

@@ -90,14 +90,24 @@ class DeviceList extends utils_1.TypedEmitter {
                 return;
             }
             this.transport.on(transport_1.TRANSPORT.UPDATE, diff => {
+                diff.disconnected.forEach(descriptor => {
+                    const path = descriptor.path.toString();
+                    const device = this.devices[path];
+                    if (device) {
+                        device.disconnect();
+                        delete this.devices[path];
+                        this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
+                    }
+                });
                 diff.connected.forEach(async (descriptor) => {
                     const path = descriptor.path.toString();
+                    this.creatingDevicesDescriptors[path] = descriptor;
                     const priority = DataManager_1.DataManager.getSettings('priority');
                     const penalty = this.getAuthPenalty();
                     if (priority || penalty) {
                         await (0, promiseUtils_1.resolveAfter)(501 + penalty + 100 * priority, null).promise;
                     }
-                    if (descriptor.session == null) {
+                    if (this.creatingDevicesDescriptors[path].session == null) {
                         await this._createAndSaveDevice(descriptor);
                     }
                     else {
@@ -158,20 +168,13 @@ class DeviceList extends utils_1.TypedEmitter {
                         }
                     });
                 });
-                diff.disconnected.forEach(descriptor => {
-                    const path = descriptor.path.toString();
-                    const device = this.devices[path];
-                    if (device) {
-                        device.disconnect();
-                        delete this.devices[path];
-                        this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
-                    }
-                });
                 diff.descriptors.forEach(d => {
+                    this.creatingDevicesDescriptors[d.path] = d;
                     if (this.devices[d.path]) {
                         this.devices[d.path].originalDescriptor = {
                             session: d.session,
                             path: d.path,
+                            product: d.product,
                         };
                     }
                 });
@@ -265,13 +268,14 @@ class DeviceList extends utils_1.TypedEmitter {
             outdated: this.transport.isOutdated,
         };
     }
-    async dispose() {
+    dispose() {
         this.removeAllListeners();
         if (autoResolveTransportEventTimeout) {
             clearTimeout(autoResolveTransportEventTimeout);
         }
-        await Promise.all(this.allDevices().map(device => device.dispose()));
-        this.transport.stop();
+        Promise.all(this.allDevices().map(device => device.dispose())).then(() => {
+            this.transport.stop();
+        });
     }
     disconnectDevices() {
         this.allDevices().forEach(device => {
@@ -288,6 +292,7 @@ class DeviceList extends utils_1.TypedEmitter {
                 this.devices[d.path].originalDescriptor = {
                     session: d.session,
                     path: d.path,
+                    product: d.product,
                 };
                 this.devices[d.path].activitySessionID = d.session;
             }
@@ -315,7 +320,6 @@ class DeviceList extends utils_1.TypedEmitter {
     async handle(descriptor) {
         var _a;
         const path = descriptor.path.toString();
-        this.creatingDevicesDescriptors[path] = descriptor;
         try {
             await this._takeAndCreateDevice(descriptor);
         }
@@ -324,7 +328,8 @@ class DeviceList extends utils_1.TypedEmitter {
             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.UNEXPECTED_ERROR ||
+                error.message === transport_1.TRANSPORT_ERROR.HTTP_ERROR) {
                 delete this.devices[path];
             }
             else if (error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS) {

package/lib/events/index.d.ts

@@ -33,6 +33,7 @@ export declare const UI: {
     readonly FIRMWARE_NOT_COMPATIBLE: "ui-device_firmware_not_compatible";
     readonly FIRMWARE_NOT_INSTALLED: "ui-device_firmware_not_installed";
     readonly FIRMWARE_PROGRESS: "ui-firmware-progress";
+    readonly FIRMWARE_RECONNECT: "ui-firmware_reconnect";
     readonly DEVICE_NEEDS_BACKUP: "ui-device_needs_backup";
     readonly REQUEST_UI_WINDOW: "ui-request_window";
     readonly CLOSE_UI_WINDOW: "ui-close_window";