@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/core/index.js

@@ -1,129 +1,50 @@
-"use strict";
-
-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"));
-const connect_common_1 = require("@trezor/connect-common");
-const transport_1 = require("@trezor/transport");
-const utils_1 = require("@trezor/utils");
-const constants_1 = require("../constants");
-const method_1 = require("./method");
-const onCallFirmwareUpdate_1 = require("./onCallFirmwareUpdate");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const DataManager_1 = require("../data/DataManager");
-const analyticsInfo_1 = require("../data/analyticsInfo");
-const connectSettings_1 = require("../data/connectSettings");
-const DeviceList_1 = require("../device/DeviceList");
-const StateStorage_1 = require("../device/StateStorage");
-const workflows = tslib_1.__importStar(require("../device/workflow"));
-const events_2 = require("../events");
-const debug_1 = require("../utils/debug");
-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();
+import EventEmitter from "events";
+import { CORE_CALL, CORE_CALL_CANCEL, CORE_EVENT, DEVICE, POPUP, RESPONSE_EVENT, SET_ENABLED_NETWORKS, UI_EVENT, UI_REQUEST, UI_RESPONSE, createDeviceMessage, createResponseMessage, createTransportMessage, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { parseLocalFirmwares } from "@trezor/connect-common/lib/data/connectSettings.js";
+import { noopCreateLogger, noopLogger, setLogWriter } from "@trezor/connect-common/lib/utils/debug.js";
+import { TRANSPORT, TRANSPORT_ERROR } from "@trezor/transport-common";
+import { createDeferred, createLazy, getSynchronize, throwError } from "@trezor/utils";
+import { getMethod } from "./method.js";
+import { onCallFirmwareUpdate } from "./onCallFirmwareUpdate.js";
+import { dispose as disposeBackend } from "../backend/BlockchainLink.js";
+import * as enabledNetworksStore from "../data/enabledNetworksStore.js";
+import { initializeFirmwareConfig } from "../data/firmwareInfo.js";
+import * as firmwareReleaseStore from "../data/firmwareReleaseStore.js";
+import * as localFirmwareStore from "../data/localFirmwareStore.js";
+import { loadProtobufModules } from "../data/protobufLoader.js";
+import * as settingsStore from "../data/settingsStore.js";
+import { DeviceList, assertDeviceListConnected } from "../device/DeviceList.js";
+import { validateState } from "../device/workflow/validateState.js";
+import { createUiPromiseManager } from "../utils/uiPromiseManager.js";
+const createSendCoreMessageWithCallId = (sendCoreMessage, callId) => message => {
+  const isUiRequestMessage = message.event === UI_EVENT && message.type.startsWith('ui-');
+  const hasCallId = 'callId' in message && Boolean(message.callId);
+  if (callId && isUiRequestMessage && !hasCallId) {
+    sendCoreMessage({
+      ...message,
+      callId
+    });
+    return;
+  }
+  sendCoreMessage(message);
 };
-const startInteractionTimeout = context => context.interactionTimeout.start(() => {
-  onPopupClosed(context, 'Interaction timeout');
-});
-const initDevice = async (context, methodCallDevice) => {
-  const {
-    uiPromises,
-    deviceList,
-    sendCoreMessage
-  } = context;
-  (0, DeviceList_1.assertDeviceListConnected)(deviceList);
-  const isWebUsb = deviceList.getActiveTransports().some(t => t.type === 'WebUsbTransport');
+const selectDevice = ({
+  deviceList
+}, methodCallDevice) => {
+  assertDeviceListConnected(deviceList);
   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) {
+    device = deviceList.getOnlyDevice();
   }
   if (!device) {
-    throw constants_1.ERRORS.TypedError('Device_NotFound');
+    throw ERRORS.TypedError('Device_NotFound');
   }
   return device;
 };
@@ -132,244 +53,159 @@ const inner = async (context, method, device) => {
     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));
-    }
+    return Promise.reject(ERRORS.TypedError('Device_FwException', firmwareException));
   }
-  const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
+  const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode);
   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));
+    return Promise.reject(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, {
+    if (method.confirmMissingBackup) {
+      const uiPromise = uiPromises.create(UI_RESPONSE.RECEIVE_CONFIRMATION, device);
+      sendCoreMessage(createUiMessage(UI_REQUEST.REQUEST_CONFIRMATION, {
         view: 'no-backup'
-      }), {
-        device: device.toMessageObject()
+      }, {
+        requestId: uiPromise.requestId
       }));
       const permitted = await uiPromise.promise.then(({
         payload
       }) => payload);
       if (!permitted) {
-        return Promise.reject(constants_1.ERRORS.TypedError('Method_PermissionsNotGranted'));
+        return Promise.reject(ERRORS.TypedError('Method_PermissionsNotGranted'));
       }
     }
-    await waitForPopup(context);
-    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.DEVICE_NEEDS_BACKUP, device.toMessageObject()));
+    sendCoreMessage(createUiMessage(UI_REQUEST.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));
+    sendCoreMessage(createUiMessage(UI_REQUEST.FIRMWARE_OUTDATED, device.toMessageObject()));
+  }
+  if (method.useDeviceState) {
+    await validateState({
+      device,
+      method,
+      signal: context.signal,
+      sendCoreMessage
+    });
   }
   try {
-    const response = await method.run();
-    return (0, events_2.createResponseMessage)(method.responseID, true, response, device);
+    const response = await method.run({
+      sendCoreMessage,
+      createUiPromise: uiPromises.create
+    });
+    return createResponseMessage(method.responseID, true, response, {
+      path: device.getUniquePath(),
+      state: device.getState(),
+      instance: device.getInstance()
+    });
   } 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');
+  if (!message.id || !message.payload || message.type !== CORE_CALL) {
+    throw ERRORS.TypedError('Method_InvalidParameter', 'onCall: message.id or message.payload is missing');
   }
   const {
     uiPromises,
     callMethods,
     methodSynchronize,
     resolveWaitForFirstMethod,
-    sendCoreMessage
+    sendCoreMessage,
+    logger
   } = 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();
+      logger.debug('loading method...');
+      const method2 = await getMethod(message);
+      logger.debug('method selected', method2.name);
       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, {
+    sendCoreMessage(createResponseMessage(responseID, false, {
       error
     }));
     return Promise.resolve();
   }
-  if (method.payload.__info) {
+  if (message.payload.__info) {
     const response = method.getMethodInfo();
-    if (method.payload.__precomposed) {
+    if (message.payload.__precomposed) {
       response.precomposed = await method.payloadToPrecomposed();
     }
-    sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, true, response));
+    sendCoreMessage(createResponseMessage(method.responseID, true, response));
     return Promise.resolve();
   }
+  const sendCoreMessageWithCallId = createSendCoreMessageWithCallId(sendCoreMessage, method.callId);
+  const methodContext = {
+    ...context,
+    sendCoreMessage: sendCoreMessageWithCallId
+  };
   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));
+      const response = await method.run({
+        sendCoreMessage: sendCoreMessageWithCallId,
+        createUiPromise: uiPromises.create
+      });
+      sendCoreMessageWithCallId(createResponseMessage(method.responseID, true, response));
     } catch (error) {
-      sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, false, {
+      sendCoreMessageWithCallId(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);
+  return await onCallDevice(methodContext, message, method);
 };
 const onCallDevice = async (context, message, method) => {
   const {
     deviceList,
     callMethods,
-    sendCoreMessage
+    sendCoreMessage,
+    logger
   } = context;
   const responseID = message.id;
   const {
-    origin,
-    env,
-    useCoreInPopup,
-    transports
-  } = DataManager_1.DataManager.getSettings();
+    transports,
+    pendingTransportEvent
+  } = settingsStore.get();
   if (!deviceList.isConnected() && !deviceList.pendingConnection()) {
     deviceList.init({
-      transports
+      transports,
+      pendingTransportEvent
     });
   }
   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;
+  try {
+    tempDevice = selectDevice(context, message.payload.device);
+  } catch (error) {
+    if (error.code === 'Transport_Missing') {
+      sendCoreMessage(createUiMessage(UI_REQUEST.TRANSPORT));
     }
+    sendCoreMessage(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());
+  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');
+    const overrideError = ERRORS.TypedError('Method_Override');
     await device.interrupt(overrideError);
     if (method.overridden) {
-      sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, false, {
+      sendCoreMessage(createResponseMessage(method.responseID, false, {
         error: overrideError
       }));
       throw overrideError;
@@ -378,20 +214,16 @@ const onCallDevice = async (context, message, method) => {
     if (device.isUnacquired()) {
       await device.currentRun;
     } else {
-      sendCoreMessage((0, events_2.createResponseMessage)(responseID, false, {
-        error: constants_1.ERRORS.TypedError('Device_CallInProgress')
+      sendCoreMessage(createResponseMessage(responseID, false, {
+        error: ERRORS.TypedError('Device_CallInProgress')
       }));
-      throw constants_1.ERRORS.TypedError('Device_CallInProgress');
+      throw ERRORS.TypedError('Device_CallInProgress');
     }
   }
   device.setInstance(message.payload.device?.instance);
-  if (method.hasExpectedDeviceState) {
-    device.setState(method.deviceState);
-  }
+  device.setState(method.deviceState);
   registerDeviceEvents(context, method)(device);
-  if (useCoreInPopup && env === 'webextension' && origin) {
-    device.initStorage(new StateStorage_1.WebextensionStateStorage(origin));
-  }
+  method.resolveCardanoCapability();
   let messageResponse;
   try {
     const innerAction = () => inner(context, method, device).then(response => {
@@ -404,29 +236,26 @@ const onCallDevice = async (context, message, method) => {
     });
   } catch (error) {
     if (error.cause) {
-      _log.debug('device.run error caught, caused by:', error.cause);
+      logger.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) {
+      if (deviceList.isConnected() && error.message === TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS) {
         await deviceList.enumerate();
       }
-      messageResponse = (0, events_2.createResponseMessage)(method.responseID, false, {
+      messageResponse = 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()));
+      device.emitDeviceChanged();
     }
     const response = messageResponse;
     if (response) {
       device.eventNames().forEach(e => device.removeAllListeners(e));
-      if (useCoreInPopup) {
-        sendCoreMessage(response);
-      }
       closePopup(context);
       cleanup(context);
       if (method) {
@@ -435,55 +264,38 @@ const onCallDevice = async (context, message, method) => {
       if (response.success) {
         deviceList.removeAuthPenalty(device);
       }
-      if (!useCoreInPopup) {
-        sendCoreMessage(response);
-      }
+      sendCoreMessage(response);
     }
   }
 };
 const cleanup = ({
   uiPromises,
-  popupPromise,
-  interactionTimeout
+  logger
 }) => {
-  popupPromise.clear();
   uiPromises.clear();
-  interactionTimeout.stop();
-  _log.debug('Cleanup...');
+  logger.debug('Cleanup...');
 };
 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));
+  sendCoreMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
 };
-const onDeviceButtonHandler = (device, context, method) => async ({
+const onDeviceButtonHandler = (device, context, method) => ({
   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, {
+  sendCoreMessage(createDeviceMessage(DEVICE.BUTTON, {
     ...request,
     device: device.toMessageObject()
   }));
-  sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.REQUEST_BUTTON, {
+  sendCoreMessage(createUiMessage(UI_REQUEST.REQUEST_BUTTON, {
     ...request,
     device: device.toMessageObject(),
     data
   }));
-  if (addressRequest && !method?.useUi) {
-    sendCoreMessage((0, events_2.createUiMessage)(events_2.UI.ADDRESS_VALIDATION, data));
-  }
 };
 const onDevicePinHandler = (device, context) => async ({
   type,
@@ -493,18 +305,19 @@ const onDevicePinHandler = (device, context) => async ({
     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, {
+  const uiPromise = uiPromises.create(UI_RESPONSE.RECEIVE_PIN, device);
+  sendCoreMessage(createUiMessage(UI_REQUEST.REQUEST_PIN, {
     device: device.toMessageObject(),
     type
+  }, {
+    requestId: uiPromise.requestId
   }));
   try {
     const uiResp = await uiPromise.promise;
     if (uiResp.payload == null) {
       callback({
         success: false,
-        error: new Error(`${events_2.UI.RECEIVE_PIN} missing payload`)
+        error: new Error(`${UI_RESPONSE.RECEIVE_PIN} missing payload`)
       });
     } else {
       callback({
@@ -527,18 +340,19 @@ const onDeviceWordHandler = (device, context) => async ({
     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, {
+  const uiPromise = uiPromises.create(UI_RESPONSE.RECEIVE_WORD, device);
+  sendCoreMessage(createUiMessage(UI_REQUEST.REQUEST_WORD, {
     device: device.toMessageObject(),
     type
+  }, {
+    requestId: uiPromise.requestId
   }));
   try {
     const uiResp = await uiPromise.promise;
     if (uiResp.payload == null) {
       callback({
         success: false,
-        error: new Error(`${events_2.UI.RECEIVE_WORD} missing payload`)
+        error: new Error(`${UI_RESPONSE.RECEIVE_WORD} missing payload`)
       });
     } else {
       callback({
@@ -560,17 +374,18 @@ const onDevicePassphraseHandler = (device, context) => async ({
     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, {
+  const uiPromise = uiPromises.create(UI_RESPONSE.RECEIVE_PASSPHRASE, device);
+  sendCoreMessage(createUiMessage(UI_REQUEST.REQUEST_PASSPHRASE, {
     device: device.toMessageObject()
+  }, {
+    requestId: uiPromise.requestId
   }));
   try {
     const uiResp = await uiPromise.promise;
     if (uiResp.payload == null) {
       callback({
         success: false,
-        error: new Error(`${events_2.UI.RECEIVE_PASSPHRASE} missing payload`)
+        error: new Error(`${UI_RESPONSE.RECEIVE_PASSPHRASE} missing payload`)
       });
     } else {
       callback({
@@ -603,18 +418,19 @@ const onThpPairingHandler = (device, context) => async ({
     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, {
+  const uiPromise = uiPromises.create(UI_RESPONSE.RECEIVE_THP_PAIRING_TAG, device);
+  sendCoreMessage(createUiMessage(UI_REQUEST.REQUEST_THP_PAIRING, {
     device: device.toMessageObject(),
     ...payload
+  }, {
+    requestId: uiPromise.requestId
   }));
   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`)
+        error: new Error(`${UI_RESPONSE.RECEIVE_THP_PAIRING_TAG} missing payload`)
       });
     } else {
       callback({
@@ -633,50 +449,72 @@ const onThpCredentialsChangedHandler = (device, context) => payload => {
   const {
     sendCoreMessage
   } = context;
-  sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.THP_CREDENTIALS_CHANGED, {
+  sendCoreMessage(createDeviceMessage(DEVICE.THP_CREDENTIALS_CHANGED, {
+    device: device.toMessageObject(),
+    ...payload
+  }));
+};
+const onThpPhaseChangedHandler = (device, context) => payload => {
+  const {
+    sendCoreMessage
+  } = context;
+  sendCoreMessage(createDeviceMessage(DEVICE.THP_PAIRING_STATUS_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.on(DEVICE.BUTTON, onDeviceButtonHandler(device, context, method));
+  device.on(DEVICE.PIN, onDevicePinHandler(device, context));
+  device.on(DEVICE.WORD, onDeviceWordHandler(device, context));
+  device.on(DEVICE.PASSPHRASE, (method?.useEmptyPassphrase ? onEmptyPassphraseHandler : onDevicePassphraseHandler)(device, context));
+  device.on(DEVICE.PASSPHRASE_ON_DEVICE, () => {
+    context.sendCoreMessage(createUiMessage(UI_REQUEST.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(DEVICE.FIRMWARE_VERSION_CHANGED, payload => {
+    context.sendCoreMessage(createDeviceMessage(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));
+  device.on(DEVICE.THP_PAIRING, onThpPairingHandler(device, context));
+  device.on(DEVICE.THP_CREDENTIALS_CHANGED, onThpCredentialsChangedHandler(device, context));
+  device.on(DEVICE.THP_PAIRING_STATUS_CHANGED, onThpPhaseChangedHandler(device, context));
 };
-const onPopupClosed = (context, customErrorMessage) => {
+const abortRunningCall = (context, error, callId) => {
   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 (callId) {
+    const method = callMethods.find(m => m.callId === callId);
+    if (!method) {
+      return;
+    }
+    if (method.device?.isUsedHere()) {
+      method.device.interrupt(error);
+    } else {
+      sendCoreMessage(createResponseMessage(method.responseID, false, {
+        error
+      }));
+    }
+    return;
+  }
   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,
+          type: DEVICE.DISCONNECT,
           payload: undefined
         });
         if (!success) {
           callMethods.forEach(m => {
-            sendCoreMessage((0, events_2.createResponseMessage)(m.responseID, false, {
+            sendCoreMessage(createResponseMessage(m.responseID, false, {
               error
             }));
           });
@@ -687,117 +525,81 @@ const onPopupClosed = (context, customErrorMessage) => {
     });
   } 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 onPopupClosed = context => {
+  abortRunningCall(context, ERRORS.TypedError('Method_Interrupted'));
+};
+const onCallCancel = (context, reason, callId) => {
+  abortRunningCall(context, ERRORS.TypedError('Method_Cancel', reason), callId);
 };
 const initDeviceList = context => {
   const {
     deviceList,
-    sendCoreMessage
+    sendCoreMessage,
+    logger
   } = context;
-  deviceList.on(events_2.DEVICE.CONNECT, device => {
-    handleDeviceSelectionChanges(context);
-    sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CONNECT, device.toMessageObject()));
+  deviceList.on(DEVICE.CONNECT, device => {
+    sendCoreMessage(createDeviceMessage(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(DEVICE.CONNECT_UNACQUIRED, device => {
+    sendCoreMessage(createDeviceMessage(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(DEVICE.DISCONNECT, device => {
+    sendCoreMessage(createDeviceMessage(DEVICE.DISCONNECT, device.toMessageObject()));
   });
-  deviceList.on(events_2.DEVICE.CHANGED, device => {
-    sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.CHANGED, device.toMessageObject()));
+  deviceList.on(DEVICE.CHANGED, device => {
+    sendCoreMessage(createDeviceMessage(DEVICE.CHANGED, device.toMessageObject()));
   });
-  deviceList.on(events_2.DEVICE.TREZOR_PUSH_NOTIFICATION, payload => {
-    sendCoreMessage((0, events_2.createDeviceMessage)(events_2.DEVICE.TREZOR_PUSH_NOTIFICATION, {
+  deviceList.on(DEVICE.TREZOR_PUSH_NOTIFICATION, payload => {
+    sendCoreMessage(createDeviceMessage(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));
+  deviceList.on(TRANSPORT.START, transport => sendCoreMessage(createTransportMessage(TRANSPORT.START, transport)));
+  deviceList.on(TRANSPORT.ERROR, error => {
+    logger.warn('TRANSPORT.ERROR', error.error);
+    sendCoreMessage(createTransportMessage(TRANSPORT.ERROR, error));
   });
 };
-class Core extends events_1.default {
+export class Core extends EventEmitter {
   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');
-  }
+  methodSynchronize = getSynchronize();
+  uiPromises = createUiPromiseManager();
+  createLogger = noopCreateLogger;
+  coreLogger = noopLogger;
+  waitForFirstMethod = createDeferred();
   _deviceList;
   get deviceList() {
-    return this._deviceList ?? (0, utils_1.throwError)('Core not initialized: deviceList');
+    return this._deviceList ?? 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 (message.event === RESPONSE_EVENT) {
+      const index = this.callMethods.findIndex(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.waitForFirstMethod = createDeferred();
         }
       }
     }
-    this.emit(events_2.CORE_EVENT, message);
+    this.emit(CORE_EVENT, message);
   }
   getCoreContext() {
     return {
       signal: this.abortController.signal,
       uiPromises: this.uiPromises,
-      popupPromise: this.popupPromise,
-      interactionTimeout: this.interactionTimeout,
       deviceList: this.deviceList,
+      logger: this.coreLogger,
       callMethods: this.callMethods,
       methodSynchronize: this.methodSynchronize,
       sendCoreMessage: this.sendCoreMessage.bind(this),
       resetWaitForFirstMethod: () => {
-        this.waitForFirstMethod = (0, utils_1.createDeferred)();
+        this.waitForFirstMethod = createDeferred();
       },
       resolveWaitForFirstMethod: () => {
         this.waitForFirstMethod.resolve();
@@ -805,93 +607,97 @@ class Core extends events_1.default {
     };
   }
   handleMessage(message) {
-    _log.debug('handleMessage', message.type);
+    this.coreLogger.debug('handleMessage', message.type);
     switch (message.type) {
-      case events_2.POPUP.HANDSHAKE:
-        this.popupPromise.resolve();
+      case POPUP.CLOSED:
+        onPopupClosed(this.getCoreContext());
         break;
-      case events_2.POPUP.CLOSED:
-        this.popupPromise.clear();
-        onPopupClosed(this.getCoreContext(), message.payload ? message.payload.error : null);
+      case CORE_CALL_CANCEL:
+        onCallCancel(this.getCoreContext(), message.payload?.reason, message.payload?.callId);
         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;
+      case TRANSPORT.SET_TRANSPORTS:
+        settingsStore.update({
+          transports: message.payload.transports
+        });
         resetTransports(this.getCoreContext());
         break;
-      case transport_1.TRANSPORT.REQUEST_DEVICE:
+      case SET_ENABLED_NETWORKS:
+        enabledNetworksStore.add(message.payload);
+        break;
+      case 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()));
+      case TRANSPORT.GET_INFO:
+        this.sendCoreMessage(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:
+      case UI_RESPONSE.RECEIVE_CONFIRMATION:
+      case UI_RESPONSE.RECEIVE_PIN:
+      case UI_RESPONSE.RECEIVE_PASSPHRASE:
+      case UI_RESPONSE.RECEIVE_THP_PAIRING_TAG:
+      case UI_RESPONSE.RECEIVE_ACCOUNT:
+      case UI_RESPONSE.RECEIVE_FEE:
+      case UI_RESPONSE.RECEIVE_WORD:
+      case UI_RESPONSE.RECEIVE_DISCOVERY_ACCOUNTS:
         this.uiPromises.resolve(message);
         break;
-      case events_2.UI.RECEIVE_FIRMWARE:
+      case UI_RESPONSE.RECEIVE_FIRMWARE:
         {
-          const localFirmwares = message.payload && (0, connectSettings_1.parseLocalFirmwares)(message.payload);
+          const localFirmwares = message.payload && parseLocalFirmwares(message.payload);
           if (localFirmwares) {
-            DataManager_1.DataManager.setLocalFirmwares(localFirmwares);
+            localFirmwareStore.set(localFirmwares);
           }
           break;
         }
-      case events_2.IFRAME.CALL:
+      case CORE_CALL:
         if (message.payload.method === 'firmwareUpdate') {
-          (0, DeviceList_1.assertDeviceListConnected)(this.deviceList);
+          if (message.payload.__info) {
+            this.sendCoreMessage(createResponseMessage(message.id, true, {
+              name: 'firmwareUpdate',
+              info: 'Update firmware',
+              requiredPermissions: [{
+                permission: 'internal'
+              }],
+              useUi: true,
+              useDevice: true,
+              useDeviceState: false
+            }));
+            break;
+          }
+          assertDeviceListConnected(this.deviceList);
           const coreContext = this.getCoreContext();
-          (0, onCallFirmwareUpdate_1.onCallFirmwareUpdate)({
+          const sendCoreMessageWithCallId = createSendCoreMessageWithCallId(this.sendCoreMessage.bind(this), message.payload.callId);
+          onCallFirmwareUpdate({
             params: message.payload,
             context: {
               deviceList: this.deviceList,
-              postMessage: this.sendCoreMessage.bind(this),
-              initDevice: path => initDevice(coreContext, {
+              postMessage: sendCoreMessageWithCallId,
+              selectDevice: path => selectDevice(coreContext, {
                 path
               }),
-              log: _log,
+              log: this.coreLogger,
               abortSignal: this.abortController.signal,
               registerEvents: registerDeviceEvents(coreContext),
               uiPromises: coreContext.uiPromises
             }
           }).then(payload => {
-            this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, true, payload));
+            this.sendCoreMessage(createResponseMessage(message.id, true, payload));
           }).catch(error => {
-            this.sendCoreMessage((0, events_2.createResponseMessage)(message.id, false, {
+            this.sendCoreMessage(createResponseMessage(message.id, false, {
               error
             }));
-            _log.error('onCallFirmwareUpdate', error);
+            this.coreLogger.error('onCallFirmwareUpdate', error);
           });
         } else {
           onCall(this.getCoreContext(), message).catch(error => {
-            _log.error('onCall', error);
+            this.coreLogger.error('onCall', error);
           });
         }
     }
   }
   dispose() {
-    (0, BlockchainLink_1.dispose)();
+    disposeBackend();
     this.removeAllListeners();
     this.abortController.abort();
     this.deviceList.dispose();
@@ -912,44 +718,40 @@ class Core extends events_1.default {
   }
   async init(settings, onCoreEvent, logWriterFactory) {
     if (logWriterFactory) {
-      (0, debug_1.setLogWriter)(logWriterFactory);
+      setLogWriter(logWriterFactory);
     }
-    const throttlePromise = (0, utils_1.createDeferred)();
+    this.createLogger = settings.createLogger ?? noopCreateLogger;
+    this.coreLogger = this.createLogger('Core');
+    const throttlePromise = 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);
+      settingsStore.set({
+        ...settings,
+        enabledNetworks: undefined
+      });
+      enabledNetworksStore.set(settings.enabledNetworks ?? []);
+      await firmwareReleaseStore.init(settings.firmwareChannel, false, initializeFirmwareConfig);
+      const localFirmwares = settings.localFirmwares && parseLocalFirmwares(settings.localFirmwares);
       if (localFirmwares) {
-        DataManager_1.DataManager.setLocalFirmwares(localFirmwares);
+        localFirmwareStore.set(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
+      await loadProtobufModules();
+      this._deviceList = new DeviceList({
+        createLogger: this.createLogger
       });
       initDeviceList(this.getCoreContext());
-      this.on(events_2.CORE_EVENT, onCoreEventThrottled);
+      this.on(CORE_EVENT, onCoreEventThrottled);
     } catch (error) {
-      _log.error('init', error);
+      this.coreLogger.error('init', error);
       throttlePromise.reject(error);
       throw error;
     }
     const {
       transports,
       pendingTransportEvent,
-      transportReconnect,
-      coreMode
-    } = DataManager_1.DataManager.getSettings();
+      transportReconnect
+    } = settingsStore.get();
     try {
       this.deviceList.init({
         transports,
@@ -957,21 +759,20 @@ class Core extends events_1.default {
         transportReconnect
       });
     } catch (error) {
-      this.sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, {
+      this.sendCoreMessage(createTransportMessage(TRANSPORT.ERROR, {
         error
       }));
       throttlePromise.reject(error);
       throw error;
     }
-    if (!transportReconnect || coreMode === 'auto') {
+    if (!transportReconnect) {
       await this.deviceList.pendingConnection();
     }
-    this.on(events_2.CORE_EVENT, onCoreEvent);
-    this.off(events_2.CORE_EVENT, onCoreEventThrottled);
+    this.on(CORE_EVENT, onCoreEvent);
+    this.off(CORE_EVENT, onCoreEventThrottled);
     setTimeout(throttlePromise.resolve, 0);
   }
 }
-exports.Core = Core;
 const resetTransports = async ({
   deviceList,
   sendCoreMessage
@@ -980,7 +781,7 @@ const resetTransports = async ({
     transports,
     pendingTransportEvent,
     transportReconnect
-  } = DataManager_1.DataManager.getSettings();
+  } = settingsStore.get();
   try {
     await deviceList.init({
       transports,
@@ -988,7 +789,7 @@ const resetTransports = async ({
       transportReconnect
     });
   } catch (error) {
-    sendCoreMessage((0, events_2.createTransportMessage)(transport_1.TRANSPORT.ERROR, {
+    sendCoreMessage(createTransportMessage(TRANSPORT.ERROR, {
       error
     }));
   }
@@ -1001,6 +802,4 @@ const initCore = async (...params) => {
 const disposeCore = core => {
   core.dispose();
 };
-const initCoreState = () => (0, utils_1.createLazy)(initCore, disposeCore);
-exports.initCoreState = initCoreState;
-//# sourceMappingURL=index.js.map
+export const initCoreState = () => createLazy(initCore, disposeCore);