@trezor/connect 9.7.0-beta.1 → 9.7.0

package/lib/core/index.js

@@ -1,5 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.initCoreState = exports.Core = void 0;
 const tslib_1 = require("tslib");
 const events_1 = tslib_1.__importDefault(require("events"));
@@ -22,823 +25,981 @@ const interactionTimeout_1 = require("../utils/interactionTimeout");
 const popupPromiseManager_1 = require("../utils/popupPromiseManager");
 const uiPromiseManager_1 = require("../utils/uiPromiseManager");
 const _log = (0, debug_1.initLog)('Core');
-const waitForPopup = ({ popupPromise, sendCoreMessage }) => {
-    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_UI_WINDOW));
-    return popupPromise.wait();
+const waitForPopup = ({
+  popupPromise,
+  sendCoreMessage
+}) => {
+  sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_UI_WINDOW));
+  return popupPromise.wait();
 };
-const startInteractionTimeout = (context) => context.interactionTimeout.start(() => {
-    onPopupClosed(context, 'Interaction timeout');
+const startInteractionTimeout = context => context.interactionTimeout.start(() => {
+  onPopupClosed(context, 'Interaction timeout');
 });
 const initDevice = async (context, methodCallDevice) => {
-    const { uiPromises, deviceList, sendCoreMessage } = context;
+  const {
+    uiPromises,
+    deviceList,
+    sendCoreMessage
+  } = context;
+  (0, DeviceList_1.assertDeviceListConnected)(deviceList);
+  const isWebUsb = deviceList.getActiveTransports().some(t => t.type === '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?.state && deviceList.getDeviceByStaticState(preferredDevice.state);
+  if (methodCallDevice?.state?.staticSessionId) {
+    device = deviceList.getDeviceByStaticState(methodCallDevice.state.staticSessionId);
+  }
+  if (!device && methodCallDevice?.path) {
+    device = deviceList.getDeviceByPath(methodCallDevice.path);
+  }
+  if (preferredDevice && !device) {
+    if (preferredDeviceInList) {
+      device = preferredDeviceInList;
+    } else {
+      connect_common_1.storage.save(store => {
+        store.origin[origin] = {
+          ...store.origin[origin],
+          preferredDevice: undefined
+        };
+        return store;
+      });
+    }
+  }
+  if (device) {
+    showDeviceSelection = device.isUnreadable() || device.isUnacquired() && !!isUsingPopup;
+  } else {
+    const onlyDevice = deviceList.getOnlyDevice();
+    if (onlyDevice && (!isWebUsb || !isUsingPopup)) {
+      device = onlyDevice;
+      showDeviceSelection = device.isUnreadable() || device.isUnacquired() || !!useCoreInPopup;
+    } else {
+      showDeviceSelection = true;
+    }
+  }
+  if (showDeviceSelection) {
+    uiPromises.create(events_2.UI.RECEIVE_DEVICE);
+    await waitForPopup(context);
     (0, DeviceList_1.assertDeviceListConnected)(deviceList);
-    const isWebUsb = deviceList.getActiveTransports().some(t => t.type === '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?.state && deviceList.getDeviceByStaticState(preferredDevice.state);
-    if (methodCallDevice?.state?.staticSessionId) {
-        device = deviceList.getDeviceByStaticState(methodCallDevice.state.staticSessionId);
-    }
-    if (!device && methodCallDevice?.path) {
-        device = deviceList.getDeviceByPath(methodCallDevice.path);
-    }
-    if (preferredDevice && !device) {
-        if (preferredDeviceInList) {
-            device = preferredDeviceInList;
-        }
-        else {
-            connect_common_1.storage.save(store => {
-                store.origin[origin] = { ...store.origin[origin], preferredDevice: undefined };
-                return store;
-            });
-        }
-    }
-    if (device) {
-        showDeviceSelection = device.isUnreadable() || (device.isUnacquired() && !!isUsingPopup);
-    }
-    else {
-        const onlyDevice = deviceList.getOnlyDevice();
-        if (onlyDevice && (!isWebUsb || !isUsingPopup)) {
-            device = onlyDevice;
-            showDeviceSelection =
-                device.isUnreadable() || device.isUnacquired() || !!useCoreInPopup;
-        }
-        else {
-            showDeviceSelection = true;
-        }
-    }
-    if (showDeviceSelection) {
-        uiPromises.create(events_2.UI.RECEIVE_DEVICE);
-        await waitForPopup(context);
-        (0, DeviceList_1.assertDeviceListConnected)(deviceList);
-        const onlyDevice = deviceList.getOnlyDevice();
-        if (onlyDevice &&
-            !onlyDevice.isUnreadable() &&
-            !onlyDevice.isUnacquired() &&
-            !isWebUsb &&
-            !useCoreInPopup) {
-            device = onlyDevice;
-        }
-        else {
-            sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
-                webusb: isWebUsb,
-                devices: deviceList.getAllDevices().map(d => d.toMessageObject()),
-            }));
-            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 => {
-                        store.origin[origin] = {
-                            ...store.origin[origin],
-                            preferredDevice: { label, path, state },
-                        };
-                        return store;
-                    });
-                }
-                device = deviceList.getDeviceByPath(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 onlyDevice = deviceList.getOnlyDevice();
+    if (onlyDevice && !onlyDevice.isUnreadable() && !onlyDevice.isUnacquired() && !isWebUsb && !useCoreInPopup) {
+      device = onlyDevice;
+    } else {
+      sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
+        webusb: isWebUsb,
+        devices: deviceList.getAllDevices().map(d => d.toMessageObject())
+      }));
+      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 => {
+            store.origin[origin] = {
+              ...store.origin[origin],
+              preferredDevice: {
+                label,
+                path,
+                state
+              }
+            };
+            return store;
+          });
+        }
+        device = deviceList.getDeviceByPath(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 inner = async (context, method, device) => {
-    const { uiPromises, sendCoreMessage } = context;
-    const trustedHost = DataManager_1.DataManager.getSettings('trustedHost');
-    const isUsingPopup = DataManager_1.DataManager.getSettings('popup') ?? false;
-    const firmwareException = method.checkFirmwareRange();
-    if (firmwareException) {
-        if (isUsingPopup) {
-            if (firmwareException === events_2.UI.FIRMWARE_NOT_COMPATIBLE) {
-                await waitForPopup(context);
-                const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
-                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(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'));
-            }
-        }
-        else {
-            return Promise.reject(constants_1.ERRORS.TypedError('Device_FwException', firmwareException));
-        }
-    }
-    const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
-    if (unexpectedMode) {
-        if (isUsingPopup) {
-            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));
-        }
-        return Promise.reject(constants_1.ERRORS.TypedError('Device_ModeException', unexpectedMode));
-    }
-    method.checkDeviceCapability();
-    method.checkPermissions({ origin: DataManager_1.DataManager.getSettings('origin') });
-    if (!trustedHost && method.requiredPermissions.length > 0) {
-        await waitForPopup(context);
-        const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PERMISSION, device);
-        sendCoreMessage((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, { origin: DataManager_1.DataManager.getSettings('origin') });
-        }
-        else {
-            return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
-        }
-    }
-    const deviceNeedsBackup = device.features.backup_availability === 'Required';
-    if (deviceNeedsBackup) {
-        if (method.noBackupConfirmationMode === 'always' ||
-            (method.noBackupConfirmationMode === 'popup-only' && isUsingPopup)) {
-            await waitForPopup(context);
-            const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
-            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);
-            if (!permitted) {
-                return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
-            }
-        }
-        await waitForPopup(context);
-        sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.DEVICE_NEEDS_BACKUP, device.toMessageObject()));
-    }
-    if (device.firmwareStatus === 'outdated') {
+  const {
+    uiPromises,
+    sendCoreMessage
+  } = context;
+  const trustedHost = DataManager_1.DataManager.getSettings('trustedHost');
+  const isUsingPopup = DataManager_1.DataManager.getSettings('popup') ?? false;
+  const firmwareException = method.checkFirmwareRange();
+  if (firmwareException) {
+    if (isUsingPopup) {
+      if (firmwareException === events_2.UI.FIRMWARE_NOT_COMPATIBLE) {
         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(context);
-            const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
-            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'));
-            }
+        const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
+        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');
         }
-    }
-    const workflowCtx = {
-        device,
-        method,
-        signal: context.signal,
-    };
-    await workflows.validateState(workflowCtx);
-    if (method.useUi) {
+      } else {
         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'));
+      }
+    } else {
+      return Promise.reject(constants_1.ERRORS.TypedError('Device_FwException', firmwareException));
+    }
+  }
+  const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
+  if (unexpectedMode) {
+    if (isUsingPopup) {
+      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));
+    }
+    return Promise.reject(constants_1.ERRORS.TypedError('Device_ModeException', unexpectedMode));
+  }
+  method.checkDeviceCapability();
+  method.checkPermissions({
+    origin: DataManager_1.DataManager.getSettings('origin')
+  });
+  if (!trustedHost && method.requiredPermissions.length > 0) {
+    await waitForPopup(context);
+    const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PERMISSION, device);
+    sendCoreMessage((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, {
+        origin: DataManager_1.DataManager.getSettings('origin')
+      });
+    } else {
+      return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
+    }
+  }
+  const deviceNeedsBackup = device.features.backup_availability === 'Required';
+  if (deviceNeedsBackup) {
+    if (method.noBackupConfirmationMode === 'always' || method.noBackupConfirmationMode === 'popup-only' && isUsingPopup) {
+      await waitForPopup(context);
+      const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
+      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);
+      if (!permitted) {
+        return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
+      }
     }
-    else {
-        sendCoreMessage((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, device);
-    }
-    catch (error) {
-        return Promise.reject(error);
-    }
+    await waitForPopup(context);
+    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.DEVICE_NEEDS_BACKUP, device.toMessageObject()));
+  }
+  if (device.firmwareStatus === 'outdated') {
+    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(context);
+      const uiPromise = uiPromises.create(events_2.UI.RECEIVE_CONFIRMATION, device);
+      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'));
+      }
+    }
+  }
+  const workflowCtx = {
+    device,
+    method,
+    signal: context.signal
+  };
+  await workflows.validateState(workflowCtx);
+  if (method.useUi) {
+    await waitForPopup(context);
+  } else {
+    sendCoreMessage((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, device);
+  } catch (error) {
+    return Promise.reject(error);
+  }
 };
 const onCall = async (context, message) => {
-    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, callMethods, methodSynchronize, resolveWaitForFirstMethod, sendCoreMessage, } = context;
-    const responseID = message.id;
-    let method;
+  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,
+    callMethods,
+    methodSynchronize,
+    resolveWaitForFirstMethod,
+    sendCoreMessage
+  } = context;
+  const responseID = message.id;
+  let method;
+  try {
+    method = await methodSynchronize(async () => {
+      _log.debug('loading method...');
+      const method2 = await (0, method_1.getMethod)(message);
+      _log.debug('method selected', method2.name);
+      method2.postMessage = sendCoreMessage;
+      method2.createUiPromise = uiPromises.create;
+      method2.init();
+      await method2.initAsync?.();
+      return method2;
+    });
+    resolveWaitForFirstMethod();
+    callMethods.push(method);
+  } catch (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.payload.__info) {
+    const response = method.getMethodInfo();
+    if (method.payload.__precomposed) {
+      response.precomposed = await method.payloadToPrecomposed();
+    }
+    sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, true, response));
+    return Promise.resolve();
+  }
+  if (!method.useDevice) {
     try {
-        method = await methodSynchronize(async () => {
-            _log.debug('loading method...');
-            const method2 = await (0, method_1.getMethod)(message);
-            _log.debug('method selected', method2.name);
-            method2.postMessage = sendCoreMessage;
-            method2.createUiPromise = uiPromises.create;
-            method2.init();
-            await method2.initAsync?.();
-            return method2;
-        });
-        resolveWaitForFirstMethod();
-        callMethods.push(method);
-    }
-    catch (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.payload.__info) {
-        const response = method.getMethodInfo();
-        if (method.payload.__precomposed) {
-            response.precomposed = await method.payloadToPrecomposed();
-        }
-        sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, true, response));
-        return Promise.resolve();
-    }
-    if (!method.useDevice) {
-        try {
-            if (method.useUi) {
-                await waitForPopup(context);
-            }
-            else {
-                sendCoreMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
-            }
-            const response = await method.run();
-            sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, true, response));
-        }
-        catch (error) {
-            sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, false, { error }));
-        }
-        return Promise.resolve();
-    }
-    if (method.isManagementRestricted({ origin: DataManager_1.DataManager.getSettings('origin') })) {
+      if (method.useUi) {
+        await waitForPopup(context);
+      } else {
         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();
-    }
-    return await onCallDevice(context, message, method);
+      }
+      const response = await method.run();
+      sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, true, response));
+    } catch (error) {
+      sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, false, {
+        error
+      }));
+    }
+    return Promise.resolve();
+  }
+  if (method.isManagementRestricted({
+    origin: DataManager_1.DataManager.getSettings('origin')
+  })) {
+    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();
+  }
+  return await onCallDevice(context, message, method);
 };
 const onCallDevice = async (context, message, method) => {
-    const { deviceList, callMethods, sendCoreMessage } = context;
-    const responseID = message.id;
-    const { origin, env, useCoreInPopup, transports } = DataManager_1.DataManager.getSettings();
-    if (!deviceList.isConnected() && !deviceList.pendingConnection()) {
-        deviceList.init({ transports });
-    }
-    await deviceList.pendingConnection();
-    const shouldRetry = ['web', 'webextension'].includes(env);
-    let tempDevice;
-    while (!tempDevice) {
-        try {
-            tempDevice = await initDevice(context, message.payload.device);
-        }
-        catch (error) {
-            if (error.code === 'Transport_Missing') {
-                await waitForPopup(context);
-                sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.TRANSPORT));
-                if (deviceList.pendingConnection() && shouldRetry) {
-                    while (deviceList.pendingConnection()) {
-                        await deviceList.pendingConnection();
-                    }
-                    continue;
-                }
-            }
-            else {
-                sendCoreMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
-            }
-            sendCoreMessage((0, events_2.createResponseMessage)(responseID, false, { error }));
-            throw error;
-        }
-    }
-    const device = tempDevice;
-    method.setDevice(device);
-    const previousCall = callMethods.filter(call => call &&
-        call !== method &&
-        call.device?.getUniquePath() === method.device.getUniquePath());
-    if (previousCall.length > 0 && method.overridePreviousCall) {
-        previousCall.forEach(call => {
-            call.overridden = true;
-        });
-        const overrideError = constants_1.ERRORS.TypedError('Method_Override');
-        await device.interrupt(overrideError);
-        if (method.overridden) {
-            sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, false, { error: overrideError }));
-            throw overrideError;
-        }
-    }
-    else if (device.currentRun) {
-        if (device.isUnacquired()) {
-            await device.currentRun;
-        }
-        else {
-            sendCoreMessage((0, events_2.createResponseMessage)(responseID, false, {
-                error: constants_1.ERRORS.TypedError('Device_CallInProgress'),
-            }));
-            throw constants_1.ERRORS.TypedError('Device_CallInProgress');
-        }
-    }
-    device.setInstance(message.payload.device?.instance);
-    if (method.hasExpectedDeviceState) {
-        device.setState(method.deviceState);
-    }
-    registerDeviceEvents(context, method)(device);
-    if (useCoreInPopup && env === 'webextension' && origin) {
-        device.initStorage(new StateStorage_1.WebextensionStateStorage(origin));
-    }
-    let messageResponse;
+  const {
+    deviceList,
+    callMethods,
+    sendCoreMessage
+  } = context;
+  const responseID = message.id;
+  const {
+    origin,
+    env,
+    useCoreInPopup,
+    transports
+  } = DataManager_1.DataManager.getSettings();
+  if (!deviceList.isConnected() && !deviceList.pendingConnection()) {
+    deviceList.init({
+      transports
+    });
+  }
+  await deviceList.pendingConnection();
+  const shouldRetry = ['web', 'webextension'].includes(env);
+  let tempDevice;
+  while (!tempDevice) {
     try {
-        const innerAction = () => inner(context, method, device).then(response => {
-            messageResponse = response;
-        });
-        await device.run(innerAction, {
-            keepSession: method.keepSession,
-            skipFinalReload: method.skipFinalReload,
-            useCardanoDerivation: method.useCardanoDerivation,
-        });
-    }
-    catch (error) {
-        if (error.cause) {
-            _log.debug('device.run error caught, caused by:', error.cause);
-        }
-        if (error.code === 'Device_Disconnected') {
-            deviceList.addAuthPenalty(device);
-        }
-        if (method) {
-            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 (method.keepSession &&
-            method.deviceState &&
-            method.deviceState.sessionId !== device.getState()?.sessionId) {
-            sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device.toMessageObject()));
-        }
-        const response = messageResponse;
-        if (response) {
-            device.eventNames().forEach(e => device.removeAllListeners(e));
-            if (useCoreInPopup) {
-                sendCoreMessage(response);
-            }
-            closePopup(context);
-            cleanup(context);
-            if (method) {
-                method.dispose();
-            }
-            if (response.success) {
-                deviceList.removeAuthPenalty(device);
-            }
-            if (!useCoreInPopup) {
-                sendCoreMessage(response);
-            }
-        }
-    }
-};
-const cleanup = ({ uiPromises, popupPromise, interactionTimeout }) => {
-    popupPromise.clear();
-    uiPromises.clear();
-    interactionTimeout.stop();
-    _log.debug('Cleanup...');
-};
-const closePopup = ({ popupPromise, sendCoreMessage }) => {
-    if (popupPromise.isWaiting()) {
+      tempDevice = await initDevice(context, message.payload.device);
+    } catch (error) {
+      if (error.code === 'Transport_Missing') {
+        await waitForPopup(context);
+        sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.TRANSPORT));
+        if (deviceList.pendingConnection() && shouldRetry) {
+          while (deviceList.pendingConnection()) {
+            await deviceList.pendingConnection();
+          }
+          continue;
+        }
+      } else {
         sendCoreMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
-    }
-    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.CLOSE_UI_WINDOW));
+      }
+      sendCoreMessage((0, events_2.createResponseMessage)(responseID, false, {
+        error
+      }));
+      throw error;
+    }
+  }
+  const device = tempDevice;
+  method.setDevice(device);
+  const previousCall = callMethods.filter(call => call && call !== method && call.device?.getUniquePath() === method.device.getUniquePath());
+  if (previousCall.length > 0 && method.overridePreviousCall) {
+    previousCall.forEach(call => {
+      call.overridden = true;
+    });
+    const overrideError = constants_1.ERRORS.TypedError('Method_Override');
+    await device.interrupt(overrideError);
+    if (method.overridden) {
+      sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, false, {
+        error: overrideError
+      }));
+      throw overrideError;
+    }
+  } else if (device.currentRun) {
+    if (device.isUnacquired()) {
+      await device.currentRun;
+    } else {
+      sendCoreMessage((0, events_2.createResponseMessage)(responseID, false, {
+        error: constants_1.ERRORS.TypedError('Device_CallInProgress')
+      }));
+      throw constants_1.ERRORS.TypedError('Device_CallInProgress');
+    }
+  }
+  device.setInstance(message.payload.device?.instance);
+  if (method.hasExpectedDeviceState) {
+    device.setState(method.deviceState);
+  }
+  registerDeviceEvents(context, method)(device);
+  if (useCoreInPopup && env === 'webextension' && origin) {
+    device.initStorage(new StateStorage_1.WebextensionStateStorage(origin));
+  }
+  let messageResponse;
+  try {
+    const innerAction = () => inner(context, method, device).then(response => {
+      messageResponse = response;
+    });
+    await device.run(innerAction, {
+      keepSession: method.keepSession,
+      skipFinalReload: method.skipFinalReload,
+      useCardanoDerivation: method.useCardanoDerivation
+    });
+  } catch (error) {
+    if (error.cause) {
+      _log.debug('device.run error caught, caused by:', error.cause);
+    }
+    if (error.code === 'Device_Disconnected') {
+      deviceList.addAuthPenalty(device);
+    }
+    if (method) {
+      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 (method.keepSession && method.deviceState && method.deviceState.sessionId !== device.getState()?.sessionId) {
+      sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device.toMessageObject()));
+    }
+    const response = messageResponse;
+    if (response) {
+      device.eventNames().forEach(e => device.removeAllListeners(e));
+      if (useCoreInPopup) {
+        sendCoreMessage(response);
+      }
+      closePopup(context);
+      cleanup(context);
+      if (method) {
+        method.dispose();
+      }
+      if (response.success) {
+        deviceList.removeAuthPenalty(device);
+      }
+      if (!useCoreInPopup) {
+        sendCoreMessage(response);
+      }
+    }
+  }
 };
-const onDeviceButtonHandler = (device, context, method) => async ({ payload: request }) => {
-    const { sendCoreMessage } = context;
-    const addressRequest = request.code === 'ButtonRequest_Address';
-    if (!addressRequest || (addressRequest && method?.useUi)) {
-        await waitForPopup(context);
-    }
-    const data = typeof method?.getButtonRequestData === 'function' && request.code
-        ? method?.getButtonRequestData(request.code, request.name)
-        : undefined;
-    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) {
-        sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.ADDRESS_VALIDATION, data));
-    }
+const cleanup = ({
+  uiPromises,
+  popupPromise,
+  interactionTimeout
+}) => {
+  popupPromise.clear();
+  uiPromises.clear();
+  interactionTimeout.stop();
+  _log.debug('Cleanup...');
 };
-const onDevicePinHandler = (device, context) => async ({ type, callback }) => {
-    const { uiPromises, sendCoreMessage } = context;
-    await waitForPopup(context);
-    const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PIN, device);
-    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PIN, { device: device.toMessageObject(), type }));
-    try {
-        const uiResp = await uiPromise.promise;
-        if (uiResp.payload == null) {
-            callback({ success: false, error: new Error(`${events_2.UI.RECEIVE_PIN} missing payload`) });
-        }
-        else {
-            callback({ success: true, payload: uiResp.payload });
-        }
-    }
-    catch (error) {
-        callback({ success: false, error });
-    }
+const closePopup = ({
+  popupPromise,
+  sendCoreMessage
+}) => {
+  if (popupPromise.isWaiting()) {
+    sendCoreMessage((0, events_2.createPopupMessage)(events_2.POPUP.CANCEL_POPUP_REQUEST));
+  }
+  sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.CLOSE_UI_WINDOW));
 };
-const onDeviceWordHandler = (device, context) => async ({ type, callback }) => {
-    const { uiPromises, sendCoreMessage } = context;
+const onDeviceButtonHandler = (device, context, method) => async ({
+  payload: request
+}) => {
+  const {
+    sendCoreMessage
+  } = context;
+  const addressRequest = request.code === 'ButtonRequest_Address';
+  if (!addressRequest || addressRequest && method?.useUi) {
     await waitForPopup(context);
-    const uiPromise = uiPromises.create(events_2.UI.RECEIVE_WORD, device);
-    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_WORD, { device: device.toMessageObject(), type }));
-    try {
-        const uiResp = await uiPromise.promise;
-        if (uiResp.payload == null) {
-            callback({
-                success: false,
-                error: new Error(`${events_2.UI.RECEIVE_WORD} missing payload`),
-            });
-        }
-        else {
-            callback({ success: true, payload: uiResp.payload });
-        }
-    }
-    catch (error) {
-        callback({ success: false, error });
-    }
+  }
+  const data = typeof method?.getButtonRequestData === 'function' && request.code ? method?.getButtonRequestData(request.code, request.name) : undefined;
+  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) {
+    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.ADDRESS_VALIDATION, data));
+  }
 };
-const onDevicePassphraseHandler = (device, context) => async ({ callback }) => {
-    const { uiPromises, sendCoreMessage } = context;
-    await waitForPopup(context);
-    const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PASSPHRASE, device);
-    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE, { device: device.toMessageObject() }));
-    try {
-        const uiResp = await uiPromise.promise;
-        if (uiResp.payload == null) {
-            callback({
-                success: false,
-                error: new Error(`${events_2.UI.RECEIVE_PASSPHRASE} missing payload`),
-            });
-        }
-        else {
-            callback({ success: true, payload: uiResp.payload });
-        }
-    }
-    catch (error) {
-        callback({ success: false, error });
-    }
+const onDevicePinHandler = (device, context) => async ({
+  type,
+  callback
+}) => {
+  const {
+    uiPromises,
+    sendCoreMessage
+  } = context;
+  await waitForPopup(context);
+  const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PIN, device);
+  sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PIN, {
+    device: device.toMessageObject(),
+    type
+  }));
+  try {
+    const uiResp = await uiPromise.promise;
+    if (uiResp.payload == null) {
+      callback({
+        success: false,
+        error: new Error(`${events_2.UI.RECEIVE_PIN} missing payload`)
+      });
+    } else {
+      callback({
+        success: true,
+        payload: uiResp.payload
+      });
+    }
+  } catch (error) {
+    callback({
+      success: false,
+      error
+    });
+  }
 };
-const onEmptyPassphraseHandler = () => ({ callback }) => {
-    callback({ success: true, payload: { value: '' } });
+const onDeviceWordHandler = (device, context) => async ({
+  type,
+  callback
+}) => {
+  const {
+    uiPromises,
+    sendCoreMessage
+  } = context;
+  await waitForPopup(context);
+  const uiPromise = uiPromises.create(events_2.UI.RECEIVE_WORD, device);
+  sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_WORD, {
+    device: device.toMessageObject(),
+    type
+  }));
+  try {
+    const uiResp = await uiPromise.promise;
+    if (uiResp.payload == null) {
+      callback({
+        success: false,
+        error: new Error(`${events_2.UI.RECEIVE_WORD} missing payload`)
+      });
+    } else {
+      callback({
+        success: true,
+        payload: uiResp.payload
+      });
+    }
+  } catch (error) {
+    callback({
+      success: false,
+      error
+    });
+  }
 };
-const onThpPairingHandler = (device, context) => async ({ callback, payload }) => {
-    const { uiPromises, sendCoreMessage } = context;
-    await waitForPopup(context);
-    const uiPromise = uiPromises.create(events_2.UI.RECEIVE_THP_PAIRING_TAG, device);
-    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_THP_PAIRING, {
-        device: device.toMessageObject(),
-        ...payload,
-    }));
-    try {
-        const uiResp = await uiPromise.promise;
-        if (uiResp.payload == null) {
-            callback({
-                success: false,
-                error: new Error(`${events_2.UI.RECEIVE_THP_PAIRING_TAG} missing payload`),
-            });
-        }
-        else {
-            callback({ success: true, payload: uiResp.payload });
-        }
-    }
-    catch (error) {
-        callback({ success: false, error });
-    }
+const onDevicePassphraseHandler = (device, context) => async ({
+  callback
+}) => {
+  const {
+    uiPromises,
+    sendCoreMessage
+  } = context;
+  await waitForPopup(context);
+  const uiPromise = uiPromises.create(events_2.UI.RECEIVE_PASSPHRASE, device);
+  sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE, {
+    device: device.toMessageObject()
+  }));
+  try {
+    const uiResp = await uiPromise.promise;
+    if (uiResp.payload == null) {
+      callback({
+        success: false,
+        error: new Error(`${events_2.UI.RECEIVE_PASSPHRASE} missing payload`)
+      });
+    } else {
+      callback({
+        success: true,
+        payload: uiResp.payload
+      });
+    }
+  } catch (error) {
+    callback({
+      success: false,
+      error
+    });
+  }
 };
-const onThpCredentialsChangedHandler = (device, context) => (payload) => {
-    const { sendCoreMessage } = context;
-    sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.THP_CREDENTIALS_CHANGED, {
-        device: device.toMessageObject(),
-        ...payload,
-    }));
+const onEmptyPassphraseHandler = () => ({
+  callback
+}) => {
+  callback({
+    success: true,
+    payload: {
+      value: ''
+    }
+  });
 };
-const registerDeviceEvents = (context, method) => (device) => {
-    device.removeAllListeners();
-    device.on(events_2.DEVICE.BUTTON, onDeviceButtonHandler(device, context, method));
-    device.on(events_2.DEVICE.PIN, onDevicePinHandler(device, context));
-    device.on(events_2.DEVICE.WORD, onDeviceWordHandler(device, context));
-    device.on(events_2.DEVICE.PASSPHRASE, (method?.useEmptyPassphrase ? onEmptyPassphraseHandler : onDevicePassphraseHandler)(device, context));
-    device.on(events_2.DEVICE.PASSPHRASE_ON_DEVICE, () => {
-        context.sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE_ON_DEVICE, {
-            device: device.toMessageObject(),
-        }));
-    });
-    device.on(events_2.DEVICE.FIRMWARE_VERSION_CHANGED, payload => {
-        context.sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.FIRMWARE_VERSION_CHANGED, payload));
+const onThpPairingHandler = (device, context) => async ({
+  callback,
+  payload
+}) => {
+  const {
+    uiPromises,
+    sendCoreMessage
+  } = context;
+  await waitForPopup(context);
+  const uiPromise = uiPromises.create(events_2.UI.RECEIVE_THP_PAIRING_TAG, device);
+  sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_THP_PAIRING, {
+    device: device.toMessageObject(),
+    ...payload
+  }));
+  try {
+    const uiResp = await uiPromise.promise;
+    if (uiResp.payload == null) {
+      callback({
+        success: false,
+        error: new Error(`${events_2.UI.RECEIVE_THP_PAIRING_TAG} missing payload`)
+      });
+    } else {
+      callback({
+        success: true,
+        payload: uiResp.payload
+      });
+    }
+  } catch (error) {
+    callback({
+      success: false,
+      error
     });
-    device.on(events_2.DEVICE.THP_PAIRING, onThpPairingHandler(device, context));
-    device.on(events_2.DEVICE.THP_CREDENTIALS_CHANGED, onThpCredentialsChangedHandler(device, context));
+  }
+};
+const onThpCredentialsChangedHandler = (device, context) => payload => {
+  const {
+    sendCoreMessage
+  } = context;
+  sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.THP_CREDENTIALS_CHANGED, {
+    device: device.toMessageObject(),
+    ...payload
+  }));
+};
+const registerDeviceEvents = (context, method) => device => {
+  device.removeAllListeners();
+  device.on(events_2.DEVICE.BUTTON, onDeviceButtonHandler(device, context, method));
+  device.on(events_2.DEVICE.PIN, onDevicePinHandler(device, context));
+  device.on(events_2.DEVICE.WORD, onDeviceWordHandler(device, context));
+  device.on(events_2.DEVICE.PASSPHRASE, (method?.useEmptyPassphrase ? onEmptyPassphraseHandler : onDevicePassphraseHandler)(device, context));
+  device.on(events_2.DEVICE.PASSPHRASE_ON_DEVICE, () => {
+    context.sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_PASSPHRASE_ON_DEVICE, {
+      device: device.toMessageObject()
+    }));
+  });
+  device.on(events_2.DEVICE.FIRMWARE_VERSION_CHANGED, payload => {
+    context.sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.FIRMWARE_VERSION_CHANGED, payload));
+  });
+  device.on(events_2.DEVICE.THP_PAIRING, onThpPairingHandler(device, context));
+  device.on(events_2.DEVICE.THP_CREDENTIALS_CHANGED, onThpCredentialsChangedHandler(device, context));
 };
 const onPopupClosed = (context, customErrorMessage) => {
-    const { uiPromises, popupPromise, deviceList, callMethods, resetWaitForFirstMethod, sendCoreMessage, } = context;
-    const error = customErrorMessage
-        ? constants_1.ERRORS.TypedError('Method_Cancel', customErrorMessage)
-        : constants_1.ERRORS.TypedError('Method_Interrupted');
-    if (deviceList.isConnected() && deviceList.getDeviceCount() > 0) {
-        deviceList.getAllDevices().forEach(d => {
-            if (d.isUsedHere()) {
-                d.interrupt(error);
-            }
-            else {
-                const success = uiPromises.resolve({ type: events_2.DEVICE.DISCONNECT, payload: undefined });
-                if (!success) {
-                    callMethods.forEach(m => {
-                        sendCoreMessage((0, events_2.createResponseMessage)(m.responseID, false, { error }));
-                    });
-                    callMethods.splice(0, callMethods.length);
-                    resetWaitForFirstMethod();
-                }
-            }
+  const {
+    uiPromises,
+    popupPromise,
+    deviceList,
+    callMethods,
+    resetWaitForFirstMethod,
+    sendCoreMessage
+  } = context;
+  const error = customErrorMessage ? constants_1.ERRORS.TypedError('Method_Cancel', customErrorMessage) : constants_1.ERRORS.TypedError('Method_Interrupted');
+  if (deviceList.isConnected() && deviceList.getDeviceCount() > 0) {
+    deviceList.getAllDevices().forEach(d => {
+      if (d.isUsedHere()) {
+        d.interrupt(error);
+      } else {
+        const success = uiPromises.resolve({
+          type: events_2.DEVICE.DISCONNECT,
+          payload: undefined
         });
-    }
-    else {
-        uiPromises.rejectAll(error);
-        popupPromise.reject(error);
-    }
-    cleanup(context);
-};
-const handleDeviceSelectionChanges = (context, interruptDevice) => {
-    const { uiPromises, deviceList, sendCoreMessage } = context;
-    const promiseExists = uiPromises.exists(events_2.UI.RECEIVE_DEVICE);
-    if (promiseExists && deviceList.isConnected()) {
-        const onlyDevice = deviceList.getOnlyDevice();
-        const isWebUsb = deviceList.getActiveTransports().some(t => t.type === 'WebUsbTransport');
-        if (onlyDevice && !isWebUsb) {
-            uiPromises.resolve({
-                type: events_2.UI.RECEIVE_DEVICE,
-                payload: { device: onlyDevice.toMessageObject() },
-            });
-        }
-        else {
-            sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
-                webusb: isWebUsb,
-                devices: deviceList.getAllDevices().map(d => d.toMessageObject()),
+        if (!success) {
+          callMethods.forEach(m => {
+            sendCoreMessage((0, events_2.createResponseMessage)(m.responseID, false, {
+              error
             }));
+          });
+          callMethods.splice(0, callMethods.length);
+          resetWaitForFirstMethod();
         }
-    }
-    if (interruptDevice) {
-        const { path } = interruptDevice;
-        const shouldClosePopup = uiPromises.disconnected(path);
-        if (shouldClosePopup) {
-            closePopup(context);
-            cleanup(context);
-        }
-    }
-};
-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.toMessageObject()));
-    });
-    deviceList.on(events_2.DEVICE.CONNECT_UNACQUIRED, device => {
-        handleDeviceSelectionChanges(context);
-        sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject()));
-    });
-    deviceList.on(events_2.DEVICE.DISCONNECT, device => {
-        handleDeviceSelectionChanges(context);
-        sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.DISCONNECT, device.toMessageObject()));
-    });
-    deviceList.on(events_2.DEVICE.CHANGED, device => {
-        sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device.toMessageObject()));
-    });
-    deviceList.on(events_2.DEVICE.TREZOR_PUSH_NOTIFICATION, payload => {
-        sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.TREZOR_PUSH_NOTIFICATION, {
-            device: payload.device.toMessageObject(),
-            mode: payload.mode,
-            type: payload.type,
-        }));
-    });
-    deviceList.on(transport_1.TRANSPORT.START, transport => sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.START, transport)));
-    deviceList.on(transport_1.TRANSPORT.ERROR, error => {
-        _log.warn('TRANSPORT.ERROR', error.error);
-        sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, error));
+      }
     });
+  } else {
+    uiPromises.rejectAll(error);
+    popupPromise.reject(error);
+  }
+  cleanup(context);
+};
+const handleDeviceSelectionChanges = (context, interruptDevice) => {
+  const {
+    uiPromises,
+    deviceList,
+    sendCoreMessage
+  } = context;
+  const promiseExists = uiPromises.exists(events_2.UI.RECEIVE_DEVICE);
+  if (promiseExists && deviceList.isConnected()) {
+    const onlyDevice = deviceList.getOnlyDevice();
+    const isWebUsb = deviceList.getActiveTransports().some(t => t.type === 'WebUsbTransport');
+    if (onlyDevice && !isWebUsb) {
+      uiPromises.resolve({
+        type: events_2.UI.RECEIVE_DEVICE,
+        payload: {
+          device: onlyDevice.toMessageObject()
+        }
+      });
+    } else {
+      sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.SELECT_DEVICE, {
+        webusb: isWebUsb,
+        devices: deviceList.getAllDevices().map(d => d.toMessageObject())
+      }));
+    }
+  }
+  if (interruptDevice) {
+    const {
+      path
+    } = interruptDevice;
+    const shouldClosePopup = uiPromises.disconnected(path);
+    if (shouldClosePopup) {
+      closePopup(context);
+      cleanup(context);
+    }
+  }
+};
+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.toMessageObject()));
+  });
+  deviceList.on(events_2.DEVICE.CONNECT_UNACQUIRED, device => {
+    handleDeviceSelectionChanges(context);
+    sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject()));
+  });
+  deviceList.on(events_2.DEVICE.DISCONNECT, device => {
+    handleDeviceSelectionChanges(context);
+    sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.DISCONNECT, device.toMessageObject()));
+  });
+  deviceList.on(events_2.DEVICE.CHANGED, device => {
+    sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device.toMessageObject()));
+  });
+  deviceList.on(events_2.DEVICE.TREZOR_PUSH_NOTIFICATION, payload => {
+    sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.TREZOR_PUSH_NOTIFICATION, {
+      device: payload.device.toMessageObject(),
+      mode: payload.mode,
+      type: payload.type
+    }));
+  });
+  deviceList.on(transport_1.TRANSPORT.START, transport => sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.START, transport)));
+  deviceList.on(transport_1.TRANSPORT.ERROR, error => {
+    _log.warn('TRANSPORT.ERROR', error.error);
+    sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, error));
+  });
 };
 class Core extends events_1.default {
-    abortController = new AbortController();
-    callMethods = [];
-    popupPromise = (0, popupPromiseManager_1.createPopupPromiseManager)();
-    methodSynchronize = (0, utils_1.getSynchronize)();
-    uiPromises = (0, uiPromiseManager_1.createUiPromiseManager)(() => startInteractionTimeout(this.getCoreContext()));
-    waitForFirstMethod = (0, utils_1.createDeferred)();
-    _interactionTimeout;
-    get interactionTimeout() {
-        return this._interactionTimeout ?? (0, utils_1.throwError)('Core not initialized: interactionTimeout');
-    }
-    _deviceList;
-    get deviceList() {
-        return this._deviceList ?? (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 {
-            signal: this.abortController.signal,
-            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();
-            },
-        };
-    }
-    handleMessage(message) {
-        _log.debug('handleMessage', message.type);
-        switch (message.type) {
-            case events_2.POPUP.HANDSHAKE:
-                this.popupPromise.resolve();
-                break;
-            case events_2.POPUP.CLOSED:
-                this.popupPromise.clear();
-                onPopupClosed(this.getCoreContext(), message.payload ? message.payload.error : null);
-                break;
-            case transport_1.TRANSPORT.DISABLE_WEBUSB: {
-                const settings = DataManager_1.DataManager.getSettings();
-                const transports = settings.transports?.filter(t => t !== 'WebUsbTransport');
-                if (transports && !transports.includes('BridgeTransport')) {
-                    transports.unshift('BridgeTransport');
-                }
-                settings.transports = transports;
-                resetTransports(this.getCoreContext());
-                break;
-            }
-            case transport_1.TRANSPORT.SET_TRANSPORTS:
-                DataManager_1.DataManager.getSettings().transports = message.payload.transports;
-                resetTransports(this.getCoreContext());
-                break;
-            case transport_1.TRANSPORT.REQUEST_DEVICE:
-                if (this.deviceList.isConnected()) {
-                    this.deviceList.enumerate();
-                }
-                break;
-            case transport_1.TRANSPORT.GET_INFO:
-                this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, true, this.getActiveTransports()));
-                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_THP_PAIRING_TAG:
-            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:
-                this.uiPromises.resolve(message);
-                break;
-            case events_2.UI.RECEIVE_FIRMWARE: {
-                const localFirmwares = message.payload && (0, connectSettings_1.parseLocalFirmwares)(message.payload);
-                if (localFirmwares) {
-                    DataManager_1.DataManager.setLocalFirmwares(localFirmwares);
-                }
-                break;
-            }
-            case events_2.IFRAME.CALL:
-                if (message.payload.method === 'firmwareUpdate') {
-                    (0, DeviceList_1.assertDeviceListConnected)(this.deviceList);
-                    const coreContext = this.getCoreContext();
-                    (0, onCallFirmwareUpdate_1.onCallFirmwareUpdate)({
-                        params: message.payload,
-                        context: {
-                            deviceList: this.deviceList,
-                            postMessage: this.sendCoreMessage.bind(this),
-                            initDevice: path => initDevice(coreContext, { path }),
-                            log: _log,
-                            abortSignal: this.abortController.signal,
-                            registerEvents: registerDeviceEvents(coreContext),
-                            uiPromises: coreContext.uiPromises,
-                        },
-                    })
-                        .then(payload => {
-                        this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, true, payload));
-                    })
-                        .catch(error => {
-                        this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, false, { error }));
-                        _log.error('onCallFirmwareUpdate', error);
-                    });
-                }
-                else {
-                    onCall(this.getCoreContext(), message).catch(error => {
-                        _log.error('onCall', error);
-                    });
-                }
-        }
-    }
-    dispose() {
-        (0, BlockchainLink_1.dispose)();
-        this.removeAllListeners();
-        this.abortController.abort();
-        this.deviceList.dispose();
-    }
-    async getCurrentMethod() {
-        await this.waitForFirstMethod.promise;
-        return await this.methodSynchronize(() => this.callMethods[0]);
-    }
-    getActiveTransports() {
-        if (this.deviceList.isConnected()) {
-            return this.deviceList.getActiveTransports();
-        }
-    }
-    enumerate() {
+  abortController = new AbortController();
+  callMethods = [];
+  popupPromise = (0, popupPromiseManager_1.createPopupPromiseManager)();
+  methodSynchronize = (0, utils_1.getSynchronize)();
+  uiPromises = (0, uiPromiseManager_1.createUiPromiseManager)(() => startInteractionTimeout(this.getCoreContext()));
+  waitForFirstMethod = (0, utils_1.createDeferred)();
+  _interactionTimeout;
+  get interactionTimeout() {
+    return this._interactionTimeout ?? (0, utils_1.throwError)('Core not initialized: interactionTimeout');
+  }
+  _deviceList;
+  get deviceList() {
+    return this._deviceList ?? (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 {
+      signal: this.abortController.signal,
+      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();
+      }
+    };
+  }
+  handleMessage(message) {
+    _log.debug('handleMessage', message.type);
+    switch (message.type) {
+      case events_2.POPUP.HANDSHAKE:
+        this.popupPromise.resolve();
+        break;
+      case events_2.POPUP.CLOSED:
+        this.popupPromise.clear();
+        onPopupClosed(this.getCoreContext(), message.payload ? message.payload.error : null);
+        break;
+      case transport_1.TRANSPORT.DISABLE_WEBUSB:
+        {
+          const settings = DataManager_1.DataManager.getSettings();
+          const transports = settings.transports?.filter(t => t !== 'WebUsbTransport');
+          if (transports && !transports.includes('BridgeTransport')) {
+            transports.unshift('BridgeTransport');
+          }
+          settings.transports = transports;
+          resetTransports(this.getCoreContext());
+          break;
+        }
+      case transport_1.TRANSPORT.SET_TRANSPORTS:
+        DataManager_1.DataManager.getSettings().transports = message.payload.transports;
+        resetTransports(this.getCoreContext());
+        break;
+      case transport_1.TRANSPORT.REQUEST_DEVICE:
         if (this.deviceList.isConnected()) {
-            this.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);
-            const localFirmwares = settings.localFirmwares && (0, connectSettings_1.parseLocalFirmwares)(settings.localFirmwares);
-            if (localFirmwares) {
-                DataManager_1.DataManager.setLocalFirmwares(localFirmwares);
+          this.deviceList.enumerate();
+        }
+        break;
+      case transport_1.TRANSPORT.GET_INFO:
+        this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, true, this.getActiveTransports()));
+        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_THP_PAIRING_TAG:
+      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:
+        this.uiPromises.resolve(message);
+        break;
+      case events_2.UI.RECEIVE_FIRMWARE:
+        {
+          const localFirmwares = message.payload && (0, connectSettings_1.parseLocalFirmwares)(message.payload);
+          if (localFirmwares) {
+            DataManager_1.DataManager.setLocalFirmwares(localFirmwares);
+          }
+          break;
+        }
+      case events_2.IFRAME.CALL:
+        if (message.payload.method === 'firmwareUpdate') {
+          (0, DeviceList_1.assertDeviceListConnected)(this.deviceList);
+          const coreContext = this.getCoreContext();
+          (0, onCallFirmwareUpdate_1.onCallFirmwareUpdate)({
+            params: message.payload,
+            context: {
+              deviceList: this.deviceList,
+              postMessage: this.sendCoreMessage.bind(this),
+              initDevice: path => initDevice(coreContext, {
+                path
+              }),
+              log: _log,
+              abortSignal: this.abortController.signal,
+              registerEvents: registerDeviceEvents(coreContext),
+              uiPromises: coreContext.uiPromises
             }
-            const { debug, priority, manifest } = 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,
-                manifest,
-            });
-            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 {
-            this.deviceList.init({ transports, pendingTransportEvent, transportReconnect });
-        }
-        catch (error) {
-            this.sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, { error }));
-            throttlePromise.reject(error);
-            throw error;
-        }
-        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);
-    }
+          }).then(payload => {
+            this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, true, payload));
+          }).catch(error => {
+            this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, false, {
+              error
+            }));
+            _log.error('onCallFirmwareUpdate', error);
+          });
+        } else {
+          onCall(this.getCoreContext(), message).catch(error => {
+            _log.error('onCall', error);
+          });
+        }
+    }
+  }
+  dispose() {
+    (0, BlockchainLink_1.dispose)();
+    this.removeAllListeners();
+    this.abortController.abort();
+    this.deviceList.dispose();
+  }
+  async getCurrentMethod() {
+    await this.waitForFirstMethod.promise;
+    return await this.methodSynchronize(() => this.callMethods[0]);
+  }
+  getActiveTransports() {
+    if (this.deviceList.isConnected()) {
+      return this.deviceList.getActiveTransports();
+    }
+  }
+  enumerate() {
+    if (this.deviceList.isConnected()) {
+      this.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);
+      const localFirmwares = settings.localFirmwares && (0, connectSettings_1.parseLocalFirmwares)(settings.localFirmwares);
+      if (localFirmwares) {
+        DataManager_1.DataManager.setLocalFirmwares(localFirmwares);
+      }
+      const {
+        debug,
+        priority,
+        manifest
+      } = 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,
+        manifest
+      });
+      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 {
+      this.deviceList.init({
+        transports,
+        pendingTransportEvent,
+        transportReconnect
+      });
+    } catch (error) {
+      this.sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, {
+        error
+      }));
+      throttlePromise.reject(error);
+      throw error;
+    }
+    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 resetTransports = async ({ deviceList, sendCoreMessage }) => {
-    const { transports, pendingTransportEvent, transportReconnect } = DataManager_1.DataManager.getSettings();
-    try {
-        await deviceList.init({ transports, pendingTransportEvent, transportReconnect });
-    }
-    catch (error) {
-        sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, { error }));
-    }
+const resetTransports = async ({
+  deviceList,
+  sendCoreMessage
+}) => {
+  const {
+    transports,
+    pendingTransportEvent,
+    transportReconnect
+  } = DataManager_1.DataManager.getSettings();
+  try {
+    await deviceList.init({
+      transports,
+      pendingTransportEvent,
+      transportReconnect
+    });
+  } catch (error) {
+    sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, {
+      error
+    }));
+  }
 };
 const initCore = async (...params) => {
-    const core = new Core();
-    await core.init(...params);
-    return core;
+  const core = new Core();
+  await core.init(...params);
+  return core;
 };
-const disposeCore = (core) => {
-    core.dispose();
+const disposeCore = core => {
+  core.dispose();
 };
 const initCoreState = () => (0, utils_1.createLazy)(initCore, disposeCore);
 exports.initCoreState = initCoreState;