@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/core/index.mjs

@@ -0,0 +1,795 @@
+import EventEmitter from "events";
+import { CORE_CALL, CORE_CALL_CANCEL, CORE_EVENT, DEVICE, POPUP, RESPONSE_EVENT, UI_EVENT, UI_REQUEST, UI_RESPONSE, createDeviceMessage, createResponseMessage, createTransportMessage, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { parseLocalFirmwares } from "@trezor/connect-common/libESM/data/connectSettings.mjs";
+import { enableLog, initLog, setLogWriter } from "@trezor/connect-common/libESM/utils/debug.mjs";
+import { TRANSPORT, TRANSPORT_ERROR } from "@trezor/transport";
+import { createDeferred, createLazy, getSynchronize, throwError } from "@trezor/utils";
+import { getMethod } from "./method.mjs";
+import { onCallFirmwareUpdate } from "./onCallFirmwareUpdate.mjs";
+import { dispose as disposeBackend } from "../backend/BlockchainLink.mjs";
+import { initializeFirmwareConfig } from "../data/firmwareInfo.mjs";
+import * as firmwareReleaseStore from "../data/firmwareReleaseStore.mjs";
+import * as localFirmwareStore from "../data/localFirmwareStore.mjs";
+import { loadProtobufModules } from "../data/protobufLoader.mjs";
+import * as settingsStore from "../data/settingsStore.mjs";
+import { DeviceList, assertDeviceListConnected } from "../device/DeviceList.mjs";
+import { validateState } from "../device/workflow/validateState.mjs";
+import { createUiPromiseManager } from "../utils/uiPromiseManager.mjs";
+const _log = initLog('Core');
+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 selectDevice = ({
+  deviceList
+}, methodCallDevice) => {
+  assertDeviceListConnected(deviceList);
+  let device;
+  if (methodCallDevice?.state?.staticSessionId) {
+    device = deviceList.getDeviceByStaticState(methodCallDevice.state.staticSessionId);
+  }
+  if (!device && methodCallDevice?.path) {
+    device = deviceList.getDeviceByPath(methodCallDevice.path);
+  }
+  if (!device) {
+    device = deviceList.getOnlyDevice();
+  }
+  if (!device) {
+    throw ERRORS.TypedError('Device_NotFound');
+  }
+  return device;
+};
+const inner = async (context, method, device) => {
+  const {
+    uiPromises,
+    sendCoreMessage
+  } = context;
+  const firmwareException = method.checkFirmwareRange();
+  if (firmwareException) {
+    return Promise.reject(ERRORS.TypedError('Device_FwException', firmwareException));
+  }
+  const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode);
+  if (unexpectedMode) {
+    return Promise.reject(ERRORS.TypedError('Device_ModeException', unexpectedMode));
+  }
+  method.checkDeviceCapability();
+  const deviceNeedsBackup = device.features.backup_availability === 'Required';
+  if (deviceNeedsBackup) {
+    if (method.confirmMissingBackup) {
+      const uiPromise = uiPromises.create(UI_RESPONSE.RECEIVE_CONFIRMATION, device);
+      sendCoreMessage(createUiMessage(UI_REQUEST.REQUEST_CONFIRMATION, {
+        view: 'no-backup'
+      }, {
+        requestId: uiPromise.requestId
+      }));
+      const permitted = await uiPromise.promise.then(({
+        payload
+      }) => payload);
+      if (!permitted) {
+        return Promise.reject(ERRORS.TypedError('Method_PermissionsNotGranted'));
+      }
+    }
+    sendCoreMessage(createUiMessage(UI_REQUEST.DEVICE_NEEDS_BACKUP, device.toMessageObject()));
+  }
+  if (device.firmwareStatus === 'outdated') {
+    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({
+      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 !== CORE_CALL) {
+    throw 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 getMethod(message);
+      _log.debug('method selected', method2.name);
+      await method2.initAsync?.();
+      return method2;
+    });
+    resolveWaitForFirstMethod();
+    callMethods.push(method);
+  } catch (error) {
+    sendCoreMessage(createResponseMessage(responseID, false, {
+      error
+    }));
+    return Promise.resolve();
+  }
+  if (message.payload.__info) {
+    const response = method.getMethodInfo();
+    if (message.payload.__precomposed) {
+      response.precomposed = await method.payloadToPrecomposed();
+    }
+    sendCoreMessage(createResponseMessage(method.responseID, true, response));
+    return Promise.resolve();
+  }
+  const sendCoreMessageWithCallId = createSendCoreMessageWithCallId(sendCoreMessage, method.callId);
+  const methodContext = {
+    ...context,
+    sendCoreMessage: sendCoreMessageWithCallId
+  };
+  if (!method.useDevice) {
+    try {
+      const response = await method.run({
+        sendCoreMessage: sendCoreMessageWithCallId,
+        createUiPromise: uiPromises.create
+      });
+      sendCoreMessageWithCallId(createResponseMessage(method.responseID, true, response));
+    } catch (error) {
+      sendCoreMessageWithCallId(createResponseMessage(method.responseID, false, {
+        error
+      }));
+    }
+    return Promise.resolve();
+  }
+  return await onCallDevice(methodContext, message, method);
+};
+const onCallDevice = async (context, message, method) => {
+  const {
+    deviceList,
+    callMethods,
+    sendCoreMessage
+  } = context;
+  const responseID = message.id;
+  const {
+    env,
+    transports,
+    pendingTransportEvent
+  } = settingsStore.get();
+  if (!deviceList.isConnected() && !deviceList.pendingConnection()) {
+    deviceList.init({
+      transports,
+      pendingTransportEvent
+    });
+  }
+  await deviceList.pendingConnection();
+  const shouldRetry = ['web', 'webextension'].includes(env);
+  let tempDevice;
+  while (!tempDevice) {
+    try {
+      tempDevice = selectDevice(context, message.payload.device);
+    } catch (error) {
+      if (error.code === 'Transport_Missing') {
+        sendCoreMessage(createUiMessage(UI_REQUEST.TRANSPORT));
+        if (deviceList.pendingConnection() && shouldRetry) {
+          while (deviceList.pendingConnection()) {
+            await deviceList.pendingConnection();
+          }
+          continue;
+        }
+      }
+      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());
+  if (previousCall.length > 0 && method.overridePreviousCall) {
+    previousCall.forEach(call => {
+      call.overridden = true;
+    });
+    const overrideError = ERRORS.TypedError('Method_Override');
+    await device.interrupt(overrideError);
+    if (method.overridden) {
+      sendCoreMessage(createResponseMessage(method.responseID, false, {
+        error: overrideError
+      }));
+      throw overrideError;
+    }
+  } else if (device.currentRun) {
+    if (device.isUnacquired()) {
+      await device.currentRun;
+    } else {
+      sendCoreMessage(createResponseMessage(responseID, false, {
+        error: ERRORS.TypedError('Device_CallInProgress')
+      }));
+      throw ERRORS.TypedError('Device_CallInProgress');
+    }
+  }
+  device.setInstance(message.payload.device?.instance);
+  device.setState(method.deviceState);
+  registerDeviceEvents(context, method)(device);
+  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_ERROR.SESSION_WRONG_PREVIOUS) {
+        await deviceList.enumerate();
+      }
+      messageResponse = createResponseMessage(method.responseID, false, {
+        error
+      });
+    }
+  } finally {
+    if (method.keepSession && method.deviceState && method.deviceState.sessionId !== device.getState()?.sessionId) {
+      sendCoreMessage(createDeviceMessage(DEVICE.CHANGED, device.toMessageObject()));
+    }
+    const response = messageResponse;
+    if (response) {
+      device.eventNames().forEach(e => device.removeAllListeners(e));
+      closePopup(context);
+      cleanup(context);
+      if (method) {
+        method.dispose();
+      }
+      if (response.success) {
+        deviceList.removeAuthPenalty(device);
+      }
+      sendCoreMessage(response);
+    }
+  }
+};
+const cleanup = ({
+  uiPromises
+}) => {
+  uiPromises.clear();
+  _log.debug('Cleanup...');
+};
+const closePopup = ({
+  sendCoreMessage
+}) => {
+  sendCoreMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
+};
+const onDeviceButtonHandler = (device, context, method) => ({
+  payload: request
+}) => {
+  const {
+    sendCoreMessage
+  } = context;
+  const addressRequest = request.code === 'ButtonRequest_Address';
+  const data = typeof method?.getButtonRequestData === 'function' && request.code ? method?.getButtonRequestData(request.code, request.name) : undefined;
+  sendCoreMessage(createDeviceMessage(DEVICE.BUTTON, {
+    ...request,
+    device: device.toMessageObject()
+  }));
+  sendCoreMessage(createUiMessage(UI_REQUEST.REQUEST_BUTTON, {
+    ...request,
+    device: device.toMessageObject(),
+    data
+  }));
+  if (addressRequest && !method?.useUi) {
+    sendCoreMessage(createUiMessage(UI_REQUEST.ADDRESS_VALIDATION, data));
+  }
+};
+const onDevicePinHandler = (device, context) => async ({
+  type,
+  callback
+}) => {
+  const {
+    uiPromises,
+    sendCoreMessage
+  } = context;
+  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(`${UI_RESPONSE.RECEIVE_PIN} missing payload`)
+      });
+    } else {
+      callback({
+        success: true,
+        payload: uiResp.payload
+      });
+    }
+  } catch (error) {
+    callback({
+      success: false,
+      error
+    });
+  }
+};
+const onDeviceWordHandler = (device, context) => async ({
+  type,
+  callback
+}) => {
+  const {
+    uiPromises,
+    sendCoreMessage
+  } = context;
+  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(`${UI_RESPONSE.RECEIVE_WORD} 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;
+  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(`${UI_RESPONSE.RECEIVE_PASSPHRASE} missing payload`)
+      });
+    } else {
+      callback({
+        success: true,
+        payload: uiResp.payload
+      });
+    }
+  } catch (error) {
+    callback({
+      success: false,
+      error
+    });
+  }
+};
+const onEmptyPassphraseHandler = () => ({
+  callback
+}) => {
+  callback({
+    success: true,
+    payload: {
+      value: ''
+    }
+  });
+};
+const onThpPairingHandler = (device, context) => async ({
+  callback,
+  payload
+}) => {
+  const {
+    uiPromises,
+    sendCoreMessage
+  } = context;
+  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(`${UI_RESPONSE.RECEIVE_THP_PAIRING_TAG} missing payload`)
+      });
+    } else {
+      callback({
+        success: true,
+        payload: uiResp.payload
+      });
+    }
+  } catch (error) {
+    callback({
+      success: false,
+      error
+    });
+  }
+};
+const onThpCredentialsChangedHandler = (device, context) => payload => {
+  const {
+    sendCoreMessage
+  } = context;
+  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(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(DEVICE.FIRMWARE_VERSION_CHANGED, payload => {
+    context.sendCoreMessage(createDeviceMessage(DEVICE.FIRMWARE_VERSION_CHANGED, payload));
+  });
+  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 abortRunningCall = (context, error) => {
+  const {
+    uiPromises,
+    deviceList,
+    callMethods,
+    resetWaitForFirstMethod,
+    sendCoreMessage
+  } = context;
+  if (deviceList.isConnected() && deviceList.getDeviceCount() > 0) {
+    deviceList.getAllDevices().forEach(d => {
+      if (d.isUsedHere()) {
+        d.interrupt(error);
+      } else {
+        const success = uiPromises.resolve({
+          type: DEVICE.DISCONNECT,
+          payload: undefined
+        });
+        if (!success) {
+          callMethods.forEach(m => {
+            sendCoreMessage(createResponseMessage(m.responseID, false, {
+              error
+            }));
+          });
+          callMethods.splice(0, callMethods.length);
+          resetWaitForFirstMethod();
+        }
+      }
+    });
+  } else {
+    uiPromises.rejectAll(error);
+  }
+  cleanup(context);
+};
+const onPopupClosed = context => {
+  abortRunningCall(context, ERRORS.TypedError('Method_Interrupted'));
+};
+const onCallCancel = (context, reason) => {
+  abortRunningCall(context, ERRORS.TypedError('Method_Cancel', reason));
+};
+const initDeviceList = context => {
+  const {
+    deviceList,
+    sendCoreMessage
+  } = context;
+  deviceList.on(DEVICE.CONNECT, device => {
+    sendCoreMessage(createDeviceMessage(DEVICE.CONNECT, device.toMessageObject()));
+  });
+  deviceList.on(DEVICE.CONNECT_UNACQUIRED, device => {
+    sendCoreMessage(createDeviceMessage(DEVICE.CONNECT_UNACQUIRED, device.toMessageObject()));
+  });
+  deviceList.on(DEVICE.DISCONNECT, device => {
+    sendCoreMessage(createDeviceMessage(DEVICE.DISCONNECT, device.toMessageObject()));
+  });
+  deviceList.on(DEVICE.CHANGED, device => {
+    sendCoreMessage(createDeviceMessage(DEVICE.CHANGED, device.toMessageObject()));
+  });
+  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.START, transport => sendCoreMessage(createTransportMessage(TRANSPORT.START, transport)));
+  deviceList.on(TRANSPORT.ERROR, error => {
+    _log.warn('TRANSPORT.ERROR', error.error);
+    sendCoreMessage(createTransportMessage(TRANSPORT.ERROR, error));
+  });
+};
+export class Core extends EventEmitter {
+  abortController = new AbortController();
+  callMethods = [];
+  methodSynchronize = getSynchronize();
+  uiPromises = createUiPromiseManager();
+  waitForFirstMethod = createDeferred();
+  _deviceList;
+  get deviceList() {
+    return this._deviceList ?? throwError('Core not initialized: deviceList');
+  }
+  sendCoreMessage(message) {
+    if (message.event === 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 = createDeferred();
+        }
+      }
+    }
+    this.emit(CORE_EVENT, message);
+  }
+  getCoreContext() {
+    return {
+      signal: this.abortController.signal,
+      uiPromises: this.uiPromises,
+      deviceList: this.deviceList,
+      callMethods: this.callMethods,
+      methodSynchronize: this.methodSynchronize,
+      sendCoreMessage: this.sendCoreMessage.bind(this),
+      resetWaitForFirstMethod: () => {
+        this.waitForFirstMethod = createDeferred();
+      },
+      resolveWaitForFirstMethod: () => {
+        this.waitForFirstMethod.resolve();
+      }
+    };
+  }
+  handleMessage(message) {
+    _log.debug('handleMessage', message.type);
+    switch (message.type) {
+      case POPUP.CLOSED:
+        onPopupClosed(this.getCoreContext());
+        break;
+      case CORE_CALL_CANCEL:
+        onCallCancel(this.getCoreContext(), message.payload?.reason);
+        break;
+      case TRANSPORT.DISABLE_WEBUSB:
+        {
+          const settings = settingsStore.get();
+          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.SET_TRANSPORTS:
+        settingsStore.update({
+          transports: message.payload.transports
+        });
+        resetTransports(this.getCoreContext());
+        break;
+      case TRANSPORT.REQUEST_DEVICE:
+        if (this.deviceList.isConnected()) {
+          this.deviceList.enumerate();
+        }
+        break;
+      case TRANSPORT.GET_INFO:
+        this.sendCoreMessage(createResponseMessage(message.id, true, this.getActiveTransports()));
+        break;
+      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 UI_RESPONSE.RECEIVE_FIRMWARE:
+        {
+          const localFirmwares = message.payload && parseLocalFirmwares(message.payload);
+          if (localFirmwares) {
+            localFirmwareStore.set(localFirmwares);
+          }
+          break;
+        }
+      case CORE_CALL:
+        if (message.payload.method === 'firmwareUpdate') {
+          assertDeviceListConnected(this.deviceList);
+          const coreContext = this.getCoreContext();
+          const sendCoreMessageWithCallId = createSendCoreMessageWithCallId(this.sendCoreMessage.bind(this), message.payload.callId);
+          onCallFirmwareUpdate({
+            params: message.payload,
+            context: {
+              deviceList: this.deviceList,
+              postMessage: sendCoreMessageWithCallId,
+              selectDevice: path => selectDevice(coreContext, {
+                path
+              }),
+              log: _log,
+              abortSignal: this.abortController.signal,
+              registerEvents: registerDeviceEvents(coreContext),
+              uiPromises: coreContext.uiPromises
+            }
+          }).then(payload => {
+            this.sendCoreMessage(createResponseMessage(message.id, true, payload));
+          }).catch(error => {
+            this.sendCoreMessage(createResponseMessage(message.id, false, {
+              error
+            }));
+            _log.error('onCallFirmwareUpdate', error);
+          });
+        } else {
+          onCall(this.getCoreContext(), message).catch(error => {
+            _log.error('onCall', error);
+          });
+        }
+    }
+  }
+  dispose() {
+    disposeBackend();
+    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) {
+      setLogWriter(logWriterFactory);
+    }
+    const throttlePromise = createDeferred();
+    throttlePromise.promise.catch(() => {});
+    const onCoreEventThrottled = message => throttlePromise.promise.then(() => onCoreEvent(message));
+    try {
+      settingsStore.set(settings);
+      await firmwareReleaseStore.init(settings.firmwareChannel, false, initializeFirmwareConfig);
+      const localFirmwares = settings.localFirmwares && parseLocalFirmwares(settings.localFirmwares);
+      if (localFirmwares) {
+        localFirmwareStore.set(localFirmwares);
+      }
+      await loadProtobufModules();
+      const {
+        debug,
+        priority,
+        manifest
+      } = settingsStore.get();
+      enableLog(debug);
+      this._deviceList = new DeviceList({
+        debug,
+        priority,
+        manifest
+      });
+      initDeviceList(this.getCoreContext());
+      this.on(CORE_EVENT, onCoreEventThrottled);
+    } catch (error) {
+      _log.error('init', error);
+      throttlePromise.reject(error);
+      throw error;
+    }
+    const {
+      transports,
+      pendingTransportEvent,
+      transportReconnect,
+      coreMode
+    } = settingsStore.get();
+    try {
+      this.deviceList.init({
+        transports,
+        pendingTransportEvent,
+        transportReconnect
+      });
+    } catch (error) {
+      this.sendCoreMessage(createTransportMessage(TRANSPORT.ERROR, {
+        error
+      }));
+      throttlePromise.reject(error);
+      throw error;
+    }
+    if (!transportReconnect || coreMode === 'auto') {
+      await this.deviceList.pendingConnection();
+    }
+    this.on(CORE_EVENT, onCoreEvent);
+    this.off(CORE_EVENT, onCoreEventThrottled);
+    setTimeout(throttlePromise.resolve, 0);
+  }
+}
+const resetTransports = async ({
+  deviceList,
+  sendCoreMessage
+}) => {
+  const {
+    transports,
+    pendingTransportEvent,
+    transportReconnect
+  } = settingsStore.get();
+  try {
+    await deviceList.init({
+      transports,
+      pendingTransportEvent,
+      transportReconnect
+    });
+  } catch (error) {
+    sendCoreMessage(createTransportMessage(TRANSPORT.ERROR, {
+      error
+    }));
+  }
+};
+const initCore = async (...params) => {
+  const core = new Core();
+  await core.init(...params);
+  return core;
+};
+const disposeCore = core => {
+  core.dispose();
+};
+export const initCoreState = () => createLazy(initCore, disposeCore);