@trezor/connect 9.3.1-beta.1 → 9.3.1-beta.3

package/lib/core/index.js

@@ -20,52 +20,26 @@ const debug_1 = require("../utils/debug");
 const BlockchainLink_1 = require("../backend/BlockchainLink");
 const interactionTimeout_1 = require("../utils/interactionTimeout");
 const onCallFirmwareUpdate_1 = require("./onCallFirmwareUpdate");
-let _core;
-let _deviceList;
-const _callMethods = [];
-let _interactionTimeout;
-let _deviceListInitTimeout;
-let _overridePromise;
-const methodSynchronize = (0, utils_2.getSynchronize)();
-let waitForFirstMethod = (0, utils_1.createDeferred)();
 const _log = (0, debug_1.initLog)('Core');
-const postMessage = (message) => {
-    if (message.event === events_2.RESPONSE_EVENT) {
-        const index = _callMethods.findIndex(call => call && call.responseID === message.id);
-        if (index >= 0) {
-            _callMethods.splice(index, 1);
-            if (_callMethods.length === 0) {
-                waitForFirstMethod = (0, utils_1.createDeferred)();
-            }
-        }
-    }
-    _core.emit(events_2.CORE_EVENT, message);
-};
-const popupPromise = (0, popupPromiseManager_1.createPopupPromiseManager)();
-const waitForPopup = () => {
-    postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_UI_WINDOW));
+const waitForPopup = ({ popupPromise, sendCoreMessage }) => {
+    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_UI_WINDOW));
     return popupPromise.wait();
 };
-const interactionTimeout = () => _interactionTimeout.start(() => {
-    onPopupClosed('Interaction timeout');
+const startInteractionTimeout = (context) => context.interactionTimeout.start(() => {
+    onPopupClosed(context, 'Interaction timeout');
 });
-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');
-    }
-    const isWebUsb = _deviceList.transportType() === 'WebUsbTransport';
+const initDevice = async (context, devicePath) => {
+    const { uiPromises, deviceList, sendCoreMessage } = context;
+    await deviceList.pendingConnection();
+    (0, DeviceList_1.assertDeviceListConnected)(deviceList);
+    const isWebUsb = deviceList.transportType() === 'WebUsbTransport';
     let device;
     let showDeviceSelection = isWebUsb;
     const isUsingPopup = DataManager_1.DataManager.getSettings('popup');
     const origin = DataManager_1.DataManager.getSettings('origin');
     const useCoreInPopup = DataManager_1.DataManager.getSettings('useCoreInPopup');
     const { preferredDevice } = connect_common_1.storage.load().origin[origin] || {};
-    const preferredDeviceInList = preferredDevice && _deviceList.getDevice(preferredDevice.path);
+    const preferredDeviceInList = preferredDevice && deviceList.getDevice(preferredDevice.path);
     if (preferredDevice && !preferredDeviceInList) {
         connect_common_1.storage.save(store => {
             store.origin[origin] = { ...store.origin[origin], preferredDevice: undefined };
@@ -73,14 +47,14 @@ const initDevice = async (devicePath) => {
         });
     }
     if (devicePath) {
-        device = _deviceList.getDevice(devicePath);
+        device = deviceList.getDevice(devicePath);
         showDeviceSelection =
             !device || !!(device === null || device === void 0 ? void 0 : device.unreadableError) || (device.isUnacquired() && !!isUsingPopup);
     }
     else {
-        const devices = _deviceList.asArray();
+        const devices = deviceList.asArray();
         if (devices.length === 1 && (!isWebUsb || !isUsingPopup)) {
-            device = _deviceList.getDevice(devices[0].path);
+            device = deviceList.getDevice(devices[0].path);
             showDeviceSelection =
                 !!(device === null || device === void 0 ? void 0 : device.unreadableError) || device.isUnacquired() || !!useCoreInPopup;
         }
@@ -90,22 +64,20 @@ const initDevice = async (devicePath) => {
     }
     if (showDeviceSelection) {
         uiPromises.create(events_2.UI.RECEIVE_DEVICE);
-        await waitForPopup();
-        if (!_deviceList) {
-            throw constants_1.ERRORS.TypedError('Transport_Missing');
-        }
-        const devices = _deviceList.asArray();
+        await waitForPopup(context);
+        (0, DeviceList_1.assertDeviceListConnected)(deviceList);
+        const devices = deviceList.asArray();
         if (devices.length === 1 &&
             devices[0].type !== 'unreadable' &&
             devices[0].features &&
             !isWebUsb &&
             !useCoreInPopup) {
-            device = _deviceList.getDevice(devices[0].path);
+            device = deviceList.getDevice(devices[0].path);
         }
         else {
-            postMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
+            sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
                 webusb: isWebUsb,
-                devices: _deviceList.asArray(),
+                devices: deviceList.asArray(),
             }));
             if (uiPromises.exists(events_2.UI.RECEIVE_DEVICE)) {
                 const { payload } = await uiPromises.get(events_2.UI.RECEIVE_DEVICE);
@@ -119,24 +91,27 @@ const initDevice = async (devicePath) => {
                         return store;
                     });
                 }
-                device = _deviceList.getDevice(payload.device.path);
+                device = deviceList.getDevice(payload.device.path);
             }
         }
     }
+    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');
     }
     return device;
 };
 const MAX_PIN_TRIES = 3;
-const getInvalidDeviceState = async (device, preauthorized) => {
+const getInvalidDeviceState = async ({ sendCoreMessage }, device, preauthorized) => {
     for (let i = 0; i < MAX_PIN_TRIES - 1; ++i) {
         try {
             return await device.validateState(preauthorized);
         }
         catch (error) {
             if (error.message.includes('PIN invalid')) {
-                postMessage((0, events_2.createUiMessage)(events_2.UI.INVALID_PIN, { device: device.toMessageObject() }));
+                sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.INVALID_PIN, { device: device.toMessageObject() }));
             }
             else {
                 throw error;
@@ -145,25 +120,26 @@ const getInvalidDeviceState = async (device, preauthorized) => {
     }
     return device.validateState(preauthorized);
 };
-const inner = async (method, device) => {
+const inner = async (context, method, device) => {
     var _a;
+    const { uiPromises, sendCoreMessage } = context;
     const trustedHost = DataManager_1.DataManager.getSettings('trustedHost');
     const isUsingPopup = (_a = DataManager_1.DataManager.getSettings('popup')) !== null && _a !== void 0 ? _a : false;
     const firmwareException = method.checkFirmwareRange();
     if (firmwareException) {
         if (isUsingPopup) {
             if (firmwareException === events_2.UI.FIRMWARE_NOT_COMPATIBLE) {
-                await waitForPopup();
+                await waitForPopup(context);
                 const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
-                postMessage((0, events_2.createUiMessage)(events_2.UI.FIRMWARE_NOT_COMPATIBLE, device.toMessageObject()));
+                sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.FIRMWARE_NOT_COMPATIBLE, device.toMessageObject()));
                 const uiResp = await uiPromise.promise;
                 if (!uiResp.payload) {
                     throw constants_1.ERRORS.TypedError('Method_PermissionsNotGranted');
                 }
             }
             else {
-                await waitForPopup();
-                postMessage((0, events_2.createUiMessage)(firmwareException, device.toMessageObject()));
+                await waitForPopup(context);
+                sendCoreMessage((0, events_2.createUiMessage)(firmwareException, device.toMessageObject()));
                 await uiPromises.create(events_2.DEVICE.DISCONNECT, device).promise;
                 return Promise.reject(constants_1.ERRORS.TypedError('Method_Cancel'));
             }
@@ -176,8 +152,8 @@ const inner = async (method, device) => {
     if (unexpectedMode) {
         device.keepSession = false;
         if (isUsingPopup) {
-            await waitForPopup();
-            postMessage((0, events_2.createUiMessage)(unexpectedMode, device.toMessageObject()));
+            await waitForPopup(context);
+            sendCoreMessage((0, events_2.createUiMessage)(unexpectedMode, device.toMessageObject()));
             await uiPromises.create(events_2.DEVICE.DISCONNECT, device).promise;
             return Promise.reject(constants_1.ERRORS.TypedError('Device_ModeException', unexpectedMode));
         }
@@ -185,9 +161,9 @@ const inner = async (method, device) => {
     }
     method.checkPermissions();
     if (!trustedHost && method.requiredPermissions.length > 0) {
-        await waitForPopup();
+        await waitForPopup(context);
         const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PERMISSION, device);
-        postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PERMISSION, {
+        sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PERMISSION, {
             permissions: method.requiredPermissions,
             device: device.toMessageObject(),
         }));
@@ -203,9 +179,9 @@ const inner = async (method, device) => {
     if (deviceNeedsBackup) {
         if (method.noBackupConfirmationMode === 'always' ||
             (method.noBackupConfirmationMode === 'popup-only' && isUsingPopup)) {
-            await waitForPopup();
+            await waitForPopup(context);
             const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
-            postMessage((0, analyticsInfo_1.enhanceMessageWithAnalytics)((0, events_2.createUiMessage)(events_2.UI.REQUEST_CONFIRMATION, {
+            sendCoreMessage((0, analyticsInfo_1.enhanceMessageWithAnalytics)((0, events_2.createUiMessage)(events_2.UI.REQUEST_CONFIRMATION, {
                 view: 'no-backup',
             }), { device: device.toMessageObject() }));
             const permitted = await uiPromise.promise.then(({ payload }) => payload);
@@ -213,19 +189,19 @@ const inner = async (method, device) => {
                 return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
             }
         }
-        await waitForPopup();
-        postMessage((0, events_2.createUiMessage)(events_2.UI.DEVICE_NEEDS_BACKUP, device.toMessageObject()));
+        await waitForPopup(context);
+        sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.DEVICE_NEEDS_BACKUP, device.toMessageObject()));
     }
     if (device.firmwareStatus === 'outdated') {
-        await waitForPopup();
-        postMessage((0, events_2.createUiMessage)(events_2.UI.FIRMWARE_OUTDATED, device.toMessageObject()));
+        await waitForPopup(context);
+        sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.FIRMWARE_OUTDATED, device.toMessageObject()));
     }
     if (!trustedHost) {
         const requestConfirmation = method.confirmation;
         if (requestConfirmation) {
-            await waitForPopup();
+            await waitForPopup(context);
             const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
-            postMessage((0, analyticsInfo_1.enhanceMessageWithAnalytics)((0, events_2.createUiMessage)(events_2.UI.REQUEST_CONFIRMATION, requestConfirmation), { device: device.toMessageObject() }));
+            sendCoreMessage((0, analyticsInfo_1.enhanceMessageWithAnalytics)((0, events_2.createUiMessage)(events_2.UI.REQUEST_CONFIRMATION, requestConfirmation), { device: device.toMessageObject() }));
             const confirmed = await uiPromise.promise.then(({ payload }) => payload);
             if (!confirmed) {
                 return Promise.reject(constants_1.ERRORS.TypedError('Method_Cancel'));
@@ -235,18 +211,18 @@ const inner = async (method, device) => {
     const isDeviceUnlocked = device.features.unlocked;
     if (method.useDeviceState) {
         try {
-            let invalidDeviceState = await getInvalidDeviceState(device, method.preauthorized);
+            let invalidDeviceState = await getInvalidDeviceState(context, device, method.preauthorized);
             if (isUsingPopup) {
                 while (invalidDeviceState) {
                     const uiPromise = uiPromises.create(events_2.UI.INVALID_PASSPHRASE_ACTION, device);
-                    postMessage((0, events_2.createUiMessage)(events_2.UI.INVALID_PASSPHRASE, {
+                    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.INVALID_PASSPHRASE, {
                         device: device.toMessageObject(),
                     }));
                     const uiResp = await uiPromise.promise;
                     if (uiResp.payload) {
                         device.setInternalState(undefined);
                         await device.initialize(method.useCardanoDerivation);
-                        invalidDeviceState = await getInvalidDeviceState(device, method.preauthorized);
+                        invalidDeviceState = await getInvalidDeviceState(context, device, method.preauthorized);
                     }
                     else {
                         device.setExternalState(invalidDeviceState);
@@ -264,13 +240,13 @@ const inner = async (method, device) => {
         }
     }
     if (!isDeviceUnlocked && device.features.unlocked) {
-        postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device.toMessageObject()));
+        sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device.toMessageObject()));
     }
     if (method.useUi) {
-        await waitForPopup();
+        await waitForPopup(context);
     }
     else {
-        postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+        sendCoreMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
     }
     try {
         const response = await method.run();
@@ -280,11 +256,12 @@ const inner = async (method, device) => {
         return Promise.reject(error);
     }
 };
-const onCall = async (message) => {
+const onCall = async (context, message) => {
     var _a;
     if (!message.id || !message.payload || message.type !== events_2.IFRAME.CALL) {
         throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'onCall: message.id or message.payload is missing');
     }
+    const { uiPromises, deviceList, callMethods, methodSynchronize, resolveWaitForFirstMethod, getOverridePromise, setOverridePromise, sendCoreMessage, } = context;
     const responseID = message.id;
     const origin = DataManager_1.DataManager.getSettings('origin');
     const env = DataManager_1.DataManager.getSettings('env');
@@ -301,27 +278,27 @@ const onCall = async (message) => {
             _log.debug('loading method...');
             const method = await (0, method_1.getMethod)(message);
             _log.debug('method selected', method.name);
-            method.postMessage = postMessage;
+            method.postMessage = sendCoreMessage;
             method.createUiPromise = uiPromises.create;
             method.init();
             await ((_a = method.initAsync) === null || _a === void 0 ? void 0 : _a.call(method));
             return method;
         });
-        waitForFirstMethod.resolve();
-        _callMethods.push(method);
+        resolveWaitForFirstMethod();
+        callMethods.push(method);
     }
     catch (error) {
-        postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
-        postMessage((0, events_2.createResponseMessage)(responseID, false, { error }));
+        sendCoreMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+        sendCoreMessage((0, events_2.createResponseMessage)(responseID, false, { error }));
         return Promise.resolve();
     }
     if (!method.useDevice) {
         try {
             if (method.useUi) {
-                await waitForPopup();
+                await waitForPopup(context);
             }
             else {
-                postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+                sendCoreMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
             }
             const response = await method.run();
             messageResponse = (0, events_2.createResponseMessage)(method.responseID, true, response);
@@ -329,45 +306,47 @@ const onCall = async (message) => {
         catch (error) {
             messageResponse = (0, events_2.createResponseMessage)(method.responseID, false, { error });
         }
-        postMessage(messageResponse);
+        sendCoreMessage(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));
-        postMessage((0, events_2.createResponseMessage)(responseID, false, {
+        sendCoreMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+        sendCoreMessage((0, events_2.createResponseMessage)(responseID, false, {
             error: constants_1.ERRORS.TypedError('Method_NotAllowed'),
         }));
         return Promise.resolve();
     }
     let device;
     try {
-        device = await initDevice(method.devicePath);
+        device = await initDevice(context, method.devicePath);
     }
     catch (error) {
         if (error.code === 'Transport_Missing') {
-            await waitForPopup();
-            postMessage((0, events_2.createUiMessage)(events_2.UI.TRANSPORT));
+            await waitForPopup(context);
+            sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.TRANSPORT));
         }
         else {
-            postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+            sendCoreMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
         }
-        postMessage((0, events_2.createResponseMessage)(responseID, false, { error }));
+        sendCoreMessage((0, events_2.createResponseMessage)(responseID, false, { error }));
         throw error;
     }
     method.setDevice(device);
-    const previousCall = _callMethods.filter(call => call && call !== method && call.devicePath === method.devicePath);
+    const previousCall = callMethods.filter(call => call && call !== method && call.devicePath === method.devicePath);
     if (previousCall.length > 0 && method.overridePreviousCall) {
         previousCall.forEach(call => {
             call.overridden = true;
         });
         const overrideError = constants_1.ERRORS.TypedError('Method_Override');
-        _overridePromise = device.override(overrideError);
-        await _overridePromise;
+        setOverridePromise(device.override(overrideError));
+        await getOverridePromise();
         if (method.overridden) {
-            postMessage((0, events_2.createResponseMessage)(method.responseID, false, { error: overrideError }));
+            sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, false, { error: overrideError }));
             throw overrideError;
         }
     }
@@ -376,7 +355,7 @@ const onCall = async (message) => {
             await device.waitForFirstRun();
         }
         else {
-            postMessage((0, events_2.createResponseMessage)(responseID, false, {
+            sendCoreMessage((0, events_2.createResponseMessage)(responseID, false, {
                 error: constants_1.ERRORS.TypedError('Device_CallInProgress'),
             }));
             throw constants_1.ERRORS.TypedError('Device_CallInProgress');
@@ -386,14 +365,12 @@ const onCall = async (message) => {
     if (method.hasExpectedDeviceState) {
         device.setExternalState(method.deviceState);
     }
-    device.on(events_2.DEVICE.BUTTON, (d, code) => {
-        onDeviceButtonHandler(d, code, method);
-    });
-    device.on(events_2.DEVICE.PIN, onDevicePinHandler);
-    device.on(events_2.DEVICE.WORD, onDeviceWordHandler);
-    device.on(events_2.DEVICE.PASSPHRASE, method.useEmptyPassphrase ? onEmptyPassphraseHandler : onDevicePassphraseHandler);
+    device.on(events_2.DEVICE.BUTTON, onDeviceButtonHandler(context, method));
+    device.on(events_2.DEVICE.PIN, onDevicePinHandler(context));
+    device.on(events_2.DEVICE.WORD, onDeviceWordHandler(context));
+    device.on(events_2.DEVICE.PASSPHRASE, (method.useEmptyPassphrase ? onEmptyPassphraseHandler : onDevicePassphraseHandler)(context));
     device.on(events_2.DEVICE.PASSPHRASE_ON_DEVICE, () => {
-        postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE_ON_DEVICE, { device: device.toMessageObject() }));
+        sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE_ON_DEVICE, { device: device.toMessageObject() }));
     });
     device.on(events_2.DEVICE.SAVE_STATE, (state) => {
         if (useCoreInPopup && env === 'webextension') {
@@ -420,10 +397,10 @@ const onCall = async (message) => {
         }
     }
     try {
-        if (_overridePromise) {
-            await _overridePromise;
+        if (getOverridePromise()) {
+            await getOverridePromise();
         }
-        const innerAction = () => inner(method, device).then(response => {
+        const innerAction = () => inner(context, method, device).then(response => {
             messageResponse = response;
         });
         await device.run(innerAction, {
@@ -433,19 +410,20 @@ const onCall = async (message) => {
         });
     }
     catch (error) {
-        if (_deviceList && error.code === 'Device_Disconnected') {
-            _deviceList.addAuthPenalty(device);
+        if (error.code === 'Device_Disconnected') {
+            deviceList.addAuthPenalty(device);
         }
         if (method) {
-            if (_deviceList && error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS) {
-                await _deviceList.enumerate();
+            if (deviceList.isConnected() &&
+                error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS) {
+                await deviceList.enumerate();
             }
             messageResponse = (0, events_2.createResponseMessage)(method.responseID, false, { error });
         }
     }
     finally {
-        if (_overridePromise) {
-            await _overridePromise;
+        if (getOverridePromise()) {
+            await getOverridePromise();
         }
         const response = messageResponse;
         if (response) {
@@ -459,73 +437,75 @@ const onCall = async (message) => {
             }
             await device.cleanup();
             if (useCoreInPopup) {
-                postMessage(response);
+                sendCoreMessage(response);
             }
-            closePopup();
-            cleanup();
+            closePopup(context);
+            cleanup(context);
             if (method) {
                 method.dispose();
             }
-            if (_deviceList) {
-                if (response.success) {
-                    _deviceList.removeAuthPenalty(device);
-                }
+            if (response.success) {
+                deviceList.removeAuthPenalty(device);
             }
             if (!useCoreInPopup) {
-                postMessage(response);
+                sendCoreMessage(response);
             }
         }
     }
 };
-const cleanup = () => {
+const cleanup = ({ uiPromises, popupPromise, interactionTimeout }) => {
     popupPromise.clear();
     uiPromises.clear();
-    _interactionTimeout.stop();
+    interactionTimeout.stop();
     _log.debug('Cleanup...');
 };
-const closePopup = () => {
+const closePopup = ({ popupPromise, sendCoreMessage }) => {
     if (popupPromise.isWaiting()) {
-        postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+        sendCoreMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
     }
-    postMessage((0, events_2.createUiMessage)(events_2.UI.CLOSE_UI_WINDOW));
+    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.CLOSE_UI_WINDOW));
 };
-const onDeviceButtonHandler = async (...[device, request, method]) => {
+const onDeviceButtonHandler = (context, method) => async (...[device, request]) => {
+    const { sendCoreMessage } = context;
     const addressRequest = request.code === 'ButtonRequest_Address';
     if (!addressRequest || (addressRequest && method.useUi)) {
-        await waitForPopup();
+        await waitForPopup(context);
     }
     const data = typeof method.getButtonRequestData === 'function' && request.code
         ? method.getButtonRequestData(request.code)
         : undefined;
-    interactionTimeout();
-    postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.BUTTON, { ...request, device: device.toMessageObject() }));
-    postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_BUTTON, {
+    startInteractionTimeout(context);
+    sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.BUTTON, { ...request, device: device.toMessageObject() }));
+    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_BUTTON, {
         ...request,
         device: device.toMessageObject(),
         data,
     }));
     if (addressRequest && !method.useUi) {
-        postMessage((0, events_2.createUiMessage)(events_2.UI.ADDRESS_VALIDATION, data));
+        sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.ADDRESS_VALIDATION, data));
     }
 };
-const onDevicePinHandler = async (...[device, type, callback]) => {
-    await waitForPopup();
+const onDevicePinHandler = (context) => async (...[device, type, callback]) => {
+    const { uiPromises, sendCoreMessage } = context;
+    await waitForPopup(context);
     const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PIN, device);
-    postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PIN, { device: device.toMessageObject(), type }));
+    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PIN, { device: device.toMessageObject(), type }));
     const uiResp = await uiPromise.promise;
     callback(null, uiResp.payload);
 };
-const onDeviceWordHandler = async (...[device, type, callback]) => {
-    await waitForPopup();
+const onDeviceWordHandler = (context) => async (...[device, type, callback]) => {
+    const { uiPromises, sendCoreMessage } = context;
+    await waitForPopup(context);
     const uiPromise = uiPromises.create(events_2.UI.RECEIVE_WORD, device);
-    postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_WORD, { device: device.toMessageObject(), type }));
+    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_WORD, { device: device.toMessageObject(), type }));
     const uiResp = await uiPromise.promise;
     callback(null, uiResp.payload);
 };
-const onDevicePassphraseHandler = async (...[device, callback]) => {
-    await waitForPopup();
+const onDevicePassphraseHandler = (context) => async (...[device, callback]) => {
+    const { uiPromises, sendCoreMessage } = context;
+    await waitForPopup(context);
     const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PASSPHRASE, device);
-    postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE, { device: device.toMessageObject() }));
+    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE, { device: device.toMessageObject() }));
     const uiResp = await uiPromise.promise;
     const { value, passphraseOnDevice, save } = uiResp.payload;
     callback({
@@ -534,27 +514,28 @@ const onDevicePassphraseHandler = async (...[device, callback]) => {
         cache: save,
     });
 };
-const onEmptyPassphraseHandler = (...[_, callback]) => {
+const onEmptyPassphraseHandler = () => (...[_, callback]) => {
     callback({ passphrase: '' });
 };
-const onPopupClosed = (customErrorMessage) => {
+const onPopupClosed = (context, customErrorMessage) => {
+    const { uiPromises, popupPromise, deviceList, callMethods, resetWaitForFirstMethod, setOverridePromise, sendCoreMessage, } = context;
     const error = customErrorMessage
         ? constants_1.ERRORS.TypedError('Method_Cancel', customErrorMessage)
         : constants_1.ERRORS.TypedError('Method_Interrupted');
-    if (_deviceList && _deviceList.asArray().length > 0) {
-        _deviceList.allDevices().forEach(d => {
+    if (deviceList.isConnected() && deviceList.asArray().length > 0) {
+        deviceList.allDevices().forEach(d => {
             d.keepSession = false;
             if (d.isUsedHere()) {
-                _overridePromise = d.interruptionFromUser(error);
+                setOverridePromise(d.interruptionFromUser(error));
             }
             else {
                 const success = uiPromises.resolve({ type: events_2.DEVICE.DISCONNECT, payload: undefined });
                 if (!success) {
-                    _callMethods.forEach(m => {
-                        postMessage((0, events_2.createResponseMessage)(m.responseID, false, { error }));
+                    callMethods.forEach(m => {
+                        sendCoreMessage((0, events_2.createResponseMessage)(m.responseID, false, { error }));
                     });
-                    _callMethods.splice(0, _callMethods.length);
-                    waitForFirstMethod = (0, utils_1.createDeferred)();
+                    callMethods.splice(0, callMethods.length);
+                    resetWaitForFirstMethod();
                 }
             }
         });
@@ -563,13 +544,14 @@ const onPopupClosed = (customErrorMessage) => {
         uiPromises.rejectAll(error);
         popupPromise.reject(error);
     }
-    cleanup();
+    cleanup(context);
 };
-const handleDeviceSelectionChanges = (interruptDevice) => {
+const handleDeviceSelectionChanges = (context, interruptDevice) => {
+    const { uiPromises, deviceList, sendCoreMessage } = context;
     const promiseExists = uiPromises.exists(events_2.UI.RECEIVE_DEVICE);
-    if (promiseExists && _deviceList) {
-        const list = _deviceList.asArray();
-        const isWebUsb = _deviceList.transportType() === 'WebUsbTransport';
+    if (promiseExists && deviceList.isConnected()) {
+        const list = deviceList.asArray();
+        const isWebUsb = deviceList.transportType() === 'WebUsbTransport';
         if (list.length === 1 && !isWebUsb) {
             uiPromises.resolve({
                 type: events_2.UI.RECEIVE_DEVICE,
@@ -577,7 +559,7 @@ const handleDeviceSelectionChanges = (interruptDevice) => {
             });
         }
         else {
-            postMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
+            sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
                 webusb: isWebUsb,
                 devices: list,
             }));
@@ -587,91 +569,107 @@ const handleDeviceSelectionChanges = (interruptDevice) => {
         const { path } = interruptDevice;
         const shouldClosePopup = uiPromises.disconnected(path);
         if (shouldClosePopup) {
-            closePopup();
-            cleanup();
+            closePopup(context);
+            cleanup(context);
         }
     }
 };
-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;
-        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);
-        }
-    }
+const initDeviceList = (context) => {
+    const { deviceList, sendCoreMessage } = context;
+    deviceList.on(events_2.DEVICE.CONNECT, device => {
+        handleDeviceSelectionChanges(context);
+        sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT, device));
+    });
+    deviceList.on(events_2.DEVICE.CONNECT_UNACQUIRED, device => {
+        handleDeviceSelectionChanges(context);
+        sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT_UNACQUIRED, device));
+    });
+    deviceList.on(events_2.DEVICE.DISCONNECT, device => {
+        handleDeviceSelectionChanges(context);
+        sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.DISCONNECT, device));
+    });
+    deviceList.on(events_2.DEVICE.CHANGED, device => {
+        sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device));
+    });
+    deviceList.on(transport_1.TRANSPORT.START, transportType => sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.START, transportType)));
+    deviceList.on(transport_1.TRANSPORT.ERROR, error => {
+        _log.warn('TRANSPORT.ERROR', error);
+        sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, { error }));
+    });
 };
 class Core extends events_1.default {
     constructor() {
         super(...arguments);
         this.abortController = new AbortController();
+        this.callMethods = [];
+        this.popupPromise = (0, popupPromiseManager_1.createPopupPromiseManager)();
+        this.methodSynchronize = (0, utils_2.getSynchronize)();
+        this.uiPromises = (0, uiPromiseManager_1.createUiPromiseManager)(() => startInteractionTimeout(this.getCoreContext()));
+        this.waitForFirstMethod = (0, utils_1.createDeferred)();
+    }
+    get interactionTimeout() {
+        var _a;
+        return (_a = this._interactionTimeout) !== null && _a !== void 0 ? _a : (0, utils_1.throwError)('Core not initialized: interactionTimeout');
+    }
+    get deviceList() {
+        var _a;
+        return (_a = this._deviceList) !== null && _a !== void 0 ? _a : (0, utils_1.throwError)('Core not initialized: deviceList');
+    }
+    sendCoreMessage(message) {
+        if (message.event === events_2.RESPONSE_EVENT) {
+            const index = this.callMethods.findIndex(call => call && call.responseID === message.id);
+            if (index >= 0) {
+                this.callMethods.splice(index, 1);
+                if (this.callMethods.length === 0) {
+                    this.waitForFirstMethod = (0, utils_1.createDeferred)();
+                }
+            }
+        }
+        this.emit(events_2.CORE_EVENT, message);
+    }
+    getCoreContext() {
+        return {
+            uiPromises: this.uiPromises,
+            popupPromise: this.popupPromise,
+            interactionTimeout: this.interactionTimeout,
+            deviceList: this.deviceList,
+            callMethods: this.callMethods,
+            methodSynchronize: this.methodSynchronize,
+            sendCoreMessage: this.sendCoreMessage.bind(this),
+            resetWaitForFirstMethod: () => {
+                this.waitForFirstMethod = (0, utils_1.createDeferred)();
+            },
+            resolveWaitForFirstMethod: () => {
+                this.waitForFirstMethod.resolve();
+            },
+            getOverridePromise: () => {
+                return this.overridePromise;
+            },
+            setOverridePromise: (promise) => {
+                this.overridePromise = promise;
+            },
+        };
     }
     handleMessage(message) {
         _log.debug('handleMessage', message);
         switch (message.type) {
             case events_2.POPUP.HANDSHAKE:
-                popupPromise.resolve();
+                this.popupPromise.resolve();
                 break;
             case events_2.POPUP.CLOSED:
-                popupPromise.clear();
-                onPopupClosed(message.payload ? message.payload.error : null);
+                this.popupPromise.clear();
+                onPopupClosed(this.getCoreContext(), message.payload ? message.payload.error : null);
                 break;
             case transport_1.TRANSPORT.DISABLE_WEBUSB:
-                disableWebUSBTransport();
+                disableWebUSBTransport(this.getCoreContext());
                 break;
             case transport_1.TRANSPORT.REQUEST_DEVICE:
-                _deviceList === null || _deviceList === void 0 ? void 0 : _deviceList.enumerate();
+                if (this.deviceList.isConnected()) {
+                    this.deviceList.enumerate();
+                }
                 break;
             case transport_1.TRANSPORT.GET_INFO:
-                postMessage((0, events_2.createResponseMessage)(message.id, true, this.getTransportInfo()));
+                this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, true, this.getTransportInfo()));
                 break;
             case events_2.UI.RECEIVE_DEVICE:
             case events_2.UI.RECEIVE_CONFIRMATION:
@@ -683,30 +681,31 @@ class Core extends events_1.default {
             case events_2.UI.RECEIVE_FEE:
             case events_2.UI.RECEIVE_WORD:
             case events_2.UI.LOGIN_CHALLENGE_RESPONSE:
-                uiPromises.resolve(message);
+                this.uiPromises.resolve(message);
                 break;
             case events_2.IFRAME.CALL:
                 if (message.payload.method === 'firmwareUpdate') {
+                    (0, DeviceList_1.assertDeviceListConnected)(this.deviceList);
                     (0, onCallFirmwareUpdate_1.onCallFirmwareUpdate)({
                         params: message.payload,
                         context: {
-                            deviceList: _deviceList,
-                            postMessage,
-                            initDevice,
+                            deviceList: this.deviceList,
+                            postMessage: this.sendCoreMessage.bind(this),
+                            initDevice: path => initDevice(this.getCoreContext(), path),
                             log: _log,
                             abortSignal: this.abortController.signal,
                         },
                     })
                         .then(payload => {
-                        postMessage((0, events_2.createResponseMessage)(message.id, true, payload));
+                        this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, true, payload));
                     })
                         .catch(error => {
-                        postMessage((0, events_2.createResponseMessage)(message.id, false, { error }));
+                        this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, false, { error }));
                         _log.error('onCallFirmwareUpdate', error);
                     });
                 }
                 else {
-                    onCall(message).catch(error => {
+                    onCall(this.getCoreContext(), message).catch(error => {
                         _log.error('onCall', error);
                     });
                 }
@@ -714,97 +713,97 @@ class Core extends events_1.default {
     }
     dispose() {
         (0, BlockchainLink_1.dispose)();
-        if (_deviceListInitTimeout) {
-            clearTimeout(_deviceListInitTimeout);
-        }
         this.removeAllListeners();
         this.abortController.abort();
-        if (_deviceList) {
-            _deviceList.dispose();
-        }
+        this.deviceList.dispose();
     }
     async getCurrentMethod() {
-        await waitForFirstMethod.promise;
-        return await methodSynchronize(() => _callMethods[0]);
+        await this.waitForFirstMethod.promise;
+        return await this.methodSynchronize(() => this.callMethods[0]);
     }
     getTransportInfo() {
-        if (!_deviceList) {
-            return undefined;
+        if (this.deviceList.isConnected()) {
+            return this.deviceList.getTransportInfo();
         }
-        return _deviceList.getTransportInfo();
     }
     enumerate() {
-        if (!_deviceList) {
-            return;
+        if (this.deviceList.isConnected()) {
+            this.deviceList.enumerate();
         }
-        _deviceList.enumerate();
     }
     async init(settings, onCoreEvent, logWriterFactory) {
         if (logWriterFactory) {
             (0, debug_1.setLogWriter)(logWriterFactory);
         }
+        const throttlePromise = (0, utils_1.createDeferred)();
+        throttlePromise.promise.catch(() => { });
+        const onCoreEventThrottled = (message) => throttlePromise.promise.then(() => onCoreEvent(message));
         try {
             await DataManager_1.DataManager.load(settings);
-            (0, debug_1.enableLog)(DataManager_1.DataManager.getSettings('debug'));
-            _core = this;
-            _interactionTimeout = new interactionTimeout_1.InteractionTimeout(settings.popup ? settings.interactionTimeout : 0);
-            this.on(events_2.CORE_EVENT, onCoreEvent);
+            const { debug, priority } = DataManager_1.DataManager.getSettings();
+            const messages = DataManager_1.DataManager.getProtobufMessages();
+            (0, debug_1.enableLog)(debug);
+            this._interactionTimeout = new interactionTimeout_1.InteractionTimeout(settings.popup ? settings.interactionTimeout : 0);
+            this._deviceList = new DeviceList_1.DeviceList({
+                debug,
+                messages,
+                priority,
+            });
+            initDeviceList(this.getCoreContext());
+            this.on(events_2.CORE_EVENT, onCoreEventThrottled);
         }
         catch (error) {
             _log.error('init', error);
+            throttlePromise.reject(error);
             throw error;
         }
+        const { transports, pendingTransportEvent, transportReconnect, coreMode } = DataManager_1.DataManager.getSettings();
         try {
-            if (!DataManager_1.DataManager.getSettings('transportReconnect') ||
-                DataManager_1.DataManager.getSettings('coreMode') === 'auto') {
-                await initDeviceList(false);
-            }
-            else {
-                initDeviceList(true);
-            }
+            this.deviceList.setTransports(transports);
         }
         catch (error) {
-            _log.error('initTransport', error);
+            _log.error('setTransports', error);
+            this.sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, { error }));
+            throttlePromise.reject(error);
             throw error;
         }
+        this.deviceList.init({ pendingTransportEvent, transportReconnect });
+        if (!transportReconnect || coreMode === 'auto') {
+            await this.deviceList.pendingConnection();
+        }
+        this.on(events_2.CORE_EVENT, onCoreEvent);
+        this.off(events_2.CORE_EVENT, onCoreEventThrottled);
+        setTimeout(throttlePromise.resolve, 0);
     }
 }
 exports.Core = Core;
-const disableWebUSBTransport = async () => {
-    var _a;
-    if (!_deviceList)
+const disableWebUSBTransport = async ({ deviceList, sendCoreMessage }) => {
+    if (!deviceList.isConnected())
         return;
-    if (_deviceList.transportType() !== 'WebUsbTransport')
+    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) {
+        sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, { error }));
     }
 };
-const initCore = async (settings, onCoreEvent, logWriterFactory) => {
+const initCore = async (...params) => {
     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);
+    await core.init(...params);
     return core;
 };
 const disposeCore = (core) => {