@trezor/connect 9.2.3 → 9.2.4-beta.1

package/lib/core/index.js

@@ -14,13 +14,14 @@ const constants_1 = require("../constants");
 const events_2 = require("../events");
 const method_1 = require("./method");
 const promiseUtils_1 = require("../utils/promiseUtils");
+const uiPromiseManager_1 = require("../utils/uiPromiseManager");
+const popupPromiseManager_1 = require("../utils/popupPromiseManager");
 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;
-let _popupPromise;
-const _uiPromises = [];
 const _callMethods = [];
 let _interactionTimeout;
 let _deviceListInitTimeout;
@@ -40,71 +41,16 @@ const postMessage = (message) => {
     }
     _core.emit(events_2.CORE_EVENT, message);
 };
-const getPopupPromise = (requestWindow = true) => {
-    if (requestWindow) {
-        postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_UI_WINDOW));
-    }
-    if (!_popupPromise) {
-        _popupPromise = (0, utils_1.createDeferred)();
-    }
-    return _popupPromise;
+const popupPromise = (0, popupPromiseManager_1.createPopupPromiseManager)();
+const waitForPopup = () => {
+    postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_UI_WINDOW));
+    return popupPromise.wait();
 };
 const interactionTimeout = () => _interactionTimeout.start(() => {
     onPopupClosed('Interaction timeout');
 });
-const createUiPromise = (promiseEvent, device) => {
-    const uiPromise = {
-        ...(0, utils_1.createDeferred)(promiseEvent),
-        device,
-    };
-    _uiPromises.push(uiPromise);
-    interactionTimeout();
-    return uiPromise;
-};
-const findUiPromise = (promiseEvent) => _uiPromises.find(p => p.id === promiseEvent);
-const removeUiPromise = (promise) => {
-    _uiPromises.splice(0).push(..._uiPromises.filter(p => p !== promise));
-};
-const handleMessage = (message) => {
-    _log.debug('handleMessage', message);
-    switch (message.type) {
-        case events_2.POPUP.HANDSHAKE:
-            getPopupPromise(false).resolve();
-            break;
-        case events_2.POPUP.CLOSED:
-            onPopupClosed(message.payload ? message.payload.error : null);
-            break;
-        case transport_1.TRANSPORT.DISABLE_WEBUSB:
-            disableWebUSBTransport();
-            break;
-        case transport_1.TRANSPORT.REQUEST_DEVICE:
-            _deviceList === null || _deviceList === void 0 ? void 0 : _deviceList.enumerate();
-            break;
-        case events_2.UI.RECEIVE_DEVICE:
-        case events_2.UI.RECEIVE_CONFIRMATION:
-        case events_2.UI.RECEIVE_PERMISSION:
-        case events_2.UI.RECEIVE_PIN:
-        case events_2.UI.RECEIVE_PASSPHRASE:
-        case events_2.UI.INVALID_PASSPHRASE_ACTION:
-        case events_2.UI.RECEIVE_ACCOUNT:
-        case events_2.UI.RECEIVE_FEE:
-        case events_2.UI.RECEIVE_WORD:
-        case events_2.UI.LOGIN_CHALLENGE_RESPONSE: {
-            const uiPromise = findUiPromise(message.type);
-            if (uiPromise) {
-                uiPromise.resolve(message);
-                removeUiPromise(uiPromise);
-            }
-            break;
-        }
-        case events_2.IFRAME.CALL:
-            onCall(message).catch(error => {
-                _log.error('onCall', error);
-            });
-            break;
-    }
-};
-const initDevice = async (method) => {
+const uiPromises = (0, uiPromiseManager_1.createUiPromiseManager)(interactionTimeout);
+const initDevice = async (devicePath) => {
     if (!_deviceList) {
         throw constants_1.ERRORS.TypedError('Transport_Missing');
     }
@@ -123,8 +69,8 @@ const initDevice = async (method) => {
             return store;
         });
     }
-    if (method.devicePath) {
-        device = _deviceList.getDevice(method.devicePath);
+    if (devicePath) {
+        device = _deviceList.getDevice(devicePath);
         showDeviceSelection =
             !device || !!(device === null || device === void 0 ? void 0 : device.unreadableError) || (device.isUnacquired() && !!isUsingPopup);
     }
@@ -140,8 +86,8 @@ const initDevice = async (method) => {
         }
     }
     if (showDeviceSelection) {
-        createUiPromise(events_2.UI.RECEIVE_DEVICE);
-        await getPopupPromise().promise;
+        uiPromises.create(events_2.UI.RECEIVE_DEVICE);
+        await waitForPopup();
         if (!_deviceList) {
             throw constants_1.ERRORS.TypedError('Transport_Missing');
         }
@@ -158,9 +104,8 @@ const initDevice = async (method) => {
                 webusb: isWebUsb,
                 devices: _deviceList.asArray(),
             }));
-            const uiPromise = findUiPromise(events_2.UI.RECEIVE_DEVICE);
-            if (uiPromise) {
-                const { payload } = await uiPromise.promise;
+            if (uiPromises.exists(events_2.UI.RECEIVE_DEVICE)) {
+                const { payload } = await uiPromises.get(events_2.UI.RECEIVE_DEVICE);
                 if (payload.remember) {
                     const { label, path, state } = payload.device;
                     connect_common_1.storage.save(store => {
@@ -180,14 +125,164 @@ const initDevice = async (method) => {
     }
     return device;
 };
+const MAX_PIN_TRIES = 3;
+const getInvalidDeviceState = async (device, network, preauthorized) => {
+    for (let i = 0; i < MAX_PIN_TRIES - 1; ++i) {
+        try {
+            return await device.validateState(network, preauthorized);
+        }
+        catch (error) {
+            if (error.message.includes('PIN invalid')) {
+                postMessage((0, events_2.createUiMessage)(events_2.UI.INVALID_PIN, { device: device.toMessageObject() }));
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    return device.validateState(network, preauthorized);
+};
+const inner = async (method, device) => {
+    var _a;
+    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();
+                const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
+                postMessage((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 uiPromises.create(events_2.DEVICE.DISCONNECT, device).promise;
+                return Promise.reject(constants_1.ERRORS.TypedError('Method_Cancel'));
+            }
+        }
+        else {
+            return Promise.reject(constants_1.ERRORS.TypedError('Device_FwException', firmwareException));
+        }
+    }
+    const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
+    if (unexpectedMode) {
+        device.keepSession = false;
+        if (isUsingPopup) {
+            await waitForPopup();
+            postMessage((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));
+        }
+        return Promise.reject(constants_1.ERRORS.TypedError('Device_ModeException', unexpectedMode));
+    }
+    method.checkPermissions();
+    if (!trustedHost && method.requiredPermissions.length > 0) {
+        await waitForPopup();
+        const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PERMISSION, device);
+        postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PERMISSION, {
+            permissions: method.requiredPermissions,
+            device: device.toMessageObject(),
+        }));
+        const { granted, remember } = await uiPromise.promise.then(({ payload }) => payload);
+        if (granted) {
+            method.savePermissions(!remember);
+        }
+        else {
+            return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
+        }
+    }
+    const deviceNeedsBackup = device.features.needs_backup;
+    if (deviceNeedsBackup) {
+        if (method.noBackupConfirmationMode === 'always' ||
+            (method.noBackupConfirmationMode === 'popup-only' && isUsingPopup)) {
+            await waitForPopup();
+            const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
+            postMessage((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);
+            if (!permitted) {
+                return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
+            }
+        }
+        await waitForPopup();
+        postMessage((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()));
+    }
+    if (!trustedHost) {
+        const requestConfirmation = method.confirmation;
+        if (requestConfirmation) {
+            await waitForPopup();
+            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() }));
+            const confirmed = await uiPromise.promise.then(({ payload }) => payload);
+            if (!confirmed) {
+                return Promise.reject(constants_1.ERRORS.TypedError('Method_Cancel'));
+            }
+        }
+    }
+    const isDeviceUnlocked = device.features.unlocked;
+    if (method.useDeviceState) {
+        try {
+            let invalidDeviceState = await getInvalidDeviceState(device, method.network, 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, {
+                        device: device.toMessageObject(),
+                    }));
+                    const uiResp = await uiPromise.promise;
+                    if (uiResp.payload) {
+                        device.setInternalState(undefined);
+                        await device.initialize(method.useEmptyPassphrase, method.useCardanoDerivation);
+                        invalidDeviceState = await getInvalidDeviceState(device, method.network, method.preauthorized);
+                    }
+                    else {
+                        device.setExternalState(invalidDeviceState);
+                        break;
+                    }
+                }
+            }
+            else if (invalidDeviceState) {
+                throw constants_1.ERRORS.TypedError('Device_InvalidState');
+            }
+        }
+        catch (error) {
+            device.setInternalState(undefined);
+            return Promise.reject(error);
+        }
+    }
+    if (!isDeviceUnlocked && device.features.unlocked) {
+        postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device.toMessageObject()));
+    }
+    if (method.useUi) {
+        await waitForPopup();
+    }
+    else {
+        postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+    }
+    try {
+        const response = await method.run();
+        return (0, events_2.createResponseMessage)(method.responseID, true, response);
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
+};
 const onCall = async (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 responseID = message.id;
-    const trustedHost = DataManager_1.DataManager.getSettings('trustedHost');
-    const isUsingPopup = DataManager_1.DataManager.getSettings('popup');
     const origin = DataManager_1.DataManager.getSettings('origin');
     const env = DataManager_1.DataManager.getSettings('env');
     const useCoreInPopup = DataManager_1.DataManager.getSettings('useCoreInPopup');
@@ -204,8 +299,7 @@ const onCall = async (message) => {
             const method = await (0, method_1.getMethod)(message);
             _log.debug('method selected', method.name);
             method.postMessage = postMessage;
-            method.getPopupPromise = getPopupPromise;
-            method.createUiPromise = createUiPromise;
+            method.createUiPromise = uiPromises.create;
             method.init();
             await ((_a = method.initAsync) === null || _a === void 0 ? void 0 : _a.call(method));
             return method;
@@ -221,7 +315,7 @@ const onCall = async (message) => {
     if (!method.useDevice) {
         try {
             if (method.useUi) {
-                await getPopupPromise().promise;
+                await waitForPopup();
             }
             else {
                 postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
@@ -247,11 +341,11 @@ const onCall = async (message) => {
     }
     let device;
     try {
-        device = await initDevice(method);
+        device = await initDevice(method.devicePath);
     }
     catch (error) {
         if (error.code === 'Transport_Missing') {
-            await getPopupPromise().promise;
+            await waitForPopup();
             postMessage((0, events_2.createUiMessage)(events_2.UI.TRANSPORT));
         }
         else {
@@ -260,7 +354,6 @@ const onCall = async (message) => {
         postMessage((0, events_2.createResponseMessage)(responseID, false, { error }));
         throw error;
     }
-    method.postMessage = (message) => (0, analyticsInfo_1.enhancePostMessageWithAnalytics)(postMessage, message, { device: device.toMessageObject() });
     method.setDevice(device);
     const previousCall = _callMethods.filter(call => call && call !== method && call.devicePath === method.devicePath);
     if (previousCall.length > 0 && method.overridePreviousCall) {
@@ -324,112 +417,13 @@ const onCall = async (message) => {
         }
     }
     try {
-        let PIN_TRIES = 1;
-        const MAX_PIN_TRIES = 3;
-        const inner = async () => {
-            const firmwareException = await method.checkFirmwareRange(isUsingPopup);
-            if (firmwareException) {
-                if (isUsingPopup) {
-                    await getPopupPromise().promise;
-                    postMessage((0, events_2.createUiMessage)(firmwareException, device.toMessageObject()));
-                    await createUiPromise(events_2.DEVICE.DISCONNECT, device).promise;
-                    return Promise.reject(constants_1.ERRORS.TypedError('Method_Cancel'));
-                }
-                return Promise.reject(constants_1.ERRORS.TypedError('Device_FwException', firmwareException));
-            }
-            const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
-            if (unexpectedMode) {
-                device.keepSession = false;
-                if (isUsingPopup) {
-                    await getPopupPromise().promise;
-                    postMessage((0, events_2.createUiMessage)(unexpectedMode, device.toMessageObject()));
-                    await createUiPromise(events_2.DEVICE.DISCONNECT, device).promise;
-                    return Promise.reject(constants_1.ERRORS.TypedError('Device_ModeException', unexpectedMode));
-                }
-                return Promise.reject(constants_1.ERRORS.TypedError('Device_ModeException', unexpectedMode));
-            }
-            method.checkPermissions();
-            if (!trustedHost && method.requiredPermissions.length > 0) {
-                const permitted = await method.requestPermissions();
-                if (!permitted) {
-                    return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
-                }
-            }
-            const deviceNeedsBackup = device.features.needs_backup;
-            if (deviceNeedsBackup && typeof method.noBackupConfirmation === 'function') {
-                const permitted = await method.noBackupConfirmation(!isUsingPopup);
-                if (!permitted) {
-                    return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
-                }
-            }
-            if (deviceNeedsBackup) {
-                await getPopupPromise().promise;
-                postMessage((0, events_2.createUiMessage)(events_2.UI.DEVICE_NEEDS_BACKUP, device.toMessageObject()));
-            }
-            if (device.firmwareStatus === 'outdated') {
-                await getPopupPromise().promise;
-                postMessage((0, events_2.createUiMessage)(events_2.UI.FIRMWARE_OUTDATED, device.toMessageObject()));
-            }
-            if (!trustedHost && typeof method.confirmation === 'function') {
-                const confirmed = await method.confirmation();
-                if (!confirmed) {
-                    return Promise.reject(constants_1.ERRORS.TypedError('Method_Cancel'));
-                }
-            }
-            const isDeviceUnlocked = device.features.unlocked;
-            try {
-                const invalidDeviceState = method.useDeviceState
-                    ? await device.validateState(method.network, method.preauthorized)
-                    : undefined;
-                if (invalidDeviceState) {
-                    if (isUsingPopup) {
-                        const uiPromise = createUiPromise(events_2.UI.INVALID_PASSPHRASE_ACTION, device);
-                        postMessage((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.useEmptyPassphrase, method.useCardanoDerivation);
-                            return inner();
-                        }
-                        device.setExternalState(invalidDeviceState);
-                    }
-                    else {
-                        throw constants_1.ERRORS.TypedError('Device_InvalidState');
-                    }
-                }
-            }
-            catch (error) {
-                if (error.message.includes('PIN invalid') && PIN_TRIES < MAX_PIN_TRIES) {
-                    PIN_TRIES++;
-                    postMessage((0, events_2.createUiMessage)(events_2.UI.INVALID_PIN, { device: device.toMessageObject() }));
-                    return inner();
-                }
-                device.setInternalState(undefined);
-                return Promise.reject(error);
-            }
-            if (!isDeviceUnlocked && device.features.unlocked) {
-                postMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device.toMessageObject()));
-            }
-            if (method.useUi) {
-                await getPopupPromise().promise;
-            }
-            else {
-                postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
-            }
-            try {
-                const response = await method.run();
-                messageResponse = (0, events_2.createResponseMessage)(method.responseID, true, response);
-            }
-            catch (error) {
-                return Promise.reject(error);
-            }
-        };
         if (_overridePromise) {
             await _overridePromise;
         }
-        await device.run(inner, {
+        const innerAction = () => inner(method, device).then(response => {
+            messageResponse = response;
+        });
+        await device.run(innerAction, {
             keepSession: method.keepSession,
             useEmptyPassphrase: method.useEmptyPassphrase,
             skipFinalReload: method.skipFinalReload,
@@ -477,13 +471,13 @@ const onCall = async (message) => {
     }
 };
 const cleanup = () => {
-    _popupPromise = undefined;
-    _uiPromises.splice(0);
+    popupPromise.clear();
+    uiPromises.clear();
     _interactionTimeout.stop();
     _log.debug('Cleanup...');
 };
 const closePopup = () => {
-    if (_popupPromise) {
+    if (popupPromise.isWaiting()) {
         postMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
     }
     postMessage((0, events_2.createUiMessage)(events_2.UI.CLOSE_UI_WINDOW));
@@ -491,7 +485,7 @@ const closePopup = () => {
 const onDeviceButtonHandler = async (...[device, request, method]) => {
     const addressRequest = request.code === 'ButtonRequest_Address';
     if (!addressRequest || (addressRequest && method.useUi)) {
-        await getPopupPromise().promise;
+        await waitForPopup();
     }
     const data = typeof method.getButtonRequestData === 'function' && request.code
         ? method.getButtonRequestData(request.code)
@@ -508,22 +502,22 @@ const onDeviceButtonHandler = async (...[device, request, method]) => {
     }
 };
 const onDevicePinHandler = async (...[device, type, callback]) => {
-    await getPopupPromise().promise;
-    const uiPromise = createUiPromise(events_2.UI.RECEIVE_PIN, device);
+    await waitForPopup();
+    const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PIN, device);
     postMessage((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 getPopupPromise().promise;
-    const uiPromise = createUiPromise(events_2.UI.RECEIVE_WORD, device);
+    await waitForPopup();
+    const uiPromise = uiPromises.create(events_2.UI.RECEIVE_WORD, device);
     postMessage((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 getPopupPromise().promise;
-    const uiPromise = createUiPromise(events_2.UI.RECEIVE_PASSPHRASE, device);
+    await waitForPopup();
+    const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PASSPHRASE, device);
     postMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE, { device: device.toMessageObject() }));
     const uiResp = await uiPromise.promise;
     const { value, passphraseOnDevice, save } = uiResp.payload;
@@ -547,11 +541,8 @@ const onPopupClosed = (customErrorMessage) => {
                 _overridePromise = d.interruptionFromUser(error);
             }
             else {
-                const uiPromise = findUiPromise(events_2.DEVICE.DISCONNECT);
-                if (uiPromise) {
-                    uiPromise.resolve({ type: events_2.DEVICE.DISCONNECT, payload: undefined });
-                }
-                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 }));
                     });
@@ -560,33 +551,23 @@ const onPopupClosed = (customErrorMessage) => {
                 }
             }
         });
-        cleanup();
     }
     else {
-        if (_uiPromises.length > 0) {
-            _uiPromises.forEach(p => {
-                p.reject(error);
-            });
-            _uiPromises.splice(0);
-        }
-        if (_popupPromise) {
-            _popupPromise.reject(error);
-            _popupPromise = undefined;
-        }
-        cleanup();
+        uiPromises.rejectAll(error);
+        popupPromise.reject(error);
     }
+    cleanup();
 };
 const handleDeviceSelectionChanges = (interruptDevice) => {
-    const uiPromise = findUiPromise(events_2.UI.RECEIVE_DEVICE);
-    if (uiPromise && _deviceList) {
+    const promiseExists = uiPromises.exists(events_2.UI.RECEIVE_DEVICE);
+    if (promiseExists && _deviceList) {
         const list = _deviceList.asArray();
         const isWebUsb = _deviceList.transportType() === 'WebUsbTransport';
         if (list.length === 1 && !isWebUsb) {
-            uiPromise.resolve({
+            uiPromises.resolve({
                 type: events_2.UI.RECEIVE_DEVICE,
                 payload: { device: list[0] },
             });
-            removeUiPromise(uiPromise);
         }
         else {
             postMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
@@ -597,15 +578,7 @@ const handleDeviceSelectionChanges = (interruptDevice) => {
     }
     if (interruptDevice) {
         const { path } = interruptDevice;
-        let shouldClosePopup = false;
-        _uiPromises.forEach(p => {
-            if (p.device && p.device.getDevicePath() === path) {
-                if (p.id === events_2.DEVICE.DISCONNECT) {
-                    p.resolve({ type: events_2.DEVICE.DISCONNECT });
-                }
-                shouldClosePopup = true;
-            }
-        });
+        const shouldClosePopup = uiPromises.disconnected(path);
         if (shouldClosePopup) {
             closePopup();
             cleanup();
@@ -667,17 +640,73 @@ const initDeviceList = async (transportReconnect) => {
     }
 };
 class Core extends events_1.default {
+    constructor() {
+        super(...arguments);
+        this.abortController = new AbortController();
+    }
     handleMessage(message) {
-        handleMessage(message);
+        _log.debug('handleMessage', message);
+        switch (message.type) {
+            case events_2.POPUP.HANDSHAKE:
+                popupPromise.resolve();
+                break;
+            case events_2.POPUP.CLOSED:
+                onPopupClosed(message.payload ? message.payload.error : null);
+                break;
+            case transport_1.TRANSPORT.DISABLE_WEBUSB:
+                disableWebUSBTransport();
+                break;
+            case transport_1.TRANSPORT.REQUEST_DEVICE:
+                _deviceList === null || _deviceList === void 0 ? void 0 : _deviceList.enumerate();
+                break;
+            case events_2.UI.RECEIVE_DEVICE:
+            case events_2.UI.RECEIVE_CONFIRMATION:
+            case events_2.UI.RECEIVE_PERMISSION:
+            case events_2.UI.RECEIVE_PIN:
+            case events_2.UI.RECEIVE_PASSPHRASE:
+            case events_2.UI.INVALID_PASSPHRASE_ACTION:
+            case events_2.UI.RECEIVE_ACCOUNT:
+            case events_2.UI.RECEIVE_FEE:
+            case events_2.UI.RECEIVE_WORD:
+            case events_2.UI.LOGIN_CHALLENGE_RESPONSE:
+                uiPromises.resolve(message);
+                break;
+            case events_2.IFRAME.CALL:
+                if (message.payload.method === 'firmwareUpdate') {
+                    (0, onCallFirmwareUpdate_1.onCallFirmwareUpdate)({
+                        params: message.payload,
+                        context: {
+                            deviceList: _deviceList,
+                            postMessage,
+                            initDevice,
+                            log: _log,
+                            abortSignal: this.abortController.signal,
+                        },
+                    })
+                        .then(payload => {
+                        postMessage((0, events_2.createResponseMessage)(message.id, true, payload));
+                    })
+                        .catch(error => {
+                        postMessage((0, events_2.createResponseMessage)(message.id, false, { error }));
+                        _log.error('onCallFirmwareUpdate', error);
+                    });
+                }
+                else {
+                    onCall(message).catch(error => {
+                        _log.error('onCall', error);
+                    });
+                }
+        }
     }
-    async dispose() {
+    dispose() {
         (0, BlockchainLink_1.dispose)();
         if (_deviceListInitTimeout) {
             clearTimeout(_deviceListInitTimeout);
         }
         this.removeAllListeners();
+        this.abortController.abort();
         if (_deviceList) {
-            await _deviceList.dispose();
+            _deviceList.dispose();
         }
     }
     async getCurrentMethod() {
@@ -745,7 +774,7 @@ const disableWebUSBTransport = async () => {
         }
     }
     try {
-        await _deviceList.dispose();
+        _deviceList.dispose();
         await initDeviceList(settings.transportReconnect);
     }
     catch (error) {