@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.1

package/libESM/core/index.mjs

@@ -1,795 +0,0 @@
-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);