@trezor/connect 9.3.0 → 9.3.1-beta.2

package/lib/api/getFeatures.d.ts

@@ -15,6 +15,7 @@ export default class GetFeatures extends AbstractMethod<'getFeatures'> {
         language_version_matches?: boolean | undefined;
         unit_packaging?: number | undefined;
         recovery_type?: "NormalRecovery" | "DryRun" | "UnlockRepeatedBackup" | undefined;
+        optiga_sec?: number | undefined;
         flags: number | null;
         language: string | null;
         label: string | null;

package/lib/backend/Blockchain.js

@@ -22,6 +22,15 @@ const getWorker = (type) => {
             return null;
     }
 };
+const getNormalizedShortcut = (shortcut) => {
+    if (shortcut === 'tXRP') {
+        return 'XRP';
+    }
+    if (shortcut.toLowerCase() === 'bsc') {
+        return 'bnb';
+    }
+    return shortcut;
+};
 class Blockchain {
     constructor(options) {
         this.feeForBlock = [];
@@ -72,7 +81,7 @@ class Blockchain {
             throw constants_1.ERRORS.TypedError('Backend_Error', error.message);
         }
         this.serverInfo = info;
-        const shortcut = this.coinInfo.shortcut === 'tXRP' ? 'XRP' : this.coinInfo.shortcut;
+        const shortcut = getNormalizedShortcut(this.coinInfo.shortcut);
         if (info.shortcut.toLowerCase() !== shortcut.toLowerCase()) {
             throw constants_1.ERRORS.TypedError('Backend_Invalid');
         }

package/lib/core/AbstractMethod.js

@@ -11,6 +11,7 @@ exports.DEFAULT_FIRMWARE_RANGE = {
     T1B1: { min: '1.0.0', max: '0' },
     T2T1: { min: '2.0.0', max: '0' },
     T2B1: { min: '2.6.1', max: '0' },
+    T3B1: { min: '2.8.1', max: '0' },
     T3T1: { min: '2.7.1', max: '0' },
 };
 class AbstractMethod {

package/lib/core/index.d.ts

@@ -14,9 +14,9 @@ export declare class Core extends EventEmitter {
     init(settings: ConnectSettings, onCoreEvent: (message: CoreEventMessage) => void, logWriterFactory?: () => LogWriter | undefined): Promise<void>;
 }
 export declare const initCoreState: () => {
-    getOrInitCore: (settings: ConnectSettings, onCoreEvent: (message: CoreEventMessage) => void, logWriterFactory?: (() => LogWriter | undefined) | undefined) => Promise<Core>;
-    getCore: () => Core | undefined;
-    getInitPromise: () => Promise<Core> | undefined;
+    get: () => Core | undefined;
+    getPending: () => Promise<Core> | undefined;
+    getOrInit: (settings: ConnectSettings, onCoreEvent: (message: CoreEventMessage) => void, logWriterFactory?: (() => LogWriter) | undefined) => Promise<Core>;
     dispose: () => void;
 };
 //# sourceMappingURL=index.d.ts.map

package/lib/core/index.js

@@ -20,12 +20,11 @@ const debug_1 = require("../utils/debug");
 const BlockchainLink_1 = require("../backend/BlockchainLink");
 const interactionTimeout_1 = require("../utils/interactionTimeout");
 const onCallFirmwareUpdate_1 = require("./onCallFirmwareUpdate");
-const coreManager_1 = require("./coreManager");
 let _core;
 let _deviceList;
 const _callMethods = [];
 let _interactionTimeout;
-let _deviceListInitTimeout;
+let _deviceListInitReject;
 let _overridePromise;
 const methodSynchronize = (0, utils_2.getSynchronize)();
 let waitForFirstMethod = (0, utils_1.createDeferred)();
@@ -52,13 +51,8 @@ const interactionTimeout = () => _interactionTimeout.start(() => {
 });
 const uiPromises = (0, uiPromiseManager_1.createUiPromiseManager)(interactionTimeout);
 const initDevice = async (devicePath) => {
-    if (!_deviceList) {
-        throw constants_1.ERRORS.TypedError('Transport_Missing');
-    }
-    await _deviceList.transportFirstEventPromise;
-    if (!_deviceList) {
-        throw constants_1.ERRORS.TypedError('Transport_Missing');
-    }
+    await _deviceList.pendingConnection();
+    _deviceList.assertConnected();
     const isWebUsb = _deviceList.transportType() === 'WebUsbTransport';
     let device;
     let showDeviceSelection = isWebUsb;
@@ -92,9 +86,7 @@ const initDevice = async (devicePath) => {
     if (showDeviceSelection) {
         uiPromises.create(events_2.UI.RECEIVE_DEVICE);
         await waitForPopup();
-        if (!_deviceList) {
-            throw constants_1.ERRORS.TypedError('Transport_Missing');
-        }
+        _deviceList.assertConnected();
         const devices = _deviceList.asArray();
         if (devices.length === 1 &&
             devices[0].type !== 'unreadable' &&
@@ -124,6 +116,9 @@ const initDevice = async (devicePath) => {
             }
         }
     }
+    else if (uiPromises.exists(events_2.UI.RECEIVE_DEVICE)) {
+        await uiPromises.get(events_2.UI.RECEIVE_DEVICE);
+    }
     if (!device) {
         throw constants_1.ERRORS.TypedError('Device_NotFound');
     }
@@ -246,7 +241,7 @@ const inner = async (method, device) => {
                     const uiResp = await uiPromise.promise;
                     if (uiResp.payload) {
                         device.setInternalState(undefined);
-                        await device.initialize(method.useEmptyPassphrase, method.useCardanoDerivation);
+                        await device.initialize(method.useCardanoDerivation);
                         invalidDeviceState = await getInvalidDeviceState(device, method.preauthorized);
                     }
                     else {
@@ -333,8 +328,10 @@ const onCall = async (message) => {
         postMessage(messageResponse);
         return Promise.resolve();
     }
-    if (!_deviceList && !DataManager_1.DataManager.getSettings('transportReconnect')) {
-        await initDeviceList(false);
+    if (!_deviceList.isConnected() && !_deviceList.pendingConnection()) {
+        const { transports, pendingTransportEvent } = DataManager_1.DataManager.getSettings();
+        _deviceList.setTransports(transports);
+        await _deviceList.init({ pendingTransportEvent });
     }
     if (method.isManagementRestricted()) {
         postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
@@ -429,17 +426,17 @@ const onCall = async (message) => {
         });
         await device.run(innerAction, {
             keepSession: method.keepSession,
-            useEmptyPassphrase: method.useEmptyPassphrase,
             skipFinalReload: method.skipFinalReload,
             useCardanoDerivation: method.useCardanoDerivation,
         });
     }
     catch (error) {
-        if (_deviceList && error.code === 'Device_Disconnected') {
+        if (error.code === 'Device_Disconnected') {
             _deviceList.addAuthPenalty(device);
         }
         if (method) {
-            if (_deviceList && error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS) {
+            if (_deviceList.isConnected() &&
+                error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS) {
                 await _deviceList.enumerate();
             }
             messageResponse = (0, events_2.createResponseMessage)(method.responseID, false, { error });
@@ -468,10 +465,8 @@ const onCall = async (message) => {
             if (method) {
                 method.dispose();
             }
-            if (_deviceList) {
-                if (response.success) {
-                    _deviceList.removeAuthPenalty(device);
-                }
+            if (response.success) {
+                _deviceList.removeAuthPenalty(device);
             }
             if (!useCoreInPopup) {
                 postMessage(response);
@@ -543,7 +538,7 @@ const onPopupClosed = (customErrorMessage) => {
     const error = customErrorMessage
         ? constants_1.ERRORS.TypedError('Method_Cancel', customErrorMessage)
         : constants_1.ERRORS.TypedError('Method_Interrupted');
-    if (_deviceList && _deviceList.asArray().length > 0) {
+    if (_deviceList.isConnected() && _deviceList.asArray().length > 0) {
         _deviceList.allDevices().forEach(d => {
             d.keepSession = false;
             if (d.isUsedHere()) {
@@ -569,7 +564,7 @@ const onPopupClosed = (customErrorMessage) => {
 };
 const handleDeviceSelectionChanges = (interruptDevice) => {
     const promiseExists = uiPromises.exists(events_2.UI.RECEIVE_DEVICE);
-    if (promiseExists && _deviceList) {
+    if (promiseExists && _deviceList.isConnected()) {
         const list = _deviceList.asArray();
         const isWebUsb = _deviceList.transportType() === 'WebUsbTransport';
         if (list.length === 1 && !isWebUsb) {
@@ -594,62 +589,29 @@ const handleDeviceSelectionChanges = (interruptDevice) => {
         }
     }
 };
-const initDeviceList = async (transportReconnect) => {
-    try {
-        _deviceList = new DeviceList_1.DeviceList({
-            settings: DataManager_1.DataManager.getSettings(),
-            messages: DataManager_1.DataManager.getProtobufMessages(),
-        });
-        _deviceList.on(events_2.DEVICE.CONNECT, device => {
-            handleDeviceSelectionChanges();
-            postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT, device));
-        });
-        _deviceList.on(events_2.DEVICE.CONNECT_UNACQUIRED, device => {
-            handleDeviceSelectionChanges();
-            postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT_UNACQUIRED, device));
-        });
-        _deviceList.on(events_2.DEVICE.DISCONNECT, device => {
-            handleDeviceSelectionChanges(device);
-            postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.DISCONNECT, device));
-        });
-        _deviceList.on(events_2.DEVICE.CHANGED, device => {
-            postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device));
-        });
-        _deviceList.on(transport_1.TRANSPORT.ERROR, error => {
-            _log.warn('TRANSPORT.ERROR', error);
-            if (_deviceList) {
-                _deviceList.disconnectDevices();
-                _deviceList.dispose();
-            }
-            _deviceList = undefined;
-            postMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, { error }));
-            if (transportReconnect) {
-                const { promise, timeout } = (0, promiseUtils_1.resolveAfter)(1000, null);
-                _deviceListInitTimeout = timeout;
-                promise.then(() => {
-                    initDeviceList(transportReconnect);
-                });
-            }
-        });
-        _deviceList.on(transport_1.TRANSPORT.START, transportType => postMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.START, transportType)));
-        _deviceList.init();
-        if (_deviceList) {
-            await _deviceList.waitForTransportFirstEvent();
-        }
-    }
-    catch (error) {
-        _deviceList = undefined;
+const createDeviceList = (params) => {
+    const deviceList = new DeviceList_1.DeviceList(params);
+    deviceList.on(events_2.DEVICE.CONNECT, device => {
+        handleDeviceSelectionChanges();
+        postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT, device));
+    });
+    deviceList.on(events_2.DEVICE.CONNECT_UNACQUIRED, device => {
+        handleDeviceSelectionChanges();
+        postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT_UNACQUIRED, device));
+    });
+    deviceList.on(events_2.DEVICE.DISCONNECT, device => {
+        handleDeviceSelectionChanges(device);
+        postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.DISCONNECT, device));
+    });
+    deviceList.on(events_2.DEVICE.CHANGED, device => {
+        postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device));
+    });
+    deviceList.on(transport_1.TRANSPORT.START, transportType => postMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.START, transportType)));
+    deviceList.on(transport_1.TRANSPORT.ERROR, error => {
+        _log.warn('TRANSPORT.ERROR', error);
         postMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, { error }));
-        if (!transportReconnect) {
-            throw error;
-        }
-        else {
-            const { promise, timeout } = (0, promiseUtils_1.resolveAfter)(3000, null);
-            _deviceListInitTimeout = timeout;
-            await promise;
-            await initDeviceList(transportReconnect);
-        }
-    }
+    });
+    return deviceList;
 };
 class Core extends events_1.default {
     constructor() {
@@ -670,7 +632,12 @@ class Core extends events_1.default {
                 disableWebUSBTransport();
                 break;
             case transport_1.TRANSPORT.REQUEST_DEVICE:
-                _deviceList === null || _deviceList === void 0 ? void 0 : _deviceList.enumerate();
+                if (_deviceList.isConnected()) {
+                    _deviceList.enumerate();
+                }
+                break;
+            case transport_1.TRANSPORT.GET_INFO:
+                postMessage((0, events_2.createResponseMessage)(message.id, true, this.getTransportInfo()));
                 break;
             case events_2.UI.RECEIVE_DEVICE:
             case events_2.UI.RECEIVE_CONFIRMATION:
@@ -686,6 +653,7 @@ class Core extends events_1.default {
                 break;
             case events_2.IFRAME.CALL:
                 if (message.payload.method === 'firmwareUpdate') {
+                    _deviceList.assertConnected();
                     (0, onCallFirmwareUpdate_1.onCallFirmwareUpdate)({
                         params: message.payload,
                         context: {
@@ -713,30 +681,24 @@ class Core extends events_1.default {
     }
     dispose() {
         (0, BlockchainLink_1.dispose)();
-        if (_deviceListInitTimeout) {
-            clearTimeout(_deviceListInitTimeout);
-        }
+        _deviceListInitReject === null || _deviceListInitReject === void 0 ? void 0 : _deviceListInitReject(new Error('Disposed during initialization'));
         this.removeAllListeners();
         this.abortController.abort();
-        if (_deviceList) {
-            _deviceList.dispose();
-        }
+        _deviceList.dispose();
     }
     async getCurrentMethod() {
         await waitForFirstMethod.promise;
         return await methodSynchronize(() => _callMethods[0]);
     }
     getTransportInfo() {
-        if (!_deviceList) {
-            return undefined;
+        if (_deviceList.isConnected()) {
+            return _deviceList.getTransportInfo();
         }
-        return _deviceList.getTransportInfo();
     }
     enumerate() {
-        if (!_deviceList) {
-            return;
+        if (_deviceList.isConnected()) {
+            _deviceList.enumerate();
         }
-        _deviceList.enumerate();
     }
     async init(settings, onCoreEvent, logWriterFactory) {
         if (logWriterFactory) {
@@ -744,8 +706,11 @@ class Core extends events_1.default {
         }
         try {
             await DataManager_1.DataManager.load(settings);
-            (0, debug_1.enableLog)(DataManager_1.DataManager.getSettings('debug'));
+            const { debug, priority } = DataManager_1.DataManager.getSettings();
+            const messages = DataManager_1.DataManager.getProtobufMessages();
+            (0, debug_1.enableLog)(debug);
             _core = this;
+            _deviceList = createDeviceList({ debug, messages, priority });
             _interactionTimeout = new interactionTimeout_1.InteractionTimeout(settings.popup ? settings.interactionTimeout : 0);
             this.on(events_2.CORE_EVENT, onCoreEvent);
         }
@@ -753,46 +718,63 @@ class Core extends events_1.default {
             _log.error('init', error);
             throw error;
         }
+        const { transports, pendingTransportEvent, transportReconnect, coreMode } = DataManager_1.DataManager.getSettings();
         try {
-            if (!DataManager_1.DataManager.getSettings('transportReconnect')) {
-                await initDeviceList(false);
-            }
-            else {
-                initDeviceList(true);
-            }
+            _deviceList.setTransports(transports);
         }
         catch (error) {
-            _log.error('initTransport', error);
+            _log.error('setTransports', error);
+            postMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, { error }));
             throw error;
         }
+        _deviceList.init({ pendingTransportEvent, transportReconnect });
+        if (!transportReconnect || coreMode === 'auto') {
+            await _deviceList.pendingConnection();
+        }
     }
 }
 exports.Core = Core;
 const disableWebUSBTransport = async () => {
-    var _a;
-    if (!_deviceList)
+    if (!_deviceList.isConnected())
         return;
     if (_deviceList.transportType() !== 'WebUsbTransport')
         return;
-    const settings = DataManager_1.DataManager.getSettings();
-    if (settings.transports) {
-        const transportStr = (_a = settings.transports) === null || _a === void 0 ? void 0 : _a.filter(transport => typeof transport !== 'object');
+    const { transports, pendingTransportEvent, transportReconnect } = DataManager_1.DataManager.getSettings();
+    if (transports) {
+        const transportStr = transports === null || transports === void 0 ? void 0 : transports.filter(transport => typeof transport !== 'object');
         if (transportStr.includes('WebUsbTransport')) {
-            settings.transports.splice(settings.transports.indexOf('WebUsbTransport'), 1);
+            transports.splice(transports.indexOf('WebUsbTransport'), 1);
         }
         if (!transportStr.includes('BridgeTransport')) {
-            settings.transports.unshift('BridgeTransport');
+            transports.unshift('BridgeTransport');
         }
     }
     try {
-        _deviceList.dispose();
-        await initDeviceList(settings.transportReconnect);
+        _deviceList.cleanup();
+        _deviceList.setTransports(transports);
+        await _deviceList.init({ pendingTransportEvent, transportReconnect });
     }
     catch (error) {
+        postMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, { error }));
     }
 };
-const initCoreState = () => {
-    return (0, coreManager_1.initCoreManager)(new Core());
+const initCore = async (settings, onCoreEvent, logWriterFactory) => {
+    const core = new Core();
+    let promise;
+    const eventThrottle = (...args) => promise
+        .then(() => {
+        setTimeout(() => onCoreEvent(...args), 0);
+    })
+        .catch(() => { });
+    promise = core.init(settings, eventThrottle, logWriterFactory);
+    await promise;
+    core.on(events_2.CORE_EVENT, onCoreEvent);
+    core.off(events_2.CORE_EVENT, eventThrottle);
+    return core;
+};
+const disposeCore = (core) => {
+    core.dispose();
 };
+const initCoreState = () => (0, utils_1.createLazy)(initCore, disposeCore);
 exports.initCoreState = initCoreState;
 //# sourceMappingURL=index.js.map

package/lib/core/onCallFirmwareUpdate.js

@@ -71,24 +71,29 @@ const waitForReconnectedDevice = async ({ bootloader, method, intermediary }, {
     await reconnectedDevice.acquire();
     return reconnectedDevice;
 };
-const getInstallationParams = (device, binary) => {
-    var _a;
+const getInstallationParams = (device, params) => {
+    var _a, _b;
+    const btcOnly = (_a = params.btcOnly) !== null && _a !== void 0 ? _a : device.firmwareType === 'bitcoin-only';
     if (!device.features.bootloader_mode) {
-        const version = binary ? (0, firmware_1.parseFirmwareHeaders)(Buffer.from(binary)).version : undefined;
+        const version = params.binary
+            ? (0, firmware_1.parseFirmwareHeaders)(Buffer.from(params.binary)).version
+            : undefined;
         const isUpdatingToNewerVersion = !version
-            ? (_a = device.firmwareRelease) === null || _a === void 0 ? void 0 : _a.isNewer
+            ? (_b = device.firmwareRelease) === null || _b === void 0 ? void 0 : _b.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 isUpdatingToEqualFirmwareType = (device.firmwareType === 'bitcoin-only') === btcOnly;
+        const upgrade = device.atLeast('2.6.3') && isUpdatingToNewerVersion && isUpdatingToEqualFirmwareType;
         const manual = !device.atLeast(['1.10.0', '2.6.0']) && !upgrade;
         const language = device.atLeast('2.7.0');
         return {
             manual,
             upgrade,
             language,
+            btcOnly,
         };
     }
     else {
@@ -96,23 +101,23 @@ const getInstallationParams = (device, binary) => {
             manual: false,
             upgrade: false,
             language: false,
+            btcOnly,
         };
     }
 };
 const getFwHeader = (binary) => Buffer.from(binary.slice(0, 6000)).toString('hex');
-const getBinaryHelper = (device, params, log, postMessage, intermediaryVersion) => {
+const getBinaryHelper = (device, params, log, postMessage, btcOnly, 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)({
+    return (0, firmware_1.getBinaryForFirmwareUpgrade)({
         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',
@@ -166,10 +171,15 @@ const onCallFirmwareUpdate = async ({ params, context: { deviceList, postMessage
     }
     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 { manual, upgrade, language, btcOnly } = getInstallationParams(device, params);
+    log.debug('onCallFirmwareUpdate', 'installation params', {
+        manual,
+        upgrade,
+        language,
+        btcOnly,
+    });
     const binary = params.binary ||
-        (await getBinaryHelper(device, params, log, postMessage, device.firmwareRelease.intermediaryVersion));
+        (await getBinaryHelper(device, params, log, postMessage, btcOnly, device.firmwareRelease.intermediaryVersion));
     const deviceInitiallyConnectedInBootloader = device.features.bootloader_mode;
     const deviceInitiallyConnectedWithoutFirmware = device.features.firmware_present === false;
     let reconnectedDevice = device;
@@ -194,6 +204,7 @@ const onCallFirmwareUpdate = async ({ params, context: { deviceList, postMessage
                 language: targetLanguage,
                 version: device.firmwareRelease.release.version,
                 internal_model: device.features.internal_model,
+            }).catch(() => {
             })
             : null;
         if (!languageBlob) {
@@ -216,14 +227,14 @@ const onCallFirmwareUpdate = async ({ params, context: { deviceList, postMessage
         reconnectedDevice = await waitForReconnectedDevice({ bootloader: true, method: 'auto' }, { deviceList, device, log, postMessage, abortSignal });
     }
     const intermediary = !params.binary && device.firmwareRelease.intermediaryVersion;
-    await reconnectedDevice.initialize(false, false);
+    await reconnectedDevice.initialize(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);
+        stripped = (0, firmware_1.stripFwHeaders)(await getBinaryHelper(reconnectedDevice, params, log, postMessage, btcOnly));
+        await reconnectedDevice.initialize(false);
         await (0, firmware_1.uploadFirmware)(reconnectedDevice.getCommands().typedCall.bind(reconnectedDevice.getCommands()), postMessage, reconnectedDevice, { payload: stripped });
         await reconnectedDevice.release();
     }

package/lib/data/DataManager.d.ts

@@ -74,6 +74,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1?: undefined;
+                T3B1?: undefined;
                 T3T1?: undefined;
             };
             max: undefined;
@@ -85,6 +86,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1?: undefined;
+                T3B1?: undefined;
                 T3T1?: undefined;
             };
             comment: string[];
@@ -97,6 +99,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1?: undefined;
+                T3B1?: undefined;
                 T3T1?: undefined;
             };
             comment: string[];
@@ -109,6 +112,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1?: undefined;
+                T3B1?: undefined;
                 T3T1?: undefined;
             };
             comment: string[];
@@ -122,6 +126,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1?: undefined;
+                T3B1?: undefined;
                 T3T1?: undefined;
             };
             comment: string[];
@@ -134,6 +139,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1?: undefined;
+                T3B1?: undefined;
                 T3T1?: undefined;
             };
             coin?: undefined;
@@ -145,6 +151,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1: string;
+                T3B1?: undefined;
                 T3T1?: undefined;
             };
             comment: string[];
@@ -157,6 +164,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1?: undefined;
+                T3B1?: undefined;
                 T3T1?: undefined;
             };
             coin?: undefined;
@@ -169,6 +177,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1: string;
+                T3B1?: undefined;
                 T3T1?: undefined;
             };
             coin?: undefined;
@@ -181,6 +190,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1: string;
+                T3B1?: undefined;
                 T3T1?: undefined;
             };
             comment: string[];
@@ -193,6 +203,7 @@ export declare class DataManager {
                 T1B1: string;
                 T2T1: string;
                 T2B1: string;
+                T3B1: string;
                 T3T1: string;
             };
             coin?: undefined;

package/lib/data/DataManager.js

@@ -22,7 +22,7 @@ class DataManager {
         (0, transportInfo_1.parseBridgeJSON)(this.assets.bridge);
         (0, coinInfo_1.parseCoinsJson)({
             ...this.assets.coins,
-            eth: this.assets.coinsEth,
+            ...this.assets.coinsEth,
         });
         for (const model in types_1.DeviceModelInternal) {
             const firmwareKey = `firmware-${model.toLowerCase()}`;