@unwanted/matrix-sdk-mini 34.12.0-2 → 34.12.0-4

package/lib/client.js

@@ -29,30 +29,24 @@ import { EventStatus, MatrixEvent, MatrixEventEvent } from "./models/event.js";
 import { StubStore } from "./store/stub.js";
 import { Filter } from "./filter.js";
 import * as utils from "./utils.js";
-import { noUnsafeEventProps, replaceParam, safeSet, sleep } from "./utils.js";
+import { noUnsafeEventProps, replaceParam, sleep } from "./utils.js";
 import { Direction, EventTimeline } from "./models/event-timeline.js";
 import { PushProcessor } from "./pushprocessor.js";
 import { AutoDiscovery } from "./autodiscovery.js";
-import * as olmlib from "./crypto/olmlib.js";
-import { decodeBase64, encodeBase64, encodeUnpaddedBase64Url } from "./base64.js";
+import { encodeUnpaddedBase64Url } from "./base64.js";
 import { TypedReEmitter } from "./ReEmitter.js";
 import { logger } from "./logger.js";
 import { SERVICE_TYPES } from "./service-types.js";
 import { ClientPrefix, IdentityPrefix, MatrixError, MatrixHttpApi, MediaPrefix, Method, retryNetworkOperation } from "./http-api/index.js";
-import { Crypto, CryptoEvent as LegacyCryptoEvent, fixBackupKey } from "./crypto/index.js";
 import { User, UserEvent } from "./models/user.js";
 import { getHttpUriForMxc } from "./content-repo.js";
 import { SearchResult } from "./models/search-result.js";
-import { DEHYDRATION_ALGORITHM } from "./crypto/dehydration.js";
-import { CrossSigningKey } from "./crypto/api.js";
 import * as ContentHelpers from "./content-helpers.js";
 import { NotificationCountType } from "./models/room.js";
-import { RoomMemberEvent } from "./models/room-member.js";
 import { EventType, LOCAL_NOTIFICATION_SETTINGS_PREFIX, MSC3912_RELATION_BASED_REDACTIONS_PROP, MsgType, PUSHER_ENABLED, RelationType, RoomCreateTypeField, RoomType, UNSTABLE_MSC3088_ENABLED, UNSTABLE_MSC3088_PURPOSE, UNSTABLE_MSC3089_TREE_SUBTYPE } from "./@types/event.js";
 import { GuestAccess, HistoryVisibility, Preset } from "./@types/partials.js";
 import { eventMapperFor } from "./event-mapper.js";
 import { randomString } from "./randomstring.js";
-import { BackupManager } from "./crypto/backup.js";
 import { DEFAULT_TREE_POWER_LEVELS_TEMPLATE, MSC3089TreeSpace } from "./models/MSC3089TreeSpace.js";
 import { SearchOrderBy } from "./@types/search.js";
 import { PushRuleActionName, PushRuleKind } from "./@types/PushRules.js";
@@ -65,17 +59,11 @@ import { NamespacedValue, UnstableValue } from "./NamespacedValue.js";
 import { ToDeviceMessageQueue } from "./ToDeviceMessageQueue.js";
 import { IgnoredInvites } from "./models/invites-ignorer.js";
 import { buildFeatureSupportMap, Feature, ServerSupport } from "./feature.js";
-import { RUST_SDK_STORE_PREFIX } from "./rust-crypto/constants.js";
-import { decodeRecoveryKey, CryptoEvent } from "./crypto-api/index.js";
-import { ServerSideSecretStorageImpl } from "./secret-storage.js";
 import { getRelationsThreadFilter } from "./thread-utils.js";
 import { KnownMembership } from "./@types/membership.js";
 import { ServerCapabilities } from "./serverCapabilities.js";
 import { sha256 } from "./digest.js";
-import { keyFromAuthData } from "./common-crypto/key-passphrase.js";
 var SCROLLBACK_DELAY_MS = 3000;
-var TURN_CHECK_INTERVAL = 10 * 60 * 1000; // poll for turn credentials every 10 minutes
-
 export var UNSTABLE_MSC3852_LAST_SEEN_UA = new UnstableValue("last_seen_user_agent", "org.matrix.msc3852.last_seen_user_agent");
 export var PendingEventOrdering = /*#__PURE__*/function (PendingEventOrdering) {
   PendingEventOrdering["Chronological"] = "chronological";
@@ -88,16 +76,14 @@ export var UNSTABLE_MSC2666_MUTUAL_ROOMS = "uk.half-shot.msc2666.mutual_rooms";
 export var UNSTABLE_MSC2666_QUERY_MUTUAL_ROOMS = "uk.half-shot.msc2666.query_mutual_rooms";
 export var UNSTABLE_MSC4140_DELAYED_EVENTS = "org.matrix.msc4140";
 export var UNSTABLE_MSC4133_EXTENDED_PROFILES = "uk.tcpip.msc4133";
-var CrossSigningKeyType = /*#__PURE__*/function (CrossSigningKeyType) {
-  CrossSigningKeyType["MasterKey"] = "master_key";
-  CrossSigningKeyType["SelfSigningKey"] = "self_signing_key";
-  CrossSigningKeyType["UserSigningKey"] = "user_signing_key";
-  return CrossSigningKeyType;
-}(CrossSigningKeyType || {}); // Re-export for backwards compatibility
+
+// Re-export for backwards compatibility
+
 /**
  * The summary of a room as defined by an initial version of MSC3266 and implemented in Synapse
  * Proposed at https://github.com/matrix-org/matrix-doc/pull/3266
  */
+
 /* eslint-enable camelcase */
 
 // We're using this constant for methods overloading and inspect whether a variable
@@ -129,7 +115,7 @@ var SSO_ACTION_PARAM = new UnstableValue("action", "org.matrix.msc3824.action");
  */
 export class MatrixClient extends TypedEventEmitter {
   constructor(opts) {
-    var _opts$logger, _opts$usingExternalCr, _this, _opts$cryptoCallbacks;
+    var _opts$logger, _opts$usingExternalCr, _this;
     // If a custom logger is provided, use it. Otherwise, default to the global
     // one in logger.ts.
     super();
@@ -159,22 +145,6 @@ export class MatrixClient extends TypedEventEmitter {
     _defineProperty(this, "identityServer", void 0);
     _defineProperty(this, "http", void 0);
     // XXX: Intended private, used in code.
-    /**
-     * The libolm crypto implementation, if it is in use.
-     *
-     * @deprecated This should not be used. Instead, use the methods exposed directly on this class or
-     * (where they are available) via {@link getCrypto}.
-     */
-    _defineProperty(this, "crypto", void 0);
-    // XXX: Intended private, used in code. Being replaced by cryptoBackend
-    _defineProperty(this, "cryptoBackend", void 0);
-    // one of crypto or rustCrypto
-    _defineProperty(this, "cryptoCallbacks", void 0);
-    // XXX: Intended private, used in code.
-    _defineProperty(this, "supportsCallTransfer", false);
-    // XXX: Intended private, used in code.
-    _defineProperty(this, "forceTURN", false);
-    // XXX: Intended private, used in code.
     _defineProperty(this, "iceCandidatePoolSize", 0);
     // XXX: Intended private, used in code.
     _defineProperty(this, "idBaseUrl", void 0);
@@ -183,13 +153,11 @@ export class MatrixClient extends TypedEventEmitter {
     _defineProperty(this, "useLivekitForGroupCalls", void 0);
     // Note: these are all `protected` to let downstream consumers make mistakes if they want to.
     // We don't technically support this usage, but have reasons to do this.
-    _defineProperty(this, "canSupportVoip", false);
     _defineProperty(this, "peekSync", null);
     _defineProperty(this, "isGuestAccount", false);
     _defineProperty(this, "ongoingScrollbacks", {});
     _defineProperty(this, "notifTimelineSet", null);
     /* @deprecated  */
-    _defineProperty(this, "cryptoStore", void 0);
     _defineProperty(this, "verificationMethods", void 0);
     _defineProperty(this, "fallbackICEServerAllowed", false);
     _defineProperty(this, "syncApi", void 0);
@@ -208,10 +176,6 @@ export class MatrixClient extends TypedEventEmitter {
     _defineProperty(this, "serverVersionsPromise", void 0);
     _defineProperty(this, "clientWellKnown", void 0);
     _defineProperty(this, "clientWellKnownPromise", void 0);
-    _defineProperty(this, "turnServers", []);
-    _defineProperty(this, "turnServersExpiry", 0);
-    _defineProperty(this, "checkTurnServersIntervalID", void 0);
-    _defineProperty(this, "exportedOlmDeviceToImport", void 0);
     _defineProperty(this, "txnCtr", 0);
     _defineProperty(this, "sessionId", void 0);
     /** IDs of events which are currently being encrypted.
@@ -220,10 +184,8 @@ export class MatrixClient extends TypedEventEmitter {
      * that tells us that it has been cancelled, and we should not send it.
      */
     _defineProperty(this, "eventsBeingEncrypted", new Set());
-    _defineProperty(this, "useE2eForGroupCall", true);
     _defineProperty(this, "toDeviceMessageQueue", void 0);
     _defineProperty(this, "livekitServiceURL", void 0);
-    _defineProperty(this, "_secretStorage", void 0);
     // A manager for determining which invites should be ignored.
     _defineProperty(this, "ignoredInvites", void 0);
     _defineProperty(this, "serverCapabilitiesService", void 0);
@@ -288,8 +250,6 @@ export class MatrixClient extends TypedEventEmitter {
       } else {
         this.deviceId = opts.deviceToImport.deviceId;
         this.credentials.userId = opts.deviceToImport.userId;
-        // will be used during async initialization of the crypto
-        this.exportedOlmDeviceToImport = opts.deviceToImport.olmDevice;
       }
     } else if (opts.pickleKey) {
       this.pickleKey = opts.pickleKey;
@@ -319,28 +279,14 @@ export class MatrixClient extends TypedEventEmitter {
     this.serverCapabilitiesService = new ServerCapabilities(this.http);
     this.on(ClientEvent.Sync, this.fixupRoomNotifications);
     this.timelineSupport = Boolean(opts.timelineSupport);
-    this.cryptoStore = opts.cryptoStore;
     this.verificationMethods = opts.verificationMethods;
-    this.cryptoCallbacks = opts.cryptoCallbacks || {};
-    this.forceTURN = opts.forceTURN || false;
     this.iceCandidatePoolSize = opts.iceCandidatePoolSize === undefined ? 0 : opts.iceCandidatePoolSize;
-    this.supportsCallTransfer = opts.supportsCallTransfer || false;
     this.fallbackICEServerAllowed = opts.fallbackICEServerAllowed || false;
     this.isVoipWithNoMediaAllowed = opts.isVoipWithNoMediaAllowed || false;
-    if (opts.useE2eForGroupCall !== undefined) this.useE2eForGroupCall = opts.useE2eForGroupCall;
     this.livekitServiceURL = opts.livekitServiceURL;
     this.roomNameGenerator = opts.roomNameGenerator;
     this.toDeviceMessageQueue = new ToDeviceMessageQueue(this);
-
-    // The SDK doesn't really provide a clean way for events to recalculate the push
-    // actions for themselves, so we have to kinda help them out when they are encrypted.
-    // We do this so that push rules are correctly executed on events in their decrypted
-    // state, such as highlights when the user's name is mentioned.
-    this.on(MatrixEventEvent.Decrypted, event => {
-      fixNotificationCountOnDecryption(this, event);
-    });
     this.ignoredInvites = new IgnoredInvites(this);
-    this._secretStorage = new ServerSideSecretStorageImpl(this, (_opts$cryptoCallbacks = opts.cryptoCallbacks) !== null && _opts$cryptoCallbacks !== void 0 ? _opts$cryptoCallbacks : {});
 
     // having lots of event listeners is not unusual. 0 means "unlimited".
     this.setMaxListeners(0);
@@ -375,15 +321,6 @@ export class MatrixClient extends TypedEventEmitter {
       if (userId) {
         _this2.store.storeUser(new User(userId));
       }
-
-      // periodically poll for turn servers if we support voip
-      if (_this2.canSupportVoip) {
-        _this2.checkTurnServersIntervalID = setInterval(() => {
-          _this2.checkTurnServers();
-        }, TURN_CHECK_INTERVAL);
-        // noinspection ES6MissingAwait
-        _this2.checkTurnServers();
-      }
       if (_this2.syncApi) {
         // This shouldn't happen since we thought the client was not running
         _this2.logger.error("Still have sync object whilst not running: stopping old one");
@@ -407,7 +344,7 @@ export class MatrixClient extends TypedEventEmitter {
       }
       _this2.clientOpts = opts !== null && opts !== void 0 ? opts : {};
       if (_this2.clientOpts.slidingSync) {
-        _this2.syncApi = new SlidingSyncSdk(_this2.clientOpts.slidingSync, _this2, _this2.clientOpts, _this2.buildSyncApiOptions());
+        _this2.syncApi = new SlidingSyncSdk(_this2.clientOpts.slidingSync, _this2, _this2.clientOpts);
       } else {
         _this2.syncApi = new SyncApi(_this2, _this2.clientOpts, _this2.buildSyncApiOptions());
       }
@@ -428,8 +365,6 @@ export class MatrixClient extends TypedEventEmitter {
    */
   buildSyncApiOptions() {
     return {
-      crypto: this.crypto,
-      cryptoCallbacks: this.cryptoBackend,
       canResetEntireTimeline: roomId => {
         if (!this.canResetTimelineCallback) {
           return false;
@@ -444,9 +379,7 @@ export class MatrixClient extends TypedEventEmitter {
    * clean shutdown.
    */
   stopClient() {
-    var _this$cryptoBackend, _this$syncApi, _this$peekSync;
-    (_this$cryptoBackend = this.cryptoBackend) === null || _this$cryptoBackend === void 0 || _this$cryptoBackend.stop(); // crypto might have been initialised even if the client wasn't fully started
-
+    var _this$syncApi, _this$peekSync;
     if (!this.clientRunning) return; // already stopped
 
     this.logger.debug("stopping MatrixClient");
@@ -454,8 +387,6 @@ export class MatrixClient extends TypedEventEmitter {
     (_this$syncApi = this.syncApi) === null || _this$syncApi === void 0 || _this$syncApi.stop();
     this.syncApi = undefined;
     (_this$peekSync = this.peekSync) === null || _this$peekSync === void 0 || _this$peekSync.stopPeeking();
-    globalThis.clearInterval(this.checkTurnServersIntervalID);
-    this.checkTurnServersIntervalID = undefined;
     if (this.clientWellKnownIntervalID !== undefined) {
       globalThis.clearInterval(this.clientWellKnownIntervalID);
     }
@@ -463,219 +394,17 @@ export class MatrixClient extends TypedEventEmitter {
     this.serverCapabilitiesService.stop();
   }
 
-  /**
-   * Try to rehydrate a device if available.  The client must have been
-   * initialized with a `cryptoCallback.getDehydrationKey` option, and this
-   * function must be called before initCrypto and startClient are called.
-   *
-   * @returns Promise which resolves to undefined if a device could not be dehydrated, or
-   *     to the new device ID if the dehydration was successful.
-   * @returns Rejects: with an error response.
-   *
-   * @deprecated MSC2697 device dehydration is not supported for rust cryptography.
-   */
-  rehydrateDevice() {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      if (_this3.crypto) {
-        throw new Error("Cannot rehydrate device after crypto is initialized");
-      }
-      if (!_this3.cryptoCallbacks.getDehydrationKey) {
-        return;
-      }
-      var getDeviceResult = yield _this3.getDehydratedDevice();
-      if (!getDeviceResult) {
-        return;
-      }
-      if (!getDeviceResult.device_data || !getDeviceResult.device_id) {
-        _this3.logger.info("no dehydrated device found");
-        return;
-      }
-      var account = new globalThis.Olm.Account();
-      try {
-        var deviceData = getDeviceResult.device_data;
-        if (deviceData.algorithm !== DEHYDRATION_ALGORITHM) {
-          _this3.logger.warn("Wrong algorithm for dehydrated device");
-          return;
-        }
-        _this3.logger.debug("unpickling dehydrated device");
-        var _key = yield _this3.cryptoCallbacks.getDehydrationKey(deviceData, k => {
-          // copy the key so that it doesn't get clobbered
-          account.unpickle(new Uint8Array(k), deviceData.account);
-        });
-        account.unpickle(_key, deviceData.account);
-        _this3.logger.debug("unpickled device");
-        var rehydrateResult = yield _this3.http.authedRequest(Method.Post, "/dehydrated_device/claim", undefined, {
-          device_id: getDeviceResult.device_id
-        }, {
-          prefix: "/_matrix/client/unstable/org.matrix.msc2697.v2"
-        });
-        if (rehydrateResult.success) {
-          _this3.deviceId = getDeviceResult.device_id;
-          _this3.logger.info("using dehydrated device");
-          var pickleKey = _this3.pickleKey || "DEFAULT_KEY";
-          _this3.exportedOlmDeviceToImport = {
-            pickledAccount: account.pickle(pickleKey),
-            sessions: [],
-            pickleKey: pickleKey
-          };
-          account.free();
-          return _this3.deviceId;
-        } else {
-          account.free();
-          _this3.logger.info("not using dehydrated device");
-          return;
-        }
-      } catch (e) {
-        account.free();
-        _this3.logger.warn("could not unpickle", e);
-      }
-    })();
-  }
-
-  /**
-   * Get the current dehydrated device, if any
-   * @returns A promise of an object containing the dehydrated device
-   *
-   * @deprecated MSC2697 device dehydration is not supported for rust cryptography.
-   */
-  getDehydratedDevice() {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      try {
-        return yield _this4.http.authedRequest(Method.Get, "/dehydrated_device", undefined, undefined, {
-          prefix: "/_matrix/client/unstable/org.matrix.msc2697.v2"
-        });
-      } catch (e) {
-        _this4.logger.info("could not get dehydrated device", e);
-        return;
-      }
-    })();
-  }
-
-  /**
-   * Set the dehydration key.  This will also periodically dehydrate devices to
-   * the server.
-   *
-   * @param key - the dehydration key
-   * @param keyInfo - Information about the key.  Primarily for
-   *     information about how to generate the key from a passphrase.
-   * @param deviceDisplayName - The device display name for the
-   *     dehydrated device.
-   * @returns A promise that resolves when the dehydrated device is stored.
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  setDehydrationKey(key, keyInfo, deviceDisplayName) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this5.crypto) {
-        _this5.logger.warn("not dehydrating device if crypto is not enabled");
-        return;
-      }
-      return _this5.crypto.dehydrationManager.setKeyAndQueueDehydration(key, keyInfo, deviceDisplayName);
-    })();
-  }
-
-  /**
-   * Creates a new MSC2967 dehydrated device (without queuing periodic dehydration)
-   * @param key - the dehydration key
-   * @param keyInfo - Information about the key.  Primarily for
-   *     information about how to generate the key from a passphrase.
-   * @param deviceDisplayName - The device display name for the
-   *     dehydrated device.
-   * @returns the device id of the newly created dehydrated device
-   *
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.startDehydration}.
-   */
-  createDehydratedDevice(key, keyInfo, deviceDisplayName) {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this6.crypto) {
-        _this6.logger.warn("not dehydrating device if crypto is not enabled");
-        return;
-      }
-      yield _this6.crypto.dehydrationManager.setKey(key, keyInfo, deviceDisplayName);
-      return _this6.crypto.dehydrationManager.dehydrateDevice();
-    })();
-  }
-
-  /** @deprecated Not supported for Rust Cryptography. */
-  exportDevice() {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this7.crypto) {
-        _this7.logger.warn("not exporting device if crypto is not enabled");
-        return;
-      }
-      return {
-        userId: _this7.credentials.userId,
-        deviceId: _this7.deviceId,
-        // XXX: Private member access.
-        olmDevice: yield _this7.crypto.olmDevice.export()
-      };
-    })();
-  }
-
   /**
    * Clear any data out of the persistent stores used by the client.
    *
    * @returns Promise which resolves when the stores have been cleared.
    */
   clearStores() {
-    var _this8 = this;
     if (this.clientRunning) {
       throw new Error("Cannot clear stores while client is running");
     }
     var promises = [];
     promises.push(this.store.deleteAllData());
-    if (this.cryptoStore) {
-      promises.push(this.cryptoStore.deleteAllData());
-    }
-
-    // delete the stores used by the rust matrix-sdk-crypto, in case they were used
-    var deleteRustSdkStore = /*#__PURE__*/function () {
-      var _ref2 = _asyncToGenerator(function* () {
-        var indexedDB;
-        try {
-          indexedDB = globalThis.indexedDB;
-          if (!indexedDB) return; // No indexedDB support
-        } catch (_unused) {
-          // No indexedDB support
-          return;
-        }
-        var _loop = function* _loop(dbname) {
-          var prom = new Promise((resolve, reject) => {
-            _this8.logger.info("Removing IndexedDB instance ".concat(dbname));
-            var req = indexedDB.deleteDatabase(dbname);
-            req.onsuccess = _ => {
-              _this8.logger.info("Removed IndexedDB instance ".concat(dbname));
-              resolve(0);
-            };
-            req.onerror = e => {
-              // In private browsing, Firefox has a globalThis.indexedDB, but attempts to delete an indexeddb
-              // (even a non-existent one) fail with "DOMException: A mutation operation was attempted on a
-              // database that did not allow mutations."
-              //
-              // it seems like the only thing we can really do is ignore the error.
-              _this8.logger.warn("Failed to remove IndexedDB instance ".concat(dbname, ":"), e);
-              resolve(0);
-            };
-            req.onblocked = e => {
-              _this8.logger.info("cannot yet remove IndexedDB instance ".concat(dbname));
-            };
-          });
-          yield prom;
-        };
-        for (var dbname of ["".concat(RUST_SDK_STORE_PREFIX, "::matrix-sdk-crypto"), "".concat(RUST_SDK_STORE_PREFIX, "::matrix-sdk-crypto-meta")]) {
-          yield* _loop(dbname);
-        }
-      });
-      return function deleteRustSdkStore() {
-        return _ref2.apply(this, arguments);
-      };
-    }();
-    promises.push(deleteRustSdkStore());
     return Promise.all(promises).then(); // .then to fix types
   }
 
@@ -742,41 +471,6 @@ export class MatrixClient extends TypedEventEmitter {
   getSessionId() {
     return this.sessionId;
   }
-
-  /**
-   * Check if the runtime environment supports VoIP calling.
-   * @returns True if VoIP is supported.
-   */
-  supportsVoip() {
-    return this.canSupportVoip;
-  }
-
-  /**
-   * Set whether VoIP calls are forced to use only TURN
-   * candidates. This is the same as the forceTURN option
-   * when creating the client.
-   * @param force - True to force use of TURN servers
-   */
-  setForceTURN(force) {
-    this.forceTURN = force;
-  }
-
-  /**
-   * Set whether to advertise transfer support to other parties on Matrix calls.
-   * @param support - True to advertise the 'm.call.transferee' capability
-   */
-  setSupportsCallTransfer(support) {
-    this.supportsCallTransfer = support;
-  }
-
-  /**
-   * Returns true if to-device signalling for group calls will be encrypted with Olm.
-   * If false, it will be sent unencrypted.
-   * @returns boolean Whether group call signalling will be encrypted
-   */
-  getUseE2eForGroupCall() {
-    return this.useE2eForGroupCall;
-  }
   getLivekitServiceURL() {
     return this.livekitServiceURL;
   }
@@ -882,1879 +576,48 @@ export class MatrixClient extends TypedEventEmitter {
     this.notifTimelineSet = set;
   }
 
-  /**
-   * Gets the cached capabilities of the homeserver, returning cached ones if available.
-   * If there are no cached capabilities and none can be fetched, throw an exception.
-   *
-   * @returns Promise resolving with The capabilities of the homeserver
-   */
-  getCapabilities() {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      var caps = _this9.serverCapabilitiesService.getCachedCapabilities();
-      if (caps) return caps;
-      return _this9.serverCapabilitiesService.fetchCapabilities();
-    })();
-  }
-
-  /**
-   * Gets the cached capabilities of the homeserver. If none have been fetched yet,
-   * return undefined.
-   *
-   * @returns The capabilities of the homeserver
-   */
-  getCachedCapabilities() {
-    return this.serverCapabilitiesService.getCachedCapabilities();
-  }
-
-  /**
-   * Fetches the latest capabilities from the homeserver, ignoring any cached
-   * versions. The newly returned version is cached.
-   *
-   * @returns A promise which resolves to the capabilities of the homeserver
-   */
-  fetchCapabilities() {
-    return this.serverCapabilitiesService.fetchCapabilities();
-  }
-
-  /**
-   * Initialise support for end-to-end encryption in this client, using libolm.
-   *
-   * You should call this method after creating the matrixclient, but *before*
-   * calling `startClient`, if you want to support end-to-end encryption.
-   *
-   * It will return a Promise which will resolve when the crypto layer has been
-   * successfully initialised.
-   *
-   * @deprecated libolm is deprecated. Prefer {@link initRustCrypto}.
-   */
-  initCrypto() {
-    var _this10 = this;
-    return _asyncToGenerator(function* () {
-      if (_this10.cryptoBackend) {
-        _this10.logger.warn("Attempt to re-initialise e2e encryption on MatrixClient");
-        return;
-      }
-      if (!_this10.cryptoStore) {
-        // the cryptostore is provided by sdk.createClient, so this shouldn't happen
-        throw new Error("Cannot enable encryption: no cryptoStore provided");
-      }
-      _this10.logger.debug("Crypto: Starting up crypto store...");
-      yield _this10.cryptoStore.startup();
-      var userId = _this10.getUserId();
-      if (userId === null) {
-        throw new Error("Cannot enable encryption on MatrixClient with unknown userId: " + "ensure userId is passed in createClient().");
-      }
-      if (_this10.deviceId === null) {
-        throw new Error("Cannot enable encryption on MatrixClient with unknown deviceId: " + "ensure deviceId is passed in createClient().");
-      }
-      var crypto = new Crypto(_this10, userId, _this10.deviceId, _this10.store, _this10.cryptoStore, _this10.verificationMethods);
-      _this10.reEmitter.reEmit(crypto, [LegacyCryptoEvent.KeyBackupFailed, LegacyCryptoEvent.KeyBackupSessionsRemaining, LegacyCryptoEvent.RoomKeyRequest, LegacyCryptoEvent.RoomKeyRequestCancellation, LegacyCryptoEvent.Warning, LegacyCryptoEvent.DevicesUpdated, LegacyCryptoEvent.WillUpdateDevices, LegacyCryptoEvent.DeviceVerificationChanged, LegacyCryptoEvent.UserTrustStatusChanged, LegacyCryptoEvent.KeysChanged]);
-      _this10.logger.debug("Crypto: initialising crypto object...");
-      yield crypto.init({
-        exportedOlmDevice: _this10.exportedOlmDeviceToImport,
-        pickleKey: _this10.pickleKey
-      });
-      delete _this10.exportedOlmDeviceToImport;
-      _this10.olmVersion = Crypto.getOlmVersion();
-
-      // if crypto initialisation was successful, tell it to attach its event handlers.
-      crypto.registerEventHandlers(_this10);
-      _this10.cryptoBackend = _this10.crypto = crypto;
-
-      // upload our keys in the background
-      _this10.crypto.uploadDeviceKeys().catch(e => {
-        // TODO: throwing away this error is a really bad idea.
-        _this10.logger.error("Error uploading device keys", e);
-      });
-    })();
-  }
-
-  /**
-   * Initialise support for end-to-end encryption in this client, using the rust matrix-sdk-crypto.
-   *
-   * An alternative to {@link initCrypto}.
-   *
-   * @param args.useIndexedDB - True to use an indexeddb store, false to use an in-memory store. Defaults to 'true'.
-   * @param args.storageKey - A key with which to encrypt the indexeddb store. If provided, it must be exactly
-   *    32 bytes of data, and must be the same each time the client is initialised for a given device.
-   *    If both this and `storagePassword` are unspecified, the store will be unencrypted.
-   * @param args.storagePassword - An alternative to `storageKey`. A password which will be used to derive a key to
-   *    encrypt the store with. Deriving a key from a password is (deliberately) a slow operation, so prefer
-   *    to pass a `storageKey` directly where possible.
-   *
-   * @returns a Promise which will resolve when the crypto layer has been
-   *    successfully initialised.
-   */
-  initRustCrypto() {
-    var _arguments = arguments,
-      _this11 = this;
-    return _asyncToGenerator(function* () {
-      var _this11$pickleKey;
-      var args = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : {};
-      if (_this11.cryptoBackend) {
-        _this11.logger.warn("Attempt to re-initialise e2e encryption on MatrixClient");
-        return;
-      }
-      var userId = _this11.getUserId();
-      if (userId === null) {
-        throw new Error("Cannot enable encryption on MatrixClient with unknown userId: " + "ensure userId is passed in createClient().");
-      }
-      var deviceId = _this11.getDeviceId();
-      if (deviceId === null) {
-        throw new Error("Cannot enable encryption on MatrixClient with unknown deviceId: " + "ensure deviceId is passed in createClient().");
-      }
-
-      // importing rust-crypto will download the webassembly, so we delay it until we know it will be
-      // needed.
-      _this11.logger.debug("Downloading Rust crypto library");
-      var RustCrypto = yield import("./rust-crypto/index.js");
-      var rustCrypto = yield RustCrypto.initRustCrypto({
-        logger: _this11.logger,
-        http: _this11.http,
-        userId: userId,
-        deviceId: deviceId,
-        secretStorage: _this11.secretStorage,
-        cryptoCallbacks: _this11.cryptoCallbacks,
-        storePrefix: args.useIndexedDB === false ? null : RUST_SDK_STORE_PREFIX,
-        storeKey: args.storageKey,
-        storePassphrase: args.storagePassword,
-        legacyCryptoStore: _this11.cryptoStore,
-        legacyPickleKey: (_this11$pickleKey = _this11.pickleKey) !== null && _this11$pickleKey !== void 0 ? _this11$pickleKey : "DEFAULT_KEY",
-        legacyMigrationProgressListener: (progress, total) => {
-          _this11.emit(CryptoEvent.LegacyCryptoStoreMigrationProgress, progress, total);
-        }
-      });
-      rustCrypto.setSupportedVerificationMethods(_this11.verificationMethods);
-      _this11.cryptoBackend = rustCrypto;
-
-      // attach the event listeners needed by RustCrypto
-      _this11.on(RoomMemberEvent.Membership, rustCrypto.onRoomMembership.bind(rustCrypto));
-      _this11.on(ClientEvent.Event, event => {
-        rustCrypto.onLiveEventFromSync(event);
-      });
-
-      // re-emit the events emitted by the crypto impl
-      _this11.reEmitter.reEmit(rustCrypto, [CryptoEvent.VerificationRequestReceived, CryptoEvent.UserTrustStatusChanged, CryptoEvent.KeyBackupStatus, CryptoEvent.KeyBackupSessionsRemaining, CryptoEvent.KeyBackupFailed, CryptoEvent.KeyBackupDecryptionKeyCached, CryptoEvent.KeysChanged, CryptoEvent.DevicesUpdated, CryptoEvent.WillUpdateDevices]);
-    })();
-  }
-
-  /**
-   * Access the server-side secret storage API for this client.
-   */
-  get secretStorage() {
-    return this._secretStorage;
-  }
-
-  /**
-   * Access the crypto API for this client.
-   *
-   * If end-to-end encryption has been enabled for this client (via {@link initCrypto} or {@link initRustCrypto}),
-   * returns an object giving access to the crypto API. Otherwise, returns `undefined`.
-   */
-  getCrypto() {
-    return this.cryptoBackend;
-  }
-
-  /**
-   * Is end-to-end crypto enabled for this client.
-   * @returns True if end-to-end is enabled.
-   * @deprecated prefer {@link getCrypto}
-   */
-  isCryptoEnabled() {
-    return !!this.cryptoBackend;
-  }
-
-  /**
-   * Get the Ed25519 key for this device
-   *
-   * @returns base64-encoded ed25519 key. Null if crypto is
-   *    disabled.
-   *
-   * @deprecated Not supported for Rust Cryptography.Prefer {@link CryptoApi.getOwnDeviceKeys}
-   */
-  getDeviceEd25519Key() {
-    var _this$crypto$getDevic, _this$crypto;
-    return (_this$crypto$getDevic = (_this$crypto = this.crypto) === null || _this$crypto === void 0 ? void 0 : _this$crypto.getDeviceEd25519Key()) !== null && _this$crypto$getDevic !== void 0 ? _this$crypto$getDevic : null;
-  }
-
-  /**
-   * Get the Curve25519 key for this device
-   *
-   * @returns base64-encoded curve25519 key. Null if crypto is
-   *    disabled.
-   *
-   * @deprecated Not supported for Rust Cryptography. Use {@link CryptoApi.getOwnDeviceKeys}
-   */
-  getDeviceCurve25519Key() {
-    var _this$crypto$getDevic2, _this$crypto2;
-    return (_this$crypto$getDevic2 = (_this$crypto2 = this.crypto) === null || _this$crypto2 === void 0 ? void 0 : _this$crypto2.getDeviceCurve25519Key()) !== null && _this$crypto$getDevic2 !== void 0 ? _this$crypto$getDevic2 : null;
-  }
-
-  /**
-   * @deprecated Does nothing.
-   */
-  uploadKeys() {
-    var _this12 = this;
-    return _asyncToGenerator(function* () {
-      _this12.logger.warn("MatrixClient.uploadKeys is deprecated");
-    })();
-  }
-
-  /**
-   * Download the keys for a list of users and stores the keys in the session
-   * store.
-   * @param userIds - The users to fetch.
-   * @param forceDownload - Always download the keys even if cached.
-   *
-   * @returns A promise which resolves to a map userId-\>deviceId-\>`DeviceInfo`
-   *
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.getUserDeviceInfo}
-   */
-  downloadKeys(userIds, forceDownload) {
-    if (!this.crypto) {
-      return Promise.reject(new Error("End-to-end encryption disabled"));
-    }
-    return this.crypto.downloadKeys(userIds, forceDownload);
-  }
-
-  /**
-   * Get the stored device keys for a user id
-   *
-   * @param userId - the user to list keys for.
-   *
-   * @returns list of devices
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.getUserDeviceInfo}
-   */
-  getStoredDevicesForUser(userId) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.getStoredDevicesForUser(userId) || [];
-  }
-
-  /**
-   * Get the stored device key for a user id and device id
-   *
-   * @param userId - the user to list keys for.
-   * @param deviceId - unique identifier for the device
-   *
-   * @returns device or null
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.getUserDeviceInfo}
-   */
-  getStoredDevice(userId, deviceId) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.getStoredDevice(userId, deviceId) || null;
-  }
-
-  /**
-   * Mark the given device as verified
-   *
-   * @param userId - owner of the device
-   * @param deviceId - unique identifier for the device or user's
-   * cross-signing public key ID.
-   *
-   * @param verified - whether to mark the device as verified. defaults
-   *   to 'true'.
-   *
-   * @returns
-   *
-   * @remarks
-   * Fires {@link CryptoEvent#DeviceVerificationChanged}
-   */
-  setDeviceVerified(userId, deviceId) {
-    var verified = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    var prom = this.setDeviceVerification(userId, deviceId, verified, null, null);
-
-    // if one of the user's own devices is being marked as verified / unverified,
-    // check the key backup status, since whether or not we use this depends on
-    // whether it has a signature from a verified device
-    if (userId == this.credentials.userId) {
-      this.checkKeyBackup();
-    }
-    return prom;
-  }
-
-  /**
-   * Mark the given device as blocked/unblocked
-   *
-   * @param userId - owner of the device
-   * @param deviceId - unique identifier for the device or user's
-   * cross-signing public key ID.
-   *
-   * @param blocked - whether to mark the device as blocked. defaults
-   *   to 'true'.
-   *
-   * @returns
-   *
-   * @remarks
-   * Fires {@link LegacyCryptoEvent.DeviceVerificationChanged}
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  setDeviceBlocked(userId, deviceId) {
-    var blocked = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    return this.setDeviceVerification(userId, deviceId, null, blocked, null);
-  }
-
-  /**
-   * Mark the given device as known/unknown
-   *
-   * @param userId - owner of the device
-   * @param deviceId - unique identifier for the device or user's
-   * cross-signing public key ID.
-   *
-   * @param known - whether to mark the device as known. defaults
-   *   to 'true'.
-   *
-   * @returns
-   *
-   * @remarks
-   * Fires {@link CryptoEvent#DeviceVerificationChanged}
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  setDeviceKnown(userId, deviceId) {
-    var known = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    return this.setDeviceVerification(userId, deviceId, null, null, known);
-  }
-  setDeviceVerification(userId, deviceId, verified, blocked, known) {
-    var _this13 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this13.crypto) {
-        throw new Error("End-to-end encryption disabled");
-      }
-      yield _this13.crypto.setDeviceVerification(userId, deviceId, verified, blocked, known);
-    })();
-  }
-
-  /**
-   * Request a key verification from another user, using a DM.
-   *
-   * @param userId - the user to request verification with
-   * @param roomId - the room to use for verification
-   *
-   * @returns resolves to a VerificationRequest
-   *    when the request has been sent to the other party.
-   *
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.requestVerificationDM}.
-   */
-  requestVerificationDM(userId, roomId) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.requestVerificationDM(userId, roomId);
-  }
-
-  /**
-   * Finds a DM verification request that is already in progress for the given room id
-   *
-   * @param roomId - the room to use for verification
-   *
-   * @returns the VerificationRequest that is in progress, if any
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.findVerificationRequestDMInProgress}.
-   */
-  findVerificationRequestDMInProgress(roomId) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    } else if (!this.crypto) {
-      // Hack for element-R to avoid breaking the cypress tests. We can get rid of this once the react-sdk is
-      // updated to use CryptoApi.findVerificationRequestDMInProgress.
-      return undefined;
-    }
-    return this.crypto.findVerificationRequestDMInProgress(roomId);
-  }
-
-  /**
-   * Returns all to-device verification requests that are already in progress for the given user id
-   *
-   * @param userId - the ID of the user to query
-   *
-   * @returns the VerificationRequests that are in progress
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.getVerificationRequestsToDeviceInProgress}.
-   */
-  getVerificationRequestsToDeviceInProgress(userId) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.getVerificationRequestsToDeviceInProgress(userId);
-  }
-
-  /**
-   * Request a key verification from another user.
-   *
-   * @param userId - the user to request verification with
-   * @param devices - array of device IDs to send requests to.  Defaults to
-   *    all devices owned by the user
-   *
-   * @returns resolves to a VerificationRequest
-   *    when the request has been sent to the other party.
-   *
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi#requestOwnUserVerification} or {@link CryptoApi#requestDeviceVerification}.
-   */
-  requestVerification(userId, devices) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.requestVerification(userId, devices);
-  }
-
-  /**
-   * Begin a key verification.
-   *
-   * @param method - the verification method to use
-   * @param userId - the user to verify keys with
-   * @param deviceId - the device to verify
-   *
-   * @returns a verification object
-   * @deprecated Prefer {@link CryptoApi#requestOwnUserVerification} or {@link CryptoApi#requestDeviceVerification}.
-   */
-  beginKeyVerification(method, userId, deviceId) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.beginKeyVerification(method, userId, deviceId);
-  }
-
-  /**
-   * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#checkKey}.
-   */
-  checkSecretStorageKey(key, info) {
-    return this.secretStorage.checkKey(key, info);
-  }
-
-  /**
-   * Set the global override for whether the client should ever send encrypted
-   * messages to unverified devices.  This provides the default for rooms which
-   * do not specify a value.
-   *
-   * @param value - whether to blacklist all unverified devices by default
-   *
-   * @deprecated Prefer direct access to {@link CryptoApi.globalBlacklistUnverifiedDevices}:
-   *
-   * ```javascript
-   * client.getCrypto().globalBlacklistUnverifiedDevices = value;
-   * ```
-   */
-  setGlobalBlacklistUnverifiedDevices(value) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    this.cryptoBackend.globalBlacklistUnverifiedDevices = value;
-    return value;
-  }
-
-  /**
-   * @returns whether to blacklist all unverified devices by default
-   *
-   * @deprecated Prefer direct access to {@link CryptoApi.globalBlacklistUnverifiedDevices}:
-   *
-   * ```javascript
-   * value = client.getCrypto().globalBlacklistUnverifiedDevices;
-   * ```
-   */
-  getGlobalBlacklistUnverifiedDevices() {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.globalBlacklistUnverifiedDevices;
-  }
-
-  /**
-   * Set whether sendMessage in a room with unknown and unverified devices
-   * should throw an error and not send them message. This has 'Global' for
-   * symmetry with setGlobalBlacklistUnverifiedDevices but there is currently
-   * no room-level equivalent for this setting.
-   *
-   * This API is currently UNSTABLE and may change or be removed without notice.
-   *
-   * It has no effect with the Rust crypto implementation.
-   *
-   * @param value - whether error on unknown devices
-   *
-   * ```ts
-   * client.getCrypto().globalErrorOnUnknownDevices = value;
-   * ```
-   */
-  setGlobalErrorOnUnknownDevices(value) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    this.cryptoBackend.globalErrorOnUnknownDevices = value;
-  }
-
-  /**
-   * @returns whether to error on unknown devices
-   *
-   * This API is currently UNSTABLE and may change or be removed without notice.
-   */
-  getGlobalErrorOnUnknownDevices() {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.globalErrorOnUnknownDevices;
-  }
-
-  /**
-   * Get the ID of one of the user's cross-signing keys
-   *
-   * @param type - The type of key to get the ID of.  One of
-   *     "master", "self_signing", or "user_signing".  Defaults to "master".
-   *
-   * @returns the key ID
-   * @deprecated Not supported for Rust Cryptography. prefer {@link Crypto.CryptoApi#getCrossSigningKeyId}
-   */
-  getCrossSigningId() {
-    var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : CrossSigningKey.Master;
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.getCrossSigningId(type);
-  }
-
-  /**
-   * Get the cross signing information for a given user.
-   *
-   * The cross-signing API is currently UNSTABLE and may change without notice.
-   *
-   * @param userId - the user ID to get the cross-signing info for.
-   *
-   * @returns the cross signing information for the user.
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi#userHasCrossSigningKeys}
-   */
-  getStoredCrossSigningForUser(userId) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.getStoredCrossSigningForUser(userId);
-  }
-
-  /**
-   * Check whether a given user is trusted.
-   *
-   * The cross-signing API is currently UNSTABLE and may change without notice.
-   *
-   * @param userId - The ID of the user to check.
-   *
-   * @deprecated Use {@link Crypto.CryptoApi.getUserVerificationStatus | `CryptoApi.getUserVerificationStatus`}
-   */
-  checkUserTrust(userId) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.checkUserTrust(userId);
-  }
-
-  /**
-   * Check whether a given device is trusted.
-   *
-   * The cross-signing API is currently UNSTABLE and may change without notice.
-   *
-   * @param userId - The ID of the user whose devices is to be checked.
-   * @param deviceId - The ID of the device to check
-   *
-   * @deprecated Use {@link Crypto.CryptoApi.getDeviceVerificationStatus | `CryptoApi.getDeviceVerificationStatus`}
-   */
-  checkDeviceTrust(userId, deviceId) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.checkDeviceTrust(userId, deviceId);
-  }
-
-  /**
-   * Check whether one of our own devices is cross-signed by our
-   * user's stored keys, regardless of whether we trust those keys yet.
-   *
-   * @param deviceId - The ID of the device to check
-   *
-   * @returns true if the device is cross-signed
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  checkIfOwnDeviceCrossSigned(deviceId) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.checkIfOwnDeviceCrossSigned(deviceId);
-  }
-
-  /**
-   * Check the copy of our cross-signing key that we have in the device list and
-   * see if we can get the private key. If so, mark it as trusted.
-   * @param opts - ICheckOwnCrossSigningTrustOpts object
-   *
-   * @deprecated Unneeded for the new crypto
-   */
-  checkOwnCrossSigningTrust(opts) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.checkOwnCrossSigningTrust(opts);
-  }
-
-  /**
-   * Checks that a given cross-signing private key matches a given public key.
-   * This can be used by the getCrossSigningKey callback to verify that the
-   * private key it is about to supply is the one that was requested.
-   * @param privateKey - The private key
-   * @param expectedPublicKey - The public key
-   * @returns true if the key matches, otherwise false
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  checkCrossSigningPrivateKey(privateKey, expectedPublicKey) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.checkCrossSigningPrivateKey(privateKey, expectedPublicKey);
-  }
-
-  /**
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi#requestDeviceVerification}.
-   */
-  legacyDeviceVerification(userId, deviceId, method) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.legacyDeviceVerification(userId, deviceId, method);
-  }
-
-  /**
-   * Perform any background tasks that can be done before a message is ready to
-   * send, in order to speed up sending of the message.
-   * @param room - the room the event is in
-   *
-   * @deprecated Prefer {@link CryptoApi.prepareToEncrypt | `CryptoApi.prepareToEncrypt`}:
-   *
-   * ```javascript
-   * client.getCrypto().prepareToEncrypt(room);
-   * ```
-   */
-  prepareToEncrypt(room) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    this.cryptoBackend.prepareToEncrypt(room);
-  }
-
-  /**
-   * Checks if the user has previously published cross-signing keys
-   *
-   * This means downloading the devicelist for the user and checking if the list includes
-   * the cross-signing pseudo-device.
-   *
-   * @deprecated Prefer {@link CryptoApi.userHasCrossSigningKeys | `CryptoApi.userHasCrossSigningKeys`}:
-   *
-   * ```javascript
-   * result = client.getCrypto().userHasCrossSigningKeys();
-   * ```
-   */
-  userHasCrossSigningKeys() {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.userHasCrossSigningKeys();
-  }
-
-  /**
-   * Checks whether cross signing:
-   * - is enabled on this account and trusted by this device
-   * - has private keys either cached locally or stored in secret storage
-   *
-   * If this function returns false, bootstrapCrossSigning() can be used
-   * to fix things such that it returns true. That is to say, after
-   * bootstrapCrossSigning() completes successfully, this function should
-   * return true.
-   * @returns True if cross-signing is ready to be used on this device
-   * @deprecated Prefer {@link CryptoApi.isCrossSigningReady | `CryptoApi.isCrossSigningReady`}:
-   */
-  isCrossSigningReady() {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.isCrossSigningReady();
-  }
-
-  /**
-   * Bootstrap cross-signing by creating keys if needed. If everything is already
-   * set up, then no changes are made, so this is safe to run to ensure
-   * cross-signing is ready for use.
-   *
-   * This function:
-   * - creates new cross-signing keys if they are not found locally cached nor in
-   *   secret storage (if it has been set up)
-   *
-   * @deprecated Prefer {@link CryptoApi.bootstrapCrossSigning | `CryptoApi.bootstrapCrossSigning`}.
-   */
-  bootstrapCrossSigning(opts) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.bootstrapCrossSigning(opts);
-  }
-
-  /**
-   * Whether to trust a others users signatures of their devices.
-   * If false, devices will only be considered 'verified' if we have
-   * verified that device individually (effectively disabling cross-signing).
-   *
-   * Default: true
-   *
-   * @returns True if trusting cross-signed devices
-   *
-   * @deprecated Prefer {@link CryptoApi.getTrustCrossSignedDevices | `CryptoApi.getTrustCrossSignedDevices`}.
-   */
-  getCryptoTrustCrossSignedDevices() {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.getTrustCrossSignedDevices();
-  }
-
-  /**
-   * See getCryptoTrustCrossSignedDevices
-   *
-   * @param val - True to trust cross-signed devices
-   *
-   * @deprecated Prefer {@link CryptoApi.setTrustCrossSignedDevices | `CryptoApi.setTrustCrossSignedDevices`}.
-   */
-  setCryptoTrustCrossSignedDevices(val) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    this.cryptoBackend.setTrustCrossSignedDevices(val);
-  }
-
-  /**
-   * Counts the number of end to end session keys that are waiting to be backed up
-   * @returns Promise which resolves to the number of sessions requiring backup
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  countSessionsNeedingBackup() {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.countSessionsNeedingBackup();
-  }
-
-  /**
-   * Get information about the encryption of an event
-   *
-   * @param event - event to be checked
-   * @returns The event information.
-   * @deprecated Prefer {@link Crypto.CryptoApi.getEncryptionInfoForEvent | `CryptoApi.getEncryptionInfoForEvent`}.
-   */
-  getEventEncryptionInfo(event) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.getEventEncryptionInfo(event);
-  }
-
-  /**
-   * Create a recovery key from a user-supplied passphrase.
-   *
-   * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-   *
-   * @param password - Passphrase string that can be entered by the user
-   *     when restoring the backup as an alternative to entering the recovery key.
-   *     Optional.
-   * @returns Object with public key metadata, encoded private
-   *     recovery key which should be disposed of after displaying to the user,
-   *     and raw private key to avoid round tripping if needed.
-   *
-   * @deprecated Prefer {@link CryptoApi.createRecoveryKeyFromPassphrase | `CryptoApi.createRecoveryKeyFromPassphrase`}.
-   */
-  createRecoveryKeyFromPassphrase(password) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.createRecoveryKeyFromPassphrase(password);
-  }
-
-  /**
-   * Checks whether secret storage:
-   * - is enabled on this account
-   * - is storing cross-signing private keys
-   * - is storing session backup key (if enabled)
-   *
-   * If this function returns false, bootstrapSecretStorage() can be used
-   * to fix things such that it returns true. That is to say, after
-   * bootstrapSecretStorage() completes successfully, this function should
-   * return true.
-   *
-   * @returns True if secret storage is ready to be used on this device
-   * @deprecated Prefer {@link CryptoApi.isSecretStorageReady | `CryptoApi.isSecretStorageReady`}.
-   */
-  isSecretStorageReady() {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.isSecretStorageReady();
-  }
-
-  /**
-   * Bootstrap Secure Secret Storage if needed by creating a default key. If everything is
-   * already set up, then no changes are made, so this is safe to run to ensure secret
-   * storage is ready for use.
-   *
-   * This function
-   * - creates a new Secure Secret Storage key if no default key exists
-   *   - if a key backup exists, it is migrated to store the key in the Secret
-   *     Storage
-   * - creates a backup if none exists, and one is requested
-   * - migrates Secure Secret Storage to use the latest algorithm, if an outdated
-   *   algorithm is found
-   *
-   * @deprecated Use {@link CryptoApi.bootstrapSecretStorage | `CryptoApi.bootstrapSecretStorage`}.
-   */
-  bootstrapSecretStorage(opts) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.bootstrapSecretStorage(opts);
-  }
-
-  /**
-   * Add a key for encrypting secrets.
-   *
-   * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-   *
-   * @param algorithm - the algorithm used by the key
-   * @param opts - the options for the algorithm.  The properties used
-   *     depend on the algorithm given.
-   * @param keyName - the name of the key.  If not given, a random name will be generated.
-   *
-   * @returns An object with:
-   *     keyId: the ID of the key
-   *     keyInfo: details about the key (iv, mac, passphrase)
-   *
-   * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#addKey}.
-   */
-  addSecretStorageKey(algorithm, opts, keyName) {
-    return this.secretStorage.addKey(algorithm, opts, keyName);
-  }
-
-  /**
-   * Check whether we have a key with a given ID.
-   *
-   * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-   *
-   * @param keyId - The ID of the key to check
-   *     for. Defaults to the default key ID if not provided.
-   * @returns Whether we have the key.
-   *
-   * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#hasKey}.
-   */
-  hasSecretStorageKey(keyId) {
-    return this.secretStorage.hasKey(keyId);
-  }
-
-  /**
-   * Store an encrypted secret on the server.
-   *
-   * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-   *
-   * @param name - The name of the secret
-   * @param secret - The secret contents.
-   * @param keys - The IDs of the keys to use to encrypt the secret or null/undefined
-   *     to use the default (will throw if no default key is set).
-   *
-   * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#store}.
-   */
-  storeSecret(name, secret, keys) {
-    return this.secretStorage.store(name, secret, keys);
-  }
-
-  /**
-   * Get a secret from storage.
-   *
-   * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-   *
-   * @param name - the name of the secret
-   *
-   * @returns the contents of the secret
-   *
-   * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#get}.
-   */
-  getSecret(name) {
-    return this.secretStorage.get(name);
-  }
-
-  /**
-   * Check if a secret is stored on the server.
-   *
-   * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-   *
-   * @param name - the name of the secret
-   * @returns map of key name to key info the secret is encrypted
-   *     with, or null if it is not present or not encrypted with a trusted
-   *     key
-   *
-   * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#isStored}.
-   */
-  isSecretStored(name) {
-    return this.secretStorage.isStored(name);
-  }
-
-  /**
-   * Request a secret from another device.
-   *
-   * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-   *
-   * @param name - the name of the secret to request
-   * @param devices - the devices to request the secret from
-   *
-   * @returns the secret request object
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  requestSecret(name, devices) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.requestSecret(name, devices);
-  }
-
-  /**
-   * Get the current default key ID for encrypting secrets.
-   *
-   * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-   *
-   * @returns The default key ID or null if no default key ID is set
-   *
-   * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#getDefaultKeyId}.
-   */
-  getDefaultSecretStorageKeyId() {
-    return this.secretStorage.getDefaultKeyId();
-  }
-
-  /**
-   * Set the current default key ID for encrypting secrets.
-   *
-   * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-   *
-   * @param keyId - The new default key ID
-   *
-   * @deprecated Use {@link MatrixClient#secretStorage} and {@link SecretStorage.ServerSideSecretStorage#setDefaultKeyId}.
-   */
-  setDefaultSecretStorageKeyId(keyId) {
-    return this.secretStorage.setDefaultKeyId(keyId);
-  }
-
-  /**
-   * Checks that a given secret storage private key matches a given public key.
-   * This can be used by the getSecretStorageKey callback to verify that the
-   * private key it is about to supply is the one that was requested.
-   *
-   * The Secure Secret Storage API is currently UNSTABLE and may change without notice.
-   *
-   * @param privateKey - The private key
-   * @param expectedPublicKey - The public key
-   * @returns true if the key matches, otherwise false
-   *
-   * @deprecated The use of asymmetric keys for SSSS is deprecated.
-   *     Use {@link SecretStorage.ServerSideSecretStorage#checkKey} for symmetric keys.
-   */
-  checkSecretStoragePrivateKey(privateKey, expectedPublicKey) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.checkSecretStoragePrivateKey(privateKey, expectedPublicKey);
-  }
-
-  /**
-   * Get e2e information on the device that sent an event
-   *
-   * @param event - event to be checked
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  getEventSenderDeviceInfo(event) {
-    var _this14 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this14.crypto) {
-        return null;
-      }
-      return _this14.crypto.getEventSenderDeviceInfo(event);
-    })();
-  }
-
-  /**
-   * Check if the sender of an event is verified
-   *
-   * @param event - event to be checked
-   *
-   * @returns true if the sender of this event has been verified using
-   * {@link MatrixClient#setDeviceVerified}.
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  isEventSenderVerified(event) {
-    var _this15 = this;
-    return _asyncToGenerator(function* () {
-      var device = yield _this15.getEventSenderDeviceInfo(event);
-      if (!device) {
-        return false;
-      }
-      return device.isVerified();
-    })();
-  }
-
-  /**
-   * Get outgoing room key request for this event if there is one.
-   * @param event - The event to check for
-   *
-   * @returns A room key request, or null if there is none
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  getOutgoingRoomKeyRequest(event) {
-    if (!this.crypto) {
-      throw new Error("End-to-End encryption disabled");
-    }
-    var wireContent = event.getWireContent();
-    var requestBody = {
-      session_id: wireContent.session_id,
-      sender_key: wireContent.sender_key,
-      algorithm: wireContent.algorithm,
-      room_id: event.getRoomId()
-    };
-    if (!requestBody.session_id || !requestBody.sender_key || !requestBody.algorithm || !requestBody.room_id) {
-      return Promise.resolve(null);
-    }
-    return this.crypto.cryptoStore.getOutgoingRoomKeyRequest(requestBody);
-  }
-
-  /**
-   * Cancel a room key request for this event if one is ongoing and resend the
-   * request.
-   * @param event - event of which to cancel and resend the room
-   *                            key request.
-   * @returns A promise that will resolve when the key request is queued
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  cancelAndResendEventRoomKeyRequest(event) {
-    if (!this.crypto) {
-      throw new Error("End-to-End encryption disabled");
-    }
-    return event.cancelAndResendKeyRequest(this.crypto, this.getUserId());
-  }
-
-  /**
-   * Enable end-to-end encryption for a room. This does not modify room state.
-   * Any messages sent before the returned promise resolves will be sent unencrypted.
-   * @param roomId - The room ID to enable encryption in.
-   * @param config - The encryption config for the room.
-   * @returns A promise that will resolve when encryption is set up.
-   *
-   * @deprecated Not supported for Rust Cryptography. To enable encryption in a room, send an `m.room.encryption`
-   * state event.
-   */
-  setRoomEncryption(roomId, config) {
-    if (!this.crypto) {
-      throw new Error("End-to-End encryption disabled");
-    }
-    return this.crypto.setRoomEncryption(roomId, config);
-  }
-
-  /**
-   * Whether encryption is enabled for a room.
-   * @param roomId - the room id to query.
-   * @returns whether encryption is enabled.
-   *
-   * @deprecated Not correctly supported for Rust Cryptography. Use {@link CryptoApi.isEncryptionEnabledInRoom} and/or
-   *    {@link Room.hasEncryptionStateEvent}.
-   */
-  isRoomEncrypted(roomId) {
-    var _this$crypto$isRoomEn, _this$crypto3;
-    var room = this.getRoom(roomId);
-    if (!room) {
-      // we don't know about this room, so can't determine if it should be
-      // encrypted. Let's assume not.
-      return false;
-    }
-
-    // if there is an 'm.room.encryption' event in this room, it should be
-    // encrypted (independently of whether we actually support encryption)
-    if (room.hasEncryptionStateEvent()) {
-      return true;
-    }
-
-    // we don't have an m.room.encrypted event, but that might be because
-    // the server is hiding it from us. Check the store to see if it was
-    // previously encrypted.
-    return (_this$crypto$isRoomEn = (_this$crypto3 = this.crypto) === null || _this$crypto3 === void 0 ? void 0 : _this$crypto3.isRoomEncrypted(roomId)) !== null && _this$crypto$isRoomEn !== void 0 ? _this$crypto$isRoomEn : false;
-  }
-
-  /**
-   * Encrypts and sends a given object via Olm to-device messages to a given
-   * set of devices.
-   *
-   * @param userDeviceInfoArr - list of deviceInfo objects representing the devices to send to
-   *
-   * @param payload - fields to include in the encrypted payload
-   *
-   * @returns Promise which
-   *     resolves once the message has been encrypted and sent to the given
-   *     userDeviceMap, and returns the `{ contentMap, deviceInfoByDeviceId }`
-   *     of the successfully sent messages.
-   *
-   * @deprecated Instead use {@link CryptoApi.encryptToDeviceMessages} followed by {@link queueToDevice}.
-   */
-  encryptAndSendToDevices(userDeviceInfoArr, payload) {
-    if (!this.crypto) {
-      throw new Error("End-to-End encryption disabled");
-    }
-    return this.crypto.encryptAndSendToDevices(userDeviceInfoArr, payload);
-  }
-
-  /**
-   * Forces the current outbound group session to be discarded such
-   * that another one will be created next time an event is sent.
-   *
-   * @param roomId - The ID of the room to discard the session for
-   *
-   * @deprecated Prefer {@link CryptoApi.forceDiscardSession | `CryptoApi.forceDiscardSession`}:
-   */
-  forceDiscardSession(roomId) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-End encryption disabled");
-    }
-    this.cryptoBackend.forceDiscardSession(roomId);
-  }
-
-  /**
-   * Get a list containing all of the room keys
-   *
-   * This should be encrypted before returning it to the user.
-   *
-   * @returns a promise which resolves to a list of session export objects
-   *
-   * @deprecated Prefer {@link CryptoApi.exportRoomKeys | `CryptoApi.exportRoomKeys`}:
-   *
-   * ```javascript
-   * sessionData = await client.getCrypto().exportRoomKeys();
-   * ```
-   */
-  exportRoomKeys() {
-    if (!this.cryptoBackend) {
-      return Promise.reject(new Error("End-to-end encryption disabled"));
-    }
-    return this.cryptoBackend.exportRoomKeys();
-  }
-
-  /**
-   * Import a list of room keys previously exported by exportRoomKeys
-   *
-   * @param keys - a list of session export objects
-   * @param opts - options object
-   *
-   * @returns a promise which resolves when the keys have been imported
-   *
-   * @deprecated Prefer {@link CryptoApi.importRoomKeys | `CryptoApi.importRoomKeys`}:
-   * ```javascript
-   *  await client.getCrypto()?.importRoomKeys([..]);
-   * ```
-   */
-  importRoomKeys(keys, opts) {
-    if (!this.cryptoBackend) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.cryptoBackend.importRoomKeys(keys, opts);
-  }
-
-  /**
-   * Force a re-check of the local key backup status against
-   * what's on the server.
-   *
-   * @returns Object with backup info (as returned by
-   *     getKeyBackupVersion) in backupInfo and
-   *     trust information (as returned by isKeyBackupTrusted)
-   *     in trustInfo.
-   *
-   * @deprecated Prefer {@link Crypto.CryptoApi.checkKeyBackupAndEnable}.
-   */
-  checkKeyBackup() {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.backupManager.checkKeyBackup();
-  }
-
-  /**
-   * Get information about the current key backup from the server.
-   *
-   * Performs some basic validity checks on the shape of the result, and raises an error if it is not as expected.
-   *
-   * **Note**: there is no (supported) way to distinguish between "failure to talk to the server" and "another client
-   * uploaded a key backup version using an algorithm I don't understand.
-   *
-   * @returns Information object from API, or null if no backup is present on the server.
-   *
-   * @deprecated Prefer {@link CryptoApi.getKeyBackupInfo}.
-   */
-  getKeyBackupVersion() {
-    var _this16 = this;
-    return _asyncToGenerator(function* () {
-      var res;
-      try {
-        res = yield _this16.http.authedRequest(Method.Get, "/room_keys/version", undefined, undefined, {
-          prefix: ClientPrefix.V3
-        });
-      } catch (e) {
-        if (e.errcode === "M_NOT_FOUND") {
-          return null;
-        } else {
-          throw e;
-        }
-      }
-      BackupManager.checkBackupVersion(res);
-      return res;
-    })();
-  }
-
-  /**
-   * @param info - key backup info dict from getKeyBackupVersion()
-   *
-   * @deprecated Not supported for Rust Cryptography. Prefer {@link CryptoApi.isKeyBackupTrusted | `CryptoApi.isKeyBackupTrusted`}.
-   */
-  isKeyBackupTrusted(info) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.backupManager.isKeyBackupTrusted(info);
-  }
-
-  /**
-   * @returns true if the client is configured to back up keys to
-   *     the server, otherwise false. If we haven't completed a successful check
-   *     of key backup status yet, returns null.
-   *
-   * @deprecated Not supported for Rust Cryptography. Prefer direct access to {@link Crypto.CryptoApi.getActiveSessionBackupVersion}:
-   *
-   * ```javascript
-   * let enabled = (await client.getCrypto().getActiveSessionBackupVersion()) !== null;
-   * ```
-   */
-  getKeyBackupEnabled() {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.backupManager.getKeyBackupEnabled();
-  }
-
-  /**
-   * Enable backing up of keys, using data previously returned from
-   * getKeyBackupVersion.
-   *
-   * @param info - Backup information object as returned by getKeyBackupVersion
-   * @returns Promise which resolves when complete.
-   *
-   * @deprecated Do not call this directly. Instead call {@link Crypto.CryptoApi.checkKeyBackupAndEnable}.
-   */
-  enableKeyBackup(info) {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.backupManager.enableKeyBackup(info);
-  }
-
-  /**
-   * Disable backing up of keys.
-   *
-   * @deprecated Not supported for Rust Cryptography. It should be unnecessary to disable key backup.
-   */
-  disableKeyBackup() {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    this.crypto.backupManager.disableKeyBackup();
-  }
-
-  /**
-   * Set up the data required to create a new backup version.  The backup version
-   * will not be created and enabled until createKeyBackupVersion is called.
-   *
-   * @param password - Passphrase string that can be entered by the user
-   *     when restoring the backup as an alternative to entering the recovery key.
-   *     Optional.
-   *
-   * @returns Object that can be passed to createKeyBackupVersion and
-   *     additionally has a 'recovery_key' member with the user-facing recovery key string.
-   *
-   * @deprecated Not supported for Rust cryptography. Use {@link Crypto.CryptoApi.resetKeyBackup | `CryptoApi.resetKeyBackup`}.
-   */
-  prepareKeyBackupVersion(password) {
-    var _arguments2 = arguments,
-      _this17 = this;
-    return _asyncToGenerator(function* () {
-      var opts = _arguments2.length > 1 && _arguments2[1] !== undefined ? _arguments2[1] : {
-        secureSecretStorage: false
-      };
-      if (!_this17.crypto) {
-        throw new Error("End-to-end encryption disabled");
-      }
-
-      // eslint-disable-next-line camelcase
-      var {
-        algorithm,
-        auth_data,
-        recovery_key,
-        privateKey
-      } = yield _this17.crypto.backupManager.prepareKeyBackupVersion(password);
-      if (opts.secureSecretStorage) {
-        yield _this17.secretStorage.store("m.megolm_backup.v1", encodeBase64(privateKey));
-        _this17.logger.info("Key backup private key stored in secret storage");
-      }
-      return {
-        algorithm,
-        /* eslint-disable camelcase */
-        auth_data,
-        recovery_key
-        /* eslint-enable camelcase */
-      };
-    })();
-  }
-
-  /**
-   * Check whether the key backup private key is stored in secret storage.
-   * @returns map of key name to key info the secret is
-   *     encrypted with, or null if it is not present or not encrypted with a
-   *     trusted key
-   */
-  isKeyBackupKeyStored() {
-    return Promise.resolve(this.secretStorage.isStored("m.megolm_backup.v1"));
-  }
-
-  /**
-   * Create a new key backup version and enable it, using the information return
-   * from prepareKeyBackupVersion.
-   *
-   * @param info - Info object from prepareKeyBackupVersion
-   * @returns Object with 'version' param indicating the version created
-   *
-   * @deprecated Use {@link Crypto.CryptoApi.resetKeyBackup | `CryptoApi.resetKeyBackup`}.
-   */
-  createKeyBackupVersion(info) {
-    var _this18 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this18.crypto) {
-        throw new Error("End-to-end encryption disabled");
-      }
-      yield _this18.crypto.backupManager.createKeyBackupVersion(info);
-      var data = {
-        algorithm: info.algorithm,
-        auth_data: info.auth_data
-      };
-
-      // Sign the backup auth data with the device key for backwards compat with
-      // older devices with cross-signing. This can probably go away very soon in
-      // favour of just signing with the cross-singing master key.
-      // XXX: Private member access
-      yield _this18.crypto.signObject(data.auth_data);
-      if (_this18.cryptoCallbacks.getCrossSigningKey &&
-      // XXX: Private member access
-      _this18.crypto.crossSigningInfo.getId()) {
-        // now also sign the auth data with the cross-signing master key
-        // we check for the callback explicitly here because we still want to be able
-        // to create an un-cross-signed key backup if there is a cross-signing key but
-        // no callback supplied.
-        // XXX: Private member access
-        yield _this18.crypto.crossSigningInfo.signObject(data.auth_data, "master");
-      }
-      var res = yield _this18.http.authedRequest(Method.Post, "/room_keys/version", undefined, data);
-
-      // We could assume everything's okay and enable directly, but this ensures
-      // we run the same signature verification that will be used for future
-      // sessions.
-      yield _this18.checkKeyBackup();
-      if (!_this18.getKeyBackupEnabled()) {
-        _this18.logger.error("Key backup not usable even though we just created it");
-      }
-      return res;
-    })();
-  }
-
-  /**
-   * @deprecated Use {@link Crypto.CryptoApi.deleteKeyBackupVersion | `CryptoApi.deleteKeyBackupVersion`}.
-   */
-  deleteKeyBackupVersion(version) {
-    var _this19 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this19.cryptoBackend) {
-        throw new Error("End-to-end encryption disabled");
-      }
-      yield _this19.cryptoBackend.deleteKeyBackupVersion(version);
-    })();
-  }
-  makeKeyBackupPath(roomId, sessionId, version) {
-    var path;
-    if (sessionId !== undefined) {
-      path = utils.encodeUri("/room_keys/keys/$roomId/$sessionId", {
-        $roomId: roomId,
-        $sessionId: sessionId
-      });
-    } else if (roomId !== undefined) {
-      path = utils.encodeUri("/room_keys/keys/$roomId", {
-        $roomId: roomId
-      });
-    } else {
-      path = "/room_keys/keys";
-    }
-    var queryData = version === undefined ? undefined : {
-      version
-    };
-    return {
-      path,
-      queryData
-    };
-  }
-
-  /**
-   * Back up session keys to the homeserver.
-   * @param roomId - ID of the room that the keys are for Optional.
-   * @param sessionId - ID of the session that the keys are for Optional.
-   * @param version - backup version Optional.
-   * @param data - Object keys to send
-   * @returns a promise that will resolve when the keys
-   * are uploaded
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-
-  sendKeyBackup(roomId, sessionId, version, data) {
-    var _this20 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this20.crypto) {
-        throw new Error("End-to-end encryption disabled");
-      }
-      var path = _this20.makeKeyBackupPath(roomId, sessionId, version);
-      yield _this20.http.authedRequest(Method.Put, path.path, path.queryData, data, {
-        prefix: ClientPrefix.V3
-      });
-    })();
-  }
-
-  /**
-   * Marks all group sessions as needing to be backed up and schedules them to
-   * upload in the background as soon as possible.
-   *
-   * @deprecated Not supported for Rust Cryptography. This is done automatically as part of
-   * {@link CryptoApi.resetKeyBackup}, so there is probably no need to call this manually.
-   */
-  scheduleAllGroupSessionsForBackup() {
-    var _this21 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this21.crypto) {
-        throw new Error("End-to-end encryption disabled");
-      }
-      yield _this21.crypto.backupManager.scheduleAllGroupSessionsForBackup();
-    })();
-  }
-
-  /**
-   * Marks all group sessions as needing to be backed up without scheduling
-   * them to upload in the background.
-   *
-   * (This is done automatically as part of {@link CryptoApi.resetKeyBackup},
-   * so there is probably no need to call this manually.)
-   *
-   * @returns Promise which resolves to the number of sessions requiring a backup.
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  flagAllGroupSessionsForBackup() {
-    if (!this.crypto) {
-      throw new Error("End-to-end encryption disabled");
-    }
-    return this.crypto.backupManager.flagAllGroupSessionsForBackup();
-  }
-
-  /**
-   * Return true if recovery key is valid.
-   * Try to decode the recovery key and check if it's successful.
-   * @param recoveryKey
-   * @deprecated Use {@link decodeRecoveryKey} directly
-   */
-  isValidRecoveryKey(recoveryKey) {
-    try {
-      decodeRecoveryKey(recoveryKey);
-      return true;
-    } catch (_unused2) {
-      return false;
-    }
-  }
-
-  /**
-   * Get the raw key for a key backup from the password
-   * Used when migrating key backups into SSSS
-   *
-   * The cross-signing API is currently UNSTABLE and may change without notice.
-   *
-   * @param password - Passphrase
-   * @param backupInfo - Backup metadata from `checkKeyBackup`
-   * @returns key backup key
-   * @deprecated Deriving a backup key from a passphrase is not part of the matrix spec. Instead, a random key is generated and stored/shared via 4S.
-   */
-  keyBackupKeyFromPassword(password, backupInfo) {
-    return keyFromAuthData(backupInfo.auth_data, password);
-  }
-
-  /**
-   * Get the raw key for a key backup from the recovery key
-   * Used when migrating key backups into SSSS
-   *
-   * The cross-signing API is currently UNSTABLE and may change without notice.
-   *
-   * @param recoveryKey - The recovery key
-   * @returns key backup key
-   * @deprecated Use {@link decodeRecoveryKey} directly
-   */
-  keyBackupKeyFromRecoveryKey(recoveryKey) {
-    return decodeRecoveryKey(recoveryKey);
-  }
-
-  /**
-   * Restore from an existing key backup via a passphrase.
-   *
-   * @param password - Passphrase
-   * @param targetRoomId - Room ID to target a specific room.
-   * Restores all rooms if omitted.
-   * @param targetSessionId - Session ID to target a specific session.
-   * Restores all sessions if omitted.
-   * @param backupInfo - Backup metadata from `getKeyBackupVersion` or `checkKeyBackup`.`backupInfo`
-   * @param opts - Optional params such as callbacks
-   * @returns Status of restoration with `total` and `imported`
-   * key counts.
-   *
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackupWithPassphrase | `CryptoApi.restoreKeyBackupWithPassphrase`}.
-   */
-
-  /**
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackupWithPassphrase | `CryptoApi.restoreKeyBackupWithPassphrase`}.
-   */
-
-  /**
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackupWithPassphrase | `CryptoApi.restoreKeyBackupWithPassphrase`}.
-   */
-
-  /**
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackupWithPassphrase | `CryptoApi.restoreKeyBackupWithPassphrase`}.
-   */
-  restoreKeyBackupWithPassword(password, targetRoomId, targetSessionId, backupInfo, opts) {
-    var _this22 = this;
-    return _asyncToGenerator(function* () {
-      var privKey = yield keyFromAuthData(backupInfo.auth_data, password);
-      return _this22.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
-    })();
-  }
-
-  /**
-   * Restore from an existing key backup via a private key stored in secret
-   * storage.
-   *
-   * @param backupInfo - Backup metadata from `checkKeyBackup`
-   * @param targetRoomId - Room ID to target a specific room.
-   * Restores all rooms if omitted.
-   * @param targetSessionId - Session ID to target a specific session.
-   * Restores all sessions if omitted.
-   * @param opts - Optional params such as callbacks
-   * @returns Status of restoration with `total` and `imported`
-   * key counts.
-   *
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-   */
-  restoreKeyBackupWithSecretStorage(backupInfo, targetRoomId, targetSessionId, opts) {
-    var _this23 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this23.cryptoBackend) {
-        throw new Error("End-to-end encryption disabled");
-      }
-      var storedKey = yield _this23.secretStorage.get("m.megolm_backup.v1");
-
-      // ensure that the key is in the right format.  If not, fix the key and
-      // store the fixed version
-      var fixedKey = fixBackupKey(storedKey);
-      if (fixedKey) {
-        var keys = yield _this23.secretStorage.getKey();
-        yield _this23.secretStorage.store("m.megolm_backup.v1", fixedKey, [keys[0]]);
-      }
-      var privKey = decodeBase64(fixedKey || storedKey);
-      return _this23.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
-    })();
-  }
-
-  /**
-   * Restore from an existing key backup via an encoded recovery key.
-   *
-   * @param recoveryKey - Encoded recovery key
-   * @param targetRoomId - Room ID to target a specific room.
-   * Restores all rooms if omitted.
-   * @param targetSessionId - Session ID to target a specific session.
-   * Restores all sessions if omitted.
-   * @param backupInfo - Backup metadata from `checkKeyBackup`
-   * @param opts - Optional params such as callbacks
-    * @returns Status of restoration with `total` and `imported`
-   * key counts.
-   *
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-   */
-
-  /**
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-   */
-
-  /**
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-   */
-
-  /**
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-   */
-  restoreKeyBackupWithRecoveryKey(recoveryKey, targetRoomId, targetSessionId, backupInfo, opts) {
-    var privKey = decodeRecoveryKey(recoveryKey);
-    return this.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
-  }
-
-  /**
-   * Restore from an existing key backup via a private key stored locally
-   * @param targetRoomId
-   * @param targetSessionId
-   * @param backupInfo
-   * @param opts
-   *
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-   */
-
-  /**
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-   */
-
-  /**
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-   */
-
-  /**
-   * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
-   */
-  restoreKeyBackupWithCache(targetRoomId, targetSessionId, backupInfo, opts) {
-    var _this24 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this24.cryptoBackend) {
-        throw new Error("End-to-end encryption disabled");
-      }
-      var privKey = yield _this24.cryptoBackend.getSessionBackupPrivateKey();
-      if (!privKey) {
-        throw new Error("Couldn't get key");
-      }
-      return _this24.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
-    })();
-  }
-  restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts) {
-    var _this25 = this;
-    return _asyncToGenerator(function* () {
-      var cacheCompleteCallback = opts === null || opts === void 0 ? void 0 : opts.cacheCompleteCallback;
-      var progressCallback = opts === null || opts === void 0 ? void 0 : opts.progressCallback;
-      if (!_this25.cryptoBackend) {
-        throw new Error("End-to-end encryption disabled");
-      }
-      if (!backupInfo.version) {
-        throw new Error("Backup version must be defined");
-      }
-      var backupVersion = backupInfo.version;
-      var totalKeyCount = 0;
-      var totalFailures = 0;
-      var totalImported = 0;
-      var path = _this25.makeKeyBackupPath(targetRoomId, targetSessionId, backupVersion);
-      var backupDecryptor = yield _this25.cryptoBackend.getBackupDecryptor(backupInfo, privKey);
-      var untrusted = !backupDecryptor.sourceTrusted;
-      try {
-        if (!(privKey instanceof Uint8Array)) {
-          // eslint-disable-next-line @typescript-eslint/no-base-to-string
-          throw new Error("restoreKeyBackup expects Uint8Array, got ".concat(privKey));
-        }
-        // Cache the key, if possible.
-        // This is async.
-        _this25.cryptoBackend.storeSessionBackupPrivateKey(privKey, backupVersion).catch(e => {
-          _this25.logger.warn("Error caching session backup key:", e);
-        }).then(cacheCompleteCallback);
-        if (progressCallback) {
-          progressCallback({
-            stage: "fetch"
-          });
-        }
-        var res = yield _this25.http.authedRequest(Method.Get, path.path, path.queryData, undefined, {
-          prefix: ClientPrefix.V3
-        });
-
-        // We have finished fetching the backup, go to next step
-        if (progressCallback) {
-          progressCallback({
-            stage: "load_keys"
-          });
-        }
-        if (res.rooms) {
-          // We have a full backup here, it can get quite big, so we need to decrypt and import it in chunks.
-
-          // Get the total count as a first pass
-          totalKeyCount = _this25.getTotalKeyCount(res);
-          // Now decrypt and import the keys in chunks
-          yield _this25.handleDecryptionOfAFullBackup(res, backupDecryptor, 200, /*#__PURE__*/function () {
-            var _ref3 = _asyncToGenerator(function* (chunk) {
-              // We have a chunk of decrypted keys: import them
-              try {
-                var _backupVersion = backupInfo.version;
-                yield _this25.cryptoBackend.importBackedUpRoomKeys(chunk, _backupVersion, {
-                  untrusted
-                });
-                totalImported += chunk.length;
-              } catch (e) {
-                totalFailures += chunk.length;
-                // We failed to import some keys, but we should still try to import the rest?
-                // Log the error and continue
-                logger.error("Error importing keys from backup", e);
-              }
-              if (progressCallback) {
-                progressCallback({
-                  total: totalKeyCount,
-                  successes: totalImported,
-                  stage: "load_keys",
-                  failures: totalFailures
-                });
-              }
-            });
-            return function (_x2) {
-              return _ref3.apply(this, arguments);
-            };
-          }());
-        } else if (res.sessions) {
-          // For now we don't chunk for a single room backup, but we could in the future.
-          // Currently it is not used by the application.
-          var sessions = res.sessions;
-          totalKeyCount = Object.keys(sessions).length;
-          var keys = yield backupDecryptor.decryptSessions(sessions);
-          for (var _k of keys) {
-            _k.room_id = targetRoomId;
-          }
-          yield _this25.cryptoBackend.importBackedUpRoomKeys(keys, backupVersion, {
-            progressCallback,
-            untrusted
-          });
-          totalImported = keys.length;
-        } else {
-          totalKeyCount = 1;
-          try {
-            var [_key2] = yield backupDecryptor.decryptSessions({
-              [targetSessionId]: res
-            });
-            _key2.room_id = targetRoomId;
-            _key2.session_id = targetSessionId;
-            yield _this25.cryptoBackend.importBackedUpRoomKeys([_key2], backupVersion, {
-              progressCallback,
-              untrusted
-            });
-            totalImported = 1;
-          } catch (e) {
-            _this25.logger.debug("Failed to decrypt megolm session from backup", e);
-          }
-        }
-      } finally {
-        backupDecryptor.free();
-      }
-
-      /// in case entering the passphrase would add a new signature?
-      yield _this25.cryptoBackend.checkKeyBackupAndEnable();
-      return {
-        total: totalKeyCount,
-        imported: totalImported
-      };
+  /**
+   * Gets the cached capabilities of the homeserver, returning cached ones if available.
+   * If there are no cached capabilities and none can be fetched, throw an exception.
+   *
+   * @returns Promise resolving with The capabilities of the homeserver
+   */
+  getCapabilities() {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      var caps = _this3.serverCapabilitiesService.getCachedCapabilities();
+      if (caps) return caps;
+      return _this3.serverCapabilitiesService.fetchCapabilities();
     })();
   }
 
   /**
-   * This method calculates the total number of keys present in the response of a `/room_keys/keys` call.
-   *
-   * @param res - The response from the server containing the keys to be counted.
+   * Gets the cached capabilities of the homeserver. If none have been fetched yet,
+   * return undefined.
    *
-   * @returns The total number of keys in the backup.
-   */
-  getTotalKeyCount(res) {
-    var rooms = res.rooms;
-    var totalKeyCount = 0;
-    for (var roomData of Object.values(rooms)) {
-      if (!roomData.sessions) continue;
-      totalKeyCount += Object.keys(roomData.sessions).length;
-    }
-    return totalKeyCount;
+   * @returns The capabilities of the homeserver
+   */
+  getCachedCapabilities() {
+    return this.serverCapabilitiesService.getCachedCapabilities();
   }
 
   /**
-   * This method handles the decryption of a full backup, i.e a call to `/room_keys/keys`.
-   * It will decrypt the keys in chunks and call the `block` callback for each chunk.
-   *
-   * @param res - The response from the server containing the keys to be decrypted.
-   * @param backupDecryptor - An instance of the BackupDecryptor class used to decrypt the keys.
-   * @param chunkSize - The size of the chunks to be processed at a time.
-   * @param block - A callback function that is called for each chunk of keys.
+   * Fetches the latest capabilities from the homeserver, ignoring any cached
+   * versions. The newly returned version is cached.
    *
-   * @returns A promise that resolves when the decryption is complete.
+   * @returns A promise which resolves to the capabilities of the homeserver
    */
-  handleDecryptionOfAFullBackup(res, backupDecryptor, chunkSize, block) {
-    return _asyncToGenerator(function* () {
-      var rooms = res.rooms;
-      var groupChunkCount = 0;
-      var chunkGroupByRoom = new Map();
-      var handleChunkCallback = /*#__PURE__*/function () {
-        var _ref4 = _asyncToGenerator(function* (roomChunks) {
-          var currentChunk = [];
-          for (var _roomId of roomChunks.keys()) {
-            var decryptedSessions = yield backupDecryptor.decryptSessions(roomChunks.get(_roomId));
-            for (var _sessionId in decryptedSessions) {
-              var _k2 = decryptedSessions[_sessionId];
-              _k2.room_id = _roomId;
-              currentChunk.push(_k2);
-            }
-          }
-          yield block(currentChunk);
-        });
-        return function handleChunkCallback(_x3) {
-          return _ref4.apply(this, arguments);
-        };
-      }();
-      for (var [_roomId2, roomData] of Object.entries(rooms)) {
-        if (!roomData.sessions) continue;
-        chunkGroupByRoom.set(_roomId2, {});
-        for (var [_sessionId2, session] of Object.entries(roomData.sessions)) {
-          var sessionsForRoom = chunkGroupByRoom.get(_roomId2);
-          sessionsForRoom[_sessionId2] = session;
-          groupChunkCount += 1;
-          if (groupChunkCount >= chunkSize) {
-            // We have enough chunks to decrypt
-            yield handleChunkCallback(chunkGroupByRoom);
-            chunkGroupByRoom = new Map();
-            // There might be remaining keys for that room, so add back an entry for the current room.
-            chunkGroupByRoom.set(_roomId2, {});
-            groupChunkCount = 0;
-          }
-        }
-      }
-
-      // Handle remaining chunk if needed
-      if (groupChunkCount > 0) {
-        yield handleChunkCallback(chunkGroupByRoom);
-      }
-    })();
+  fetchCapabilities() {
+    return this.serverCapabilitiesService.fetchCapabilities();
   }
-  deleteKeysFromBackup(roomId, sessionId, version) {
-    var _this26 = this;
+
+  /**
+   * @deprecated Does nothing.
+   */
+  uploadKeys() {
+    var _this4 = this;
     return _asyncToGenerator(function* () {
-      var path = _this26.makeKeyBackupPath(roomId, sessionId, version);
-      yield _this26.http.authedRequest(Method.Delete, path.path, path.queryData, undefined, {
-        prefix: ClientPrefix.V3
-      });
+      _this4.logger.warn("MatrixClient.uploadKeys is deprecated");
     })();
   }
 
@@ -2876,10 +739,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   getAccountDataFromServer(eventType) {
-    var _this27 = this;
+    var _this5 = this;
     return _asyncToGenerator(function* () {
-      if (_this27.isInitialSyncComplete()) {
-        var _event = _this27.store.getAccountData(eventType);
+      if (_this5.isInitialSyncComplete()) {
+        var _event = _this5.store.getAccountData(eventType);
         if (!_event) {
           return null;
         }
@@ -2888,11 +751,11 @@ export class MatrixClient extends TypedEventEmitter {
         return _event.getContent();
       }
       var path = utils.encodeUri("/user/$userId/account_data/$type", {
-        $userId: _this27.credentials.userId,
+        $userId: _this5.credentials.userId,
         $type: eventType
       });
       try {
-        return yield _this27.http.authedRequest(Method.Get, path);
+        return yield _this5.http.authedRequest(Method.Get, path);
       } catch (e) {
         var _data;
         if (((_data = e.data) === null || _data === void 0 ? void 0 : _data.errcode) === "M_NOT_FOUND") {
@@ -2903,22 +766,22 @@ export class MatrixClient extends TypedEventEmitter {
     })();
   }
   deleteAccountData(eventType) {
-    var _this28 = this;
+    var _this6 = this;
     return _asyncToGenerator(function* () {
-      var msc3391DeleteAccountDataServerSupport = _this28.canSupport.get(Feature.AccountDataDeletion);
+      var msc3391DeleteAccountDataServerSupport = _this6.canSupport.get(Feature.AccountDataDeletion);
       // if deletion is not supported overwrite with empty content
       if (msc3391DeleteAccountDataServerSupport === ServerSupport.Unsupported) {
-        yield _this28.setAccountData(eventType, {});
+        yield _this6.setAccountData(eventType, {});
         return;
       }
       var path = utils.encodeUri("/user/$userId/account_data/$type", {
-        $userId: _this28.getSafeUserId(),
+        $userId: _this6.getSafeUserId(),
         $type: eventType
       });
       var options = msc3391DeleteAccountDataServerSupport === ServerSupport.Unstable ? {
         prefix: "/_matrix/client/unstable/org.matrix.msc3391"
       } : undefined;
-      return yield _this28.http.authedRequest(Method.Delete, path, undefined, undefined, options);
+      return yield _this6.http.authedRequest(Method.Delete, path, undefined, undefined, options);
     })();
   }
 
@@ -2965,20 +828,20 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   joinRoom(roomIdOrAlias) {
-    var _arguments3 = arguments,
-      _this29 = this;
+    var _arguments = arguments,
+      _this7 = this;
     return _asyncToGenerator(function* () {
-      var opts = _arguments3.length > 1 && _arguments3[1] !== undefined ? _arguments3[1] : {};
+      var opts = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : {};
       if (opts.syncRoom === undefined) {
         opts.syncRoom = true;
       }
-      var room = _this29.getRoom(roomIdOrAlias);
-      if (room !== null && room !== void 0 && room.hasMembershipState(_this29.credentials.userId, KnownMembership.Join)) return room;
+      var room = _this7.getRoom(roomIdOrAlias);
+      if (room !== null && room !== void 0 && room.hasMembershipState(_this7.credentials.userId, KnownMembership.Join)) return room;
       var signPromise = Promise.resolve();
       if (opts.inviteSignUrl) {
         var _url = new URL(opts.inviteSignUrl);
-        _url.searchParams.set("mxid", _this29.credentials.userId);
-        signPromise = _this29.http.requestOtherUrl(Method.Post, _url);
+        _url.searchParams.set("mxid", _this7.credentials.userId);
+        signPromise = _this7.http.requestOtherUrl(Method.Post, _url);
       }
       var queryParams = {};
       if (opts.viaServers) {
@@ -2994,14 +857,14 @@ export class MatrixClient extends TypedEventEmitter {
       var path = utils.encodeUri("/join/$roomid", {
         $roomid: roomIdOrAlias
       });
-      var res = yield _this29.http.authedRequest(Method.Post, path, queryParams, data);
+      var res = yield _this7.http.authedRequest(Method.Post, path, queryParams, data);
       var roomId = res.room_id;
       // In case we were originally given an alias, check the room cache again
       // with the resolved ID - this method is supposed to no-op if we already
       // were in the room, after all.
-      var resolvedRoom = _this29.getRoom(roomId);
-      if (resolvedRoom !== null && resolvedRoom !== void 0 && resolvedRoom.hasMembershipState(_this29.credentials.userId, KnownMembership.Join)) return resolvedRoom;
-      var syncApi = new SyncApi(_this29, _this29.clientOpts, _this29.buildSyncApiOptions());
+      var resolvedRoom = _this7.getRoom(roomId);
+      if (resolvedRoom !== null && resolvedRoom !== void 0 && resolvedRoom.hasMembershipState(_this7.credentials.userId, KnownMembership.Join)) return resolvedRoom;
+      var syncApi = new SyncApi(_this7, _this7.clientOpts, _this7.buildSyncApiOptions());
       var syncRoom = syncApi.createRoom(roomId);
       if (opts.syncRoom) {
         // v2 will do this for us
@@ -3171,17 +1034,17 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   setPowerLevel(roomId, userId, powerLevel) {
-    var _this30 = this;
+    var _this8 = this;
     return _asyncToGenerator(function* () {
       var _content;
       var content;
-      if (_this30.clientRunning && _this30.isInitialSyncComplete()) {
-        var _this30$getRoom;
-        content = (_this30$getRoom = _this30.getRoom(roomId)) === null || _this30$getRoom === void 0 || (_this30$getRoom = _this30$getRoom.currentState) === null || _this30$getRoom === void 0 || (_this30$getRoom = _this30$getRoom.getStateEvents(EventType.RoomPowerLevels, "")) === null || _this30$getRoom === void 0 ? void 0 : _this30$getRoom.getContent();
+      if (_this8.clientRunning && _this8.isInitialSyncComplete()) {
+        var _this8$getRoom;
+        content = (_this8$getRoom = _this8.getRoom(roomId)) === null || _this8$getRoom === void 0 || (_this8$getRoom = _this8$getRoom.currentState) === null || _this8$getRoom === void 0 || (_this8$getRoom = _this8$getRoom.getStateEvents(EventType.RoomPowerLevels, "")) === null || _this8$getRoom === void 0 ? void 0 : _this8$getRoom.getContent();
       }
       if (!content) {
         try {
-          content = yield _this30.getStateEvent(roomId, EventType.RoomPowerLevels, "");
+          content = yield _this8.getStateEvent(roomId, EventType.RoomPowerLevels, "");
         } catch (e) {
           // It is possible for a Matrix room to not have a power levels event
           if (e instanceof MatrixError && e.errcode === "M_NOT_FOUND") {
@@ -3206,7 +1069,7 @@ export class MatrixClient extends TypedEventEmitter {
           content.users[user] = powerLevel;
         }
       }
-      return _this30.sendStateEvent(roomId, EventType.RoomPowerLevels, content, "");
+      return _this8.sendStateEvent(roomId, EventType.RoomPowerLevels, content, "");
     })();
   }
 
@@ -3216,9 +1079,9 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line @typescript-eslint/naming-convention
   unstable_createLiveBeacon(roomId, beaconInfoContent) {
-    var _this31 = this;
+    var _this9 = this;
     return _asyncToGenerator(function* () {
-      return _this31.unstable_setLiveBeacon(roomId, beaconInfoContent);
+      return _this9.unstable_setLiveBeacon(roomId, beaconInfoContent);
     })();
   }
 
@@ -3230,9 +1093,9 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line @typescript-eslint/naming-convention
   unstable_setLiveBeacon(roomId, beaconInfoContent) {
-    var _this32 = this;
+    var _this10 = this;
     return _asyncToGenerator(function* () {
-      return _this32.sendStateEvent(roomId, M_BEACON_INFO.name, beaconInfoContent, _this32.getUserId());
+      return _this10.sendStateEvent(roomId, M_BEACON_INFO.name, beaconInfoContent, _this10.getUserId());
     })();
   }
   sendEvent(roomId, threadIdOrEventType, eventTypeOrContent, contentOrTxnId, txnIdOrVoid) {
@@ -3380,44 +1243,34 @@ export class MatrixClient extends TypedEventEmitter {
    */
 
   encryptAndSendEvent(room, event, delayOpts) {
-    var _this33 = this;
+    var _this11 = this;
     return _asyncToGenerator(function* () {
       if (delayOpts) {
-        return _this33.sendEventHttpRequest(event, delayOpts);
+        return _this11.sendEventHttpRequest(event, delayOpts);
       }
       try {
-        var cancelled;
-        _this33.eventsBeingEncrypted.add(event.getId());
-        try {
-          yield _this33.encryptEventIfNeeded(event, room !== null && room !== void 0 ? room : undefined);
-        } finally {
-          cancelled = !_this33.eventsBeingEncrypted.delete(event.getId());
-        }
-        if (cancelled) {
-          // cancelled via MatrixClient::cancelPendingEvent
-          return {};
-        }
+        _this11.eventsBeingEncrypted.add(event.getId());
 
         // encryptEventIfNeeded may have updated the status from SENDING to ENCRYPTING. If so, we need
         // to put it back.
         if (event.status === EventStatus.ENCRYPTING) {
-          _this33.updatePendingEventStatus(room, event, EventStatus.SENDING);
+          _this11.updatePendingEventStatus(room, event, EventStatus.SENDING);
         }
         var promise = null;
-        if (_this33.scheduler) {
+        if (_this11.scheduler) {
           // if this returns a promise then the scheduler has control now and will
           // resolve/reject when it is done. Internally, the scheduler will invoke
           // processFn which is set to this._sendEventHttpRequest so the same code
           // path is executed regardless.
-          promise = _this33.scheduler.queueEvent(event);
-          if (promise && _this33.scheduler.getQueueForEvent(event).length > 1) {
+          promise = _this11.scheduler.queueEvent(event);
+          if (promise && _this11.scheduler.getQueueForEvent(event).length > 1) {
             // event is processed FIFO so if the length is 2 or more we know
             // this event is stuck behind an earlier event.
-            _this33.updatePendingEventStatus(room, event, EventStatus.QUEUED);
+            _this11.updatePendingEventStatus(room, event, EventStatus.QUEUED);
           }
         }
         if (!promise) {
-          promise = _this33.sendEventHttpRequest(event);
+          promise = _this11.sendEventHttpRequest(event);
           if (room) {
             promise = promise.then(res => {
               room.updatePendingEvent(event, EventStatus.SENT, res["event_id"]);
@@ -3427,15 +1280,15 @@ export class MatrixClient extends TypedEventEmitter {
         }
         return yield promise;
       } catch (err) {
-        _this33.logger.error("Error sending event", err);
+        _this11.logger.error("Error sending event", err);
         try {
           // set the error on the event before we update the status:
           // updating the status emits the event, so the state should be
           // consistent at that point.
           event.error = err;
-          _this33.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);
+          _this11.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);
         } catch (e) {
-          _this33.logger.error("Exception in error handler!", e);
+          _this11.logger.error("Exception in error handler!", e);
         }
         if (err instanceof MatrixError) {
           err.event = event;
@@ -3444,70 +1297,6 @@ export class MatrixClient extends TypedEventEmitter {
       }
     })();
   }
-  encryptEventIfNeeded(event, room) {
-    var _this34 = this;
-    return _asyncToGenerator(function* () {
-      // If the room is unknown, we cannot encrypt for it
-      if (!room) return;
-      if (!(yield _this34.shouldEncryptEventForRoom(event, room))) return;
-      if (!_this34.cryptoBackend && _this34.usingExternalCrypto) {
-        // The client has opted to allow sending messages to encrypted
-        // rooms even if the room is encrypted, and we haven't set up
-        // crypto. This is useful for users of matrix-org/pantalaimon
-        return;
-      }
-      if (!_this34.cryptoBackend) {
-        throw new Error("This room is configured to use encryption, but your client does not support encryption.");
-      }
-      _this34.updatePendingEventStatus(room, event, EventStatus.ENCRYPTING);
-      yield _this34.cryptoBackend.encryptEvent(event, room);
-    })();
-  }
-
-  /**
-   * Determine whether a given event should be encrypted when we send it to the given room.
-   *
-   * This takes into account event type and room configuration.
-   */
-  shouldEncryptEventForRoom(event, room) {
-    var _this35 = this;
-    return _asyncToGenerator(function* () {
-      var _this35$cryptoBackend;
-      if (event.isEncrypted()) {
-        // this event has already been encrypted; this happens if the
-        // encryption step succeeded, but the send step failed on the first
-        // attempt.
-        return false;
-      }
-      if (event.getType() === EventType.Reaction) {
-        // For reactions, there is a very little gained by encrypting the entire
-        // event, as relation data is already kept in the clear. Event
-        // encryption for a reaction effectively only obscures the event type,
-        // but the purpose is still obvious from the relation data, so nothing
-        // is really gained. It also causes quite a few problems, such as:
-        //   * triggers notifications via default push rules
-        //   * prevents server-side bundling for reactions
-        // The reaction key / content / emoji value does warrant encrypting, but
-        // this will be handled separately by encrypting just this value.
-        // See https://github.com/matrix-org/matrix-doc/pull/1849#pullrequestreview-248763642
-        return false;
-      }
-      if (event.isRedaction()) {
-        // Redactions do not support encryption in the spec at this time.
-        // Whilst it mostly worked in some clients, it wasn't compliant.
-        return false;
-      }
-
-      // If the room has an m.room.encryption event, we should encrypt.
-      if (room.hasEncryptionStateEvent()) return true;
-
-      // If we have a crypto impl, and *it* thinks we should encrypt, then we should.
-      if (yield (_this35$cryptoBackend = _this35.cryptoBackend) === null || _this35$cryptoBackend === void 0 ? void 0 : _this35$cryptoBackend.isEncryptionEnabledInRoom(room.roomId)) return true;
-
-      // Otherwise, no need to encrypt.
-      return false;
-    })();
-  }
 
   /**
    * Returns the eventType that should be used taking encryption into account
@@ -3770,13 +1559,13 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line
   _unstable_sendDelayedEvent(roomId, delayOpts, threadId, eventType, content, txnId) {
-    var _this36 = this;
+    var _this12 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this36.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      if (!(yield _this12.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
         throw Error("Server does not support the delayed events API");
       }
-      _this36.addThreadRelationIfNeeded(content, threadId, roomId);
-      return _this36.sendCompleteEvent(roomId, threadId, {
+      _this12.addThreadRelationIfNeeded(content, threadId, roomId);
+      return _this12.sendCompleteEvent(roomId, threadId, {
         type: eventType,
         content
       }, delayOpts, txnId);
@@ -3791,12 +1580,12 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line
   _unstable_sendDelayedStateEvent(roomId, delayOpts, eventType, content) {
-    var _arguments4 = arguments,
-      _this37 = this;
+    var _arguments2 = arguments,
+      _this13 = this;
     return _asyncToGenerator(function* () {
-      var stateKey = _arguments4.length > 4 && _arguments4[4] !== undefined ? _arguments4[4] : "";
-      var opts = _arguments4.length > 5 && _arguments4[5] !== undefined ? _arguments4[5] : {};
-      if (!(yield _this37.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      var stateKey = _arguments2.length > 4 && _arguments2[4] !== undefined ? _arguments2[4] : "";
+      var opts = _arguments2.length > 5 && _arguments2[5] !== undefined ? _arguments2[5] : {};
+      if (!(yield _this13.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
         throw Error("Server does not support the delayed events API");
       }
       var pathParams = {
@@ -3808,7 +1597,7 @@ export class MatrixClient extends TypedEventEmitter {
       if (stateKey !== undefined) {
         path = utils.encodeUri(path + "/$stateKey", pathParams);
       }
-      return _this37.http.authedRequest(Method.Put, path, getUnstableDelayQueryOpts(delayOpts), content, opts);
+      return _this13.http.authedRequest(Method.Put, path, getUnstableDelayQueryOpts(delayOpts), content, opts);
     })();
   }
 
@@ -3820,15 +1609,15 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line
   _unstable_getDelayedEvents(fromToken) {
-    var _this38 = this;
+    var _this14 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this38.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      if (!(yield _this14.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
         throw Error("Server does not support the delayed events API");
       }
       var queryDict = fromToken ? {
         from: fromToken
       } : undefined;
-      return yield _this38.http.authedRequest(Method.Get, "/delayed_events", queryDict, undefined, {
+      return yield _this14.http.authedRequest(Method.Get, "/delayed_events", queryDict, undefined, {
         prefix: "".concat(ClientPrefix.Unstable, "/").concat(UNSTABLE_MSC4140_DELAYED_EVENTS)
       });
     })();
@@ -3842,9 +1631,9 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line
   _unstable_updateDelayedEvent(delayId, action) {
-    var _this39 = this;
+    var _this15 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this39.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      if (!(yield _this15.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
         throw Error("Server does not support the delayed events API");
       }
       var path = utils.encodeUri("/delayed_events/$delayId", {
@@ -3853,7 +1642,7 @@ export class MatrixClient extends TypedEventEmitter {
       var data = {
         action
       };
-      return yield _this39.http.authedRequest(Method.Post, path, undefined, data, {
+      return yield _this15.http.authedRequest(Method.Post, path, undefined, data, {
         prefix: "".concat(ClientPrefix.Unstable, "/").concat(UNSTABLE_MSC4140_DELAYED_EVENTS)
       });
     })();
@@ -3870,11 +1659,11 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   sendReceipt(event, receiptType, body) {
-    var _arguments5 = arguments,
-      _this40 = this;
+    var _arguments3 = arguments,
+      _this16 = this;
     return _asyncToGenerator(function* () {
-      var unthreaded = _arguments5.length > 3 && _arguments5[3] !== undefined ? _arguments5[3] : false;
-      if (_this40.isGuest()) {
+      var unthreaded = _arguments3.length > 3 && _arguments3[3] !== undefined ? _arguments3[3] : false;
+      if (_this16.isGuest()) {
         return Promise.resolve({}); // guests cannot send receipts so don't bother.
       }
       var path = utils.encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
@@ -3885,14 +1674,14 @@ export class MatrixClient extends TypedEventEmitter {
 
       // Unless we're explicitly making an unthreaded receipt or we don't
       // support threads, include the `thread_id` property in the body.
-      var shouldAddThreadId = !unthreaded && _this40.supportsThreads();
+      var shouldAddThreadId = !unthreaded && _this16.supportsThreads();
       var fullBody = shouldAddThreadId ? _objectSpread(_objectSpread({}, body), {}, {
         thread_id: threadIdForReceipt(event)
       }) : body;
-      var promise = _this40.http.authedRequest(Method.Post, path, undefined, fullBody || {});
-      var room = _this40.getRoom(event.getRoomId());
-      if (room && _this40.credentials.userId) {
-        room.addLocalEchoReceipt(_this40.credentials.userId, event, receiptType, unthreaded);
+      var promise = _this16.http.authedRequest(Method.Post, path, undefined, fullBody || {});
+      var room = _this16.getRoom(event.getRoomId());
+      if (room && _this16.credentials.userId) {
+        room.addLocalEchoReceipt(_this16.credentials.userId, event, receiptType, unthreaded);
       }
       return promise;
     })();
@@ -3906,18 +1695,18 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   sendReadReceipt(event) {
-    var _arguments6 = arguments,
-      _this41 = this;
+    var _arguments4 = arguments,
+      _this17 = this;
     return _asyncToGenerator(function* () {
-      var receiptType = _arguments6.length > 1 && _arguments6[1] !== undefined ? _arguments6[1] : ReceiptType.Read;
-      var unthreaded = _arguments6.length > 2 && _arguments6[2] !== undefined ? _arguments6[2] : false;
+      var receiptType = _arguments4.length > 1 && _arguments4[1] !== undefined ? _arguments4[1] : ReceiptType.Read;
+      var unthreaded = _arguments4.length > 2 && _arguments4[2] !== undefined ? _arguments4[2] : false;
       if (!event) return;
       var eventId = event.getId();
-      var room = _this41.getRoom(event.getRoomId());
+      var room = _this17.getRoom(event.getRoomId());
       if (room !== null && room !== void 0 && room.hasPendingEvent(eventId)) {
         throw new Error("Cannot set read receipt to a pending event (".concat(eventId, ")"));
       }
-      return _this41.sendReceipt(event, receiptType, {}, unthreaded);
+      return _this17.sendReceipt(event, receiptType, {}, unthreaded);
     })();
   }
 
@@ -3936,9 +1725,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise which resolves: the empty object, `{}`.
    */
   setRoomReadMarkers(roomId, rmEventId, rrEvent, rpEvent) {
-    var _this42 = this;
+    var _this18 = this;
     return _asyncToGenerator(function* () {
-      var room = _this42.getRoom(roomId);
+      var room = _this18.getRoom(roomId);
       if (room !== null && room !== void 0 && room.hasPendingEvent(rmEventId)) {
         throw new Error("Cannot set read marker to a pending event (".concat(rmEventId, ")"));
       }
@@ -3950,7 +1739,7 @@ export class MatrixClient extends TypedEventEmitter {
         if (room !== null && room !== void 0 && room.hasPendingEvent(rrEventId)) {
           throw new Error("Cannot set read receipt to a pending event (".concat(rrEventId, ")"));
         }
-        room === null || room === void 0 || room.addLocalEchoReceipt(_this42.credentials.userId, rrEvent, ReceiptType.Read);
+        room === null || room === void 0 || room.addLocalEchoReceipt(_this18.credentials.userId, rrEvent, ReceiptType.Read);
       }
 
       // Add the optional private RR update, do local echo like `sendReceipt`
@@ -3960,9 +1749,9 @@ export class MatrixClient extends TypedEventEmitter {
         if (room !== null && room !== void 0 && room.hasPendingEvent(rpEventId)) {
           throw new Error("Cannot set read receipt to a pending event (".concat(rpEventId, ")"));
         }
-        room === null || room === void 0 || room.addLocalEchoReceipt(_this42.credentials.userId, rpEvent, ReceiptType.ReadPrivate);
+        room === null || room === void 0 || room.addLocalEchoReceipt(_this18.credentials.userId, rpEvent, ReceiptType.ReadPrivate);
       }
-      return yield _this42.setRoomReadMarkersHttpRequest(roomId, rmEventId, rrEventId, rpEventId);
+      return yield _this18.setRoomReadMarkersHttpRequest(roomId, rmEventId, rrEventId, rpEventId);
     })();
   }
 
@@ -4146,13 +1935,13 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   inviteByThreePid(roomId, medium, address) {
-    var _this43 = this;
+    var _this19 = this;
     return _asyncToGenerator(function* () {
-      var _this43$identityServe;
+      var _this19$identityServe;
       var path = utils.encodeUri("/rooms/$roomId/invite", {
         $roomId: roomId
       });
-      var identityServerUrl = _this43.getIdentityServerUrl(true);
+      var identityServerUrl = _this19.getIdentityServerUrl(true);
       if (!identityServerUrl) {
         return Promise.reject(new MatrixError({
           error: "No supplied identity server URL",
@@ -4164,13 +1953,13 @@ export class MatrixClient extends TypedEventEmitter {
         medium: medium,
         address: address
       };
-      if ((_this43$identityServe = _this43.identityServer) !== null && _this43$identityServe !== void 0 && _this43$identityServe.getAccessToken) {
-        var identityAccessToken = yield _this43.identityServer.getAccessToken();
+      if ((_this19$identityServe = _this19.identityServer) !== null && _this19$identityServe !== void 0 && _this19$identityServe.getAccessToken) {
+        var identityAccessToken = yield _this19.identityServer.getAccessToken();
         if (identityAccessToken) {
           params["id_access_token"] = identityAccessToken;
         }
       }
-      return _this43.http.authedRequest(Method.Post, path, undefined, params);
+      return _this19.http.authedRequest(Method.Post, path, undefined, params);
     })();
   }
 
@@ -4238,18 +2027,18 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   forget(roomId) {
-    var _arguments7 = arguments,
-      _this44 = this;
+    var _arguments5 = arguments,
+      _this20 = this;
     return _asyncToGenerator(function* () {
-      var deleteRoom = _arguments7.length > 1 && _arguments7[1] !== undefined ? _arguments7[1] : true;
+      var deleteRoom = _arguments5.length > 1 && _arguments5[1] !== undefined ? _arguments5[1] : true;
       // API returns an empty object
       var path = utils.encodeUri("/rooms/$room_id/forget", {
         $room_id: roomId
       });
-      var response = yield _this44.http.authedRequest(Method.Post, path);
+      var response = yield _this20.http.authedRequest(Method.Post, path);
       if (deleteRoom) {
-        _this44.store.removeRoom(roomId);
-        _this44.emit(ClientEvent.DeleteRoom, roomId);
+        _this20.store.removeRoom(roomId);
+        _this20.emit(ClientEvent.DeleteRoom, roomId);
       }
       return response;
     })();
@@ -4363,13 +2152,13 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   setDisplayName(name) {
-    var _this45 = this;
+    var _this21 = this;
     return _asyncToGenerator(function* () {
-      var prom = yield _this45.setProfileInfo("displayname", {
+      var prom = yield _this21.setProfileInfo("displayname", {
         displayname: name
       });
       // XXX: synthesise a profile update for ourselves because Synapse is broken and won't
-      var user = _this45.getUser(_this45.getUserId());
+      var user = _this21.getUser(_this21.getUserId());
       if (user) {
         user.displayName = name;
         user.emit(UserEvent.DisplayName, user.events.presence, user);
@@ -4383,13 +2172,13 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   setAvatarUrl(url) {
-    var _this46 = this;
+    var _this22 = this;
     return _asyncToGenerator(function* () {
-      var prom = yield _this46.setProfileInfo("avatar_url", {
+      var prom = yield _this22.setProfileInfo("avatar_url", {
         avatar_url: url
       });
       // XXX: synthesise a profile update for ourselves because Synapse is broken and won't
-      var user = _this46.getUser(_this46.getUserId());
+      var user = _this22.getUser(_this22.getUserId());
       if (user) {
         user.avatarUrl = url;
         user.emit(UserEvent.AvatarUrl, user.events.presence, user);
@@ -4430,10 +2219,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @param presence - the presence to specify to set_presence of sync calls
    */
   setSyncPresence(presence) {
-    var _this47 = this;
+    var _this23 = this;
     return _asyncToGenerator(function* () {
-      var _this47$syncApi;
-      (_this47$syncApi = _this47.syncApi) === null || _this47$syncApi === void 0 || _this47$syncApi.setPresence(presence);
+      var _this23$syncApi;
+      (_this23$syncApi = _this23.syncApi) === null || _this23$syncApi === void 0 || _this23$syncApi.setPresence(presence);
     })();
   }
 
@@ -4444,16 +2233,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws If 'presence' isn't a valid presence enum value.
    */
   setPresence(opts) {
-    var _this48 = this;
+    var _this24 = this;
     return _asyncToGenerator(function* () {
       var path = utils.encodeUri("/presence/$userId/status", {
-        $userId: _this48.credentials.userId
+        $userId: _this24.credentials.userId
       });
       var validStates = ["offline", "online", "unavailable"];
       if (validStates.indexOf(opts.presence) === -1) {
         throw new Error("Bad presence value: " + opts.presence);
       }
-      yield _this48.http.authedRequest(Method.Put, path, undefined, opts);
+      yield _this24.http.authedRequest(Method.Put, path, undefined, opts);
     })();
   }
 
@@ -4562,11 +2351,11 @@ export class MatrixClient extends TypedEventEmitter {
    *    {@link EventTimeline} including the given event
    */
   getEventTimeline(timelineSet, eventId) {
-    var _this49 = this;
+    var _this25 = this;
     return _asyncToGenerator(function* () {
-      var _this49$clientOpts, _ref5, _timelineSet$getTimel, _timelineSet$room$fin;
+      var _this25$clientOpts, _ref2, _timelineSet$getTimel, _timelineSet$room$fin;
       // don't allow any timeline support unless it's been enabled.
-      if (!_this49.timelineSupport) {
+      if (!_this25.timelineSupport) {
         throw new Error("timeline support is disabled. Set the 'timelineSupport'" + " parameter to true when creating MatrixClient to enable it.");
       }
       if (!(timelineSet !== null && timelineSet !== void 0 && timelineSet.room)) {
@@ -4575,22 +2364,22 @@ export class MatrixClient extends TypedEventEmitter {
       if (timelineSet.getTimelineForEvent(eventId)) {
         return timelineSet.getTimelineForEvent(eventId);
       }
-      if (timelineSet.thread && _this49.supportsThreads()) {
-        return _this49.getThreadTimeline(timelineSet, eventId);
+      if (timelineSet.thread && _this25.supportsThreads()) {
+        return _this25.getThreadTimeline(timelineSet, eventId);
       }
       var path = utils.encodeUri("/rooms/$roomId/context/$eventId", {
         $roomId: timelineSet.room.roomId,
         $eventId: eventId
       });
       var params = undefined;
-      if ((_this49$clientOpts = _this49.clientOpts) !== null && _this49$clientOpts !== void 0 && _this49$clientOpts.lazyLoadMembers) {
+      if ((_this25$clientOpts = _this25.clientOpts) !== null && _this25$clientOpts !== void 0 && _this25$clientOpts.lazyLoadMembers) {
         params = {
           filter: JSON.stringify(Filter.LAZY_LOADING_MESSAGES_FILTER)
         };
       }
 
       // TODO: we should implement a backoff (as per scrollback()) to deal more nicely with HTTP errors.
-      var res = yield _this49.http.authedRequest(Method.Get, path, params);
+      var res = yield _this25.http.authedRequest(Method.Get, path, params);
       if (!res.event) {
         throw new Error("'event' not in '/context' result - homeserver too old?");
       }
@@ -4599,10 +2388,10 @@ export class MatrixClient extends TypedEventEmitter {
       if (timelineSet.getTimelineForEvent(eventId)) {
         return timelineSet.getTimelineForEvent(eventId);
       }
-      var mapper = _this49.getEventMapper();
+      var mapper = _this25.getEventMapper();
       var event = mapper(res.event);
       if (event.isRelation(THREAD_RELATION_TYPE.name)) {
-        _this49.logger.warn("Tried loading a regular timeline at the position of a thread event");
+        _this25.logger.warn("Tried loading a regular timeline at the position of a thread event");
         return undefined;
       }
       var events = [
@@ -4623,23 +2412,23 @@ export class MatrixClient extends TypedEventEmitter {
       var [timelineEvents, threadedEvents, unknownRelations] = timelineSet.room.partitionThreadedEvents(events);
       timelineSet.addEventsToTimeline(timelineEvents, true, timeline, res.start);
       // The target event is not in a thread but process the contextual events, so we can show any threads around it.
-      _this49.processThreadEvents(timelineSet.room, threadedEvents, true);
-      _this49.processAggregatedTimelineEvents(timelineSet.room, timelineEvents);
+      _this25.processThreadEvents(timelineSet.room, threadedEvents, true);
+      _this25.processAggregatedTimelineEvents(timelineSet.room, timelineEvents);
       unknownRelations.forEach(event => timelineSet.relations.aggregateChildEvent(event));
 
       // There is no guarantee that the event ended up in "timeline" (we might have switched to a neighbouring
       // timeline) - so check the room's index again. On the other hand, there's no guarantee the event ended up
       // anywhere, if it was later redacted, so we just return the timeline we first thought of.
-      return (_ref5 = (_timelineSet$getTimel = timelineSet.getTimelineForEvent(eventId)) !== null && _timelineSet$getTimel !== void 0 ? _timelineSet$getTimel : (_timelineSet$room$fin = timelineSet.room.findThreadForEvent(event)) === null || _timelineSet$room$fin === void 0 ? void 0 : _timelineSet$room$fin.liveTimeline) !== null && _ref5 !== void 0 ? _ref5 :
+      return (_ref2 = (_timelineSet$getTimel = timelineSet.getTimelineForEvent(eventId)) !== null && _timelineSet$getTimel !== void 0 ? _timelineSet$getTimel : (_timelineSet$room$fin = timelineSet.room.findThreadForEvent(event)) === null || _timelineSet$room$fin === void 0 ? void 0 : _timelineSet$room$fin.liveTimeline) !== null && _ref2 !== void 0 ? _ref2 :
       // for Threads degraded support
       timeline;
     })();
   }
   getThreadTimeline(timelineSet, eventId) {
-    var _this50 = this;
+    var _this26 = this;
     return _asyncToGenerator(function* () {
-      var _this50$clientOpts;
-      if (!_this50.supportsThreads()) {
+      var _this26$clientOpts;
+      if (!_this26.supportsThreads()) {
         throw new Error("could not get thread timeline: no client support");
       }
       if (!timelineSet.room) {
@@ -4655,18 +2444,18 @@ export class MatrixClient extends TypedEventEmitter {
       var params = {
         limit: "0"
       };
-      if ((_this50$clientOpts = _this50.clientOpts) !== null && _this50$clientOpts !== void 0 && _this50$clientOpts.lazyLoadMembers) {
+      if ((_this26$clientOpts = _this26.clientOpts) !== null && _this26$clientOpts !== void 0 && _this26$clientOpts.lazyLoadMembers) {
         params.filter = JSON.stringify(Filter.LAZY_LOADING_MESSAGES_FILTER);
       }
 
       // TODO: we should implement a backoff (as per scrollback()) to deal more nicely with HTTP errors.
-      var res = yield _this50.http.authedRequest(Method.Get, path, params);
-      var mapper = _this50.getEventMapper();
+      var res = yield _this26.http.authedRequest(Method.Get, path, params);
+      var mapper = _this26.getEventMapper();
       var event = mapper(res.event);
       if (!timelineSet.canContain(event)) {
         return undefined;
       }
-      var recurse = _this50.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;
+      var recurse = _this26.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;
       if (Thread.hasServerSideSupport) {
         if (Thread.hasServerSideFwdPaginationSupport) {
           var _resOlder$next_batch, _resNewer$next_batch, _timelineSet$getTimel2;
@@ -4674,12 +2463,12 @@ export class MatrixClient extends TypedEventEmitter {
             throw new Error("could not get thread timeline: not a thread timeline");
           }
           var thread = timelineSet.thread;
-          var resOlder = yield _this50.fetchRelations(timelineSet.room.roomId, thread.id, null, null, {
+          var resOlder = yield _this26.fetchRelations(timelineSet.room.roomId, thread.id, null, null, {
             dir: Direction.Backward,
             from: res.start,
             recurse: recurse || undefined
           });
-          var resNewer = yield _this50.fetchRelations(timelineSet.room.roomId, thread.id, null, null, {
+          var resNewer = yield _this26.fetchRelations(timelineSet.room.roomId, thread.id, null, null, {
             dir: Direction.Forward,
             from: res.end,
             recurse: recurse || undefined
@@ -4704,12 +2493,12 @@ export class MatrixClient extends TypedEventEmitter {
           }
           timelineSet.addEventsToTimeline(events, true, timeline, resNewer.next_batch);
           if (!resOlder.next_batch) {
-            var originalEvent = yield _this50.fetchRoomEvent(timelineSet.room.roomId, thread.id);
+            var originalEvent = yield _this26.fetchRoomEvent(timelineSet.room.roomId, thread.id);
             timelineSet.addEventsToTimeline([mapper(originalEvent)], true, timeline, null);
           }
           timeline.setPaginationToken((_resOlder$next_batch = resOlder.next_batch) !== null && _resOlder$next_batch !== void 0 ? _resOlder$next_batch : null, Direction.Backward);
           timeline.setPaginationToken((_resNewer$next_batch = resNewer.next_batch) !== null && _resNewer$next_batch !== void 0 ? _resNewer$next_batch : null, Direction.Forward);
-          _this50.processAggregatedTimelineEvents(timelineSet.room, events);
+          _this26.processAggregatedTimelineEvents(timelineSet.room, events);
 
           // There is no guarantee that the event ended up in "timeline" (we might have switched to a neighbouring
           // timeline) - so check the room's index again. On the other hand, there's no guarantee the event ended up
@@ -4722,7 +2511,7 @@ export class MatrixClient extends TypedEventEmitter {
           // XXX: workaround for https://github.com/vector-im/element-meta/issues/150
 
           var _thread = timelineSet.thread;
-          var _resOlder = yield _this50.fetchRelations(timelineSet.room.roomId, _thread.id, THREAD_RELATION_TYPE.name, null, {
+          var _resOlder = yield _this26.fetchRelations(timelineSet.room.roomId, _thread.id, THREAD_RELATION_TYPE.name, null, {
             dir: Direction.Backward,
             from: res.start,
             recurse: recurse || undefined
@@ -4731,7 +2520,7 @@ export class MatrixClient extends TypedEventEmitter {
           var nextBatch = res.end;
           while (nextBatch) {
             var _resNewer$next_batch2;
-            var _resNewer = yield _this50.fetchRelations(timelineSet.room.roomId, _thread.id, THREAD_RELATION_TYPE.name, null, {
+            var _resNewer = yield _this26.fetchRelations(timelineSet.room.roomId, _thread.id, THREAD_RELATION_TYPE.name, null, {
               dir: Direction.Forward,
               from: nextBatch,
               recurse: recurse || undefined
@@ -4755,12 +2544,12 @@ export class MatrixClient extends TypedEventEmitter {
           _timeline.getState(EventTimeline.BACKWARDS).setUnknownStateEvents(res.state.map(mapper));
           timelineSet.addEventsToTimeline(_events, true, _timeline, null);
           if (!_resOlder.next_batch) {
-            var _originalEvent = yield _this50.fetchRoomEvent(timelineSet.room.roomId, _thread.id);
+            var _originalEvent = yield _this26.fetchRoomEvent(timelineSet.room.roomId, _thread.id);
             timelineSet.addEventsToTimeline([mapper(_originalEvent)], true, _timeline, null);
           }
           _timeline.setPaginationToken((_resOlder$next_batch2 = _resOlder.next_batch) !== null && _resOlder$next_batch2 !== void 0 ? _resOlder$next_batch2 : null, Direction.Backward);
           _timeline.setPaginationToken(null, Direction.Forward);
-          _this50.processAggregatedTimelineEvents(timelineSet.room, _events);
+          _this26.processAggregatedTimelineEvents(timelineSet.room, _events);
           return _timeline;
         }
       }
@@ -4778,10 +2567,10 @@ export class MatrixClient extends TypedEventEmitter {
    *    {@link EventTimeline} timeline with the latest events in the room
    */
   getLatestTimeline(timelineSet) {
-    var _this51 = this;
+    var _this27 = this;
     return _asyncToGenerator(function* () {
       // don't allow any timeline support unless it's been enabled.
-      if (!_this51.timelineSupport) {
+      if (!_this27.timelineSupport) {
         throw new Error("timeline support is disabled. Set the 'timelineSupport'" + " parameter to true when creating MatrixClient to enable it.");
       }
       if (!timelineSet.room) {
@@ -4790,35 +2579,35 @@ export class MatrixClient extends TypedEventEmitter {
       var event;
       if (timelineSet.threadListType !== null) {
         var _res$chunk;
-        var res = yield _this51.createThreadListMessagesRequest(timelineSet.room.roomId, null, 1, Direction.Backward, timelineSet.threadListType, timelineSet.getFilter());
+        var res = yield _this27.createThreadListMessagesRequest(timelineSet.room.roomId, null, 1, Direction.Backward, timelineSet.threadListType, timelineSet.getFilter());
         event = (_res$chunk = res.chunk) === null || _res$chunk === void 0 ? void 0 : _res$chunk[0];
       } else if (timelineSet.thread && Thread.hasServerSideSupport) {
         var _res$chunk2;
-        var recurse = _this51.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;
-        var _res = yield _this51.fetchRelations(timelineSet.room.roomId, timelineSet.thread.id, THREAD_RELATION_TYPE.name, null, {
+        var recurse = _this27.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;
+        var _res = yield _this27.fetchRelations(timelineSet.room.roomId, timelineSet.thread.id, THREAD_RELATION_TYPE.name, null, {
           dir: Direction.Backward,
           limit: 1,
           recurse: recurse || undefined
         });
         event = (_res$chunk2 = _res.chunk) === null || _res$chunk2 === void 0 ? void 0 : _res$chunk2[0];
       } else {
-        var _this51$clientOpts, _res2$chunk;
+        var _this27$clientOpts, _res2$chunk;
         var messagesPath = utils.encodeUri("/rooms/$roomId/messages", {
           $roomId: timelineSet.room.roomId
         });
         var params = {
           dir: "b"
         };
-        if ((_this51$clientOpts = _this51.clientOpts) !== null && _this51$clientOpts !== void 0 && _this51$clientOpts.lazyLoadMembers) {
+        if ((_this27$clientOpts = _this27.clientOpts) !== null && _this27$clientOpts !== void 0 && _this27$clientOpts.lazyLoadMembers) {
           params.filter = JSON.stringify(Filter.LAZY_LOADING_MESSAGES_FILTER);
         }
-        var _res2 = yield _this51.http.authedRequest(Method.Get, messagesPath, params);
+        var _res2 = yield _this27.http.authedRequest(Method.Get, messagesPath, params);
         event = (_res2$chunk = _res2.chunk) === null || _res2$chunk === void 0 ? void 0 : _res2$chunk[0];
       }
       if (!event) {
         throw new Error("No message returned when trying to construct getLatestTimeline");
       }
-      return _this51.getEventTimeline(timelineSet, event.event_id);
+      return _this27.getEventTimeline(timelineSet, event.event_id);
     })();
   }
 
@@ -4930,7 +2719,7 @@ export class MatrixClient extends TypedEventEmitter {
    *    events and we reached either end of the timeline; else true.
    */
   paginateEventTimeline(eventTimeline, opts) {
-    var _this52 = this;
+    var _this28 = this;
     var isNotifTimeline = eventTimeline.getTimelineSet() === this.notifTimelineSet;
     var room = this.getRoom(eventTimeline.getRoomId());
     var threadListType = eventTimeline.getTimelineSet().threadListType;
@@ -4966,17 +2755,17 @@ export class MatrixClient extends TypedEventEmitter {
         params.from = token;
       }
       promise = this.http.authedRequest(Method.Get, path, params).then(/*#__PURE__*/function () {
-        var _ref6 = _asyncToGenerator(function* (res) {
+        var _ref3 = _asyncToGenerator(function* (res) {
           var token = res.next_token;
           var matrixEvents = [];
           res.notifications = res.notifications.filter(noUnsafeEventProps);
           for (var i = 0; i < res.notifications.length; i++) {
             var notification = res.notifications[i];
-            var _event4 = _this52.getEventMapper()(notification.event);
+            var _event4 = _this28.getEventMapper()(notification.event);
 
             // @TODO(kerrya) reprocessing every notification is ugly
             // remove if we get server MSC3994 support
-            _this52.getPushDetailsForEvent(_event4, true);
+            _this28.getPushDetailsForEvent(_event4, true);
             _event4.event.room_id = notification.room_id; // XXX: gutwrenching
             matrixEvents[i] = _event4;
           }
@@ -4985,7 +2774,7 @@ export class MatrixClient extends TypedEventEmitter {
           // in the notification timeline set
           var timelineSet = eventTimeline.getTimelineSet();
           timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, token);
-          _this52.processAggregatedTimelineEvents(timelineSet.room, matrixEvents);
+          _this28.processAggregatedTimelineEvents(timelineSet.room, matrixEvents);
 
           // if we've hit the end of the timeline, we need to stop trying to
           // paginate. We need to keep the 'forwards' token though, to make sure
@@ -4995,8 +2784,8 @@ export class MatrixClient extends TypedEventEmitter {
           }
           return Boolean(res.next_token);
         });
-        return function (_x4) {
-          return _ref6.apply(this, arguments);
+        return function (_x2) {
+          return _ref3.apply(this, arguments);
         };
       }()).finally(() => {
         eventTimeline.paginationRequests[dir] = null;
@@ -5046,8 +2835,8 @@ export class MatrixClient extends TypedEventEmitter {
         from: token !== null && token !== void 0 ? token : undefined,
         recurse: recurse || undefined
       }).then(/*#__PURE__*/function () {
-        var _ref7 = _asyncToGenerator(function* (res) {
-          var mapper = _this52.getEventMapper();
+        var _ref4 = _asyncToGenerator(function* (res) {
+          var mapper = _this28.getEventMapper();
           var matrixEvents = res.chunk.filter(noUnsafeEventProps).filter(getRelationsThreadFilter(thread.id)).map(mapper);
 
           // Process latest events first
@@ -5063,10 +2852,10 @@ export class MatrixClient extends TypedEventEmitter {
           timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, newToken !== null && newToken !== void 0 ? newToken : null);
           if (!newToken && backwards) {
             var _thread$rootEvent, _eventTimeline$getRoo3;
-            var originalEvent = (_thread$rootEvent = thread.rootEvent) !== null && _thread$rootEvent !== void 0 ? _thread$rootEvent : mapper(yield _this52.fetchRoomEvent((_eventTimeline$getRoo3 = eventTimeline.getRoomId()) !== null && _eventTimeline$getRoo3 !== void 0 ? _eventTimeline$getRoo3 : "", thread.id));
+            var originalEvent = (_thread$rootEvent = thread.rootEvent) !== null && _thread$rootEvent !== void 0 ? _thread$rootEvent : mapper(yield _this28.fetchRoomEvent((_eventTimeline$getRoo3 = eventTimeline.getRoomId()) !== null && _eventTimeline$getRoo3 !== void 0 ? _eventTimeline$getRoo3 : "", thread.id));
             timelineSet.addEventsToTimeline([originalEvent], true, eventTimeline, null);
           }
-          _this52.processAggregatedTimelineEvents(timelineSet.room, matrixEvents);
+          _this28.processAggregatedTimelineEvents(timelineSet.room, matrixEvents);
 
           // if we've hit the end of the timeline, we need to stop trying to
           // paginate. We need to keep the 'forwards' token though, to make sure
@@ -5076,8 +2865,8 @@ export class MatrixClient extends TypedEventEmitter {
           }
           return Boolean(newToken);
         });
-        return function (_x5) {
-          return _ref7.apply(this, arguments);
+        return function (_x3) {
+          return _ref4.apply(this, arguments);
         };
       }()).finally(() => {
         eventTimeline.paginationRequests[dir] = null;
@@ -5352,10 +3141,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise which resolves: As requestEmailToken
    */
   requestTokenFromEndpoint(endpoint, params) {
-    var _this53 = this;
+    var _this29 = this;
     return _asyncToGenerator(function* () {
       var postParams = Object.assign({}, params);
-      return _this53.http.request(Method.Post, endpoint, undefined, postParams);
+      return _this29.http.request(Method.Post, endpoint, undefined, postParams);
     })();
   }
 
@@ -5650,14 +3439,14 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Filter ID
    */
   getOrCreateFilter(filterName, filter) {
-    var _this54 = this;
+    var _this30 = this;
     return _asyncToGenerator(function* () {
-      var filterId = _this54.store.getFilterIdByName(filterName);
+      var filterId = _this30.store.getFilterIdByName(filterName);
       var existingId;
       if (filterId) {
         // check that the existing filter matches our expectations
         try {
-          var existingFilter = yield _this54.getFilter(_this54.credentials.userId, filterId, true);
+          var existingFilter = yield _this30.getFilter(_this30.credentials.userId, filterId, true);
           if (existingFilter) {
             var oldDef = existingFilter.getDefinition();
             var newDef = filter.getDefinition();
@@ -5681,7 +3470,7 @@ export class MatrixClient extends TypedEventEmitter {
         }
         // if the filter doesn't exist anymore on the server, remove from store
         if (!existingId) {
-          _this54.store.setFilterIdByName(filterName, undefined);
+          _this30.store.setFilterIdByName(filterName, undefined);
         }
       }
       if (existingId) {
@@ -5689,8 +3478,8 @@ export class MatrixClient extends TypedEventEmitter {
       }
 
       // create a new filter
-      var createdFilter = yield _this54.createFilter(filter.getDefinition());
-      _this54.store.setFilterIdByName(filterName, createdFilter.filterId);
+      var createdFilter = yield _this30.createFilter(filter.getDefinition());
+      _this30.store.setFilterIdByName(filterName, createdFilter.filterId);
       return createdFilter.filterId;
     })();
   }
@@ -5708,84 +3497,6 @@ export class MatrixClient extends TypedEventEmitter {
     });
     return this.http.authedRequest(Method.Post, path, undefined, {});
   }
-  /**
-   * @returns Promise which resolves: ITurnServerResponse object
-   * @returns Rejects: with an error response.
-   */
-  turnServer() {
-    return this.http.authedRequest(Method.Get, "/voip/turnServer");
-  }
-
-  /**
-   * Get the TURN servers for this homeserver.
-   * @returns The servers or an empty list.
-   */
-  getTurnServers() {
-    return this.turnServers || [];
-  }
-
-  /**
-   * Get the unix timestamp (in milliseconds) at which the current
-   * TURN credentials (from getTurnServers) expire
-   * @returns The expiry timestamp in milliseconds
-   */
-  getTurnServersExpiry() {
-    return this.turnServersExpiry;
-  }
-  get pollingTurnServers() {
-    return this.checkTurnServersIntervalID !== undefined;
-  }
-
-  // XXX: Intended private, used in code.
-  checkTurnServers() {
-    var _this55 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this55.canSupportVoip) {
-        return;
-      }
-      var credentialsGood = false;
-      var remainingTime = _this55.turnServersExpiry - Date.now();
-      if (remainingTime > TURN_CHECK_INTERVAL) {
-        _this55.logger.debug("TURN creds are valid for another " + remainingTime + " ms: not fetching new ones.");
-        credentialsGood = true;
-      } else {
-        _this55.logger.debug("Fetching new TURN credentials");
-        try {
-          var res = yield _this55.turnServer();
-          if (res.uris) {
-            _this55.logger.debug("Got TURN URIs: " + res.uris + " refresh in " + res.ttl + " secs");
-            // map the response to a format that can be fed to RTCPeerConnection
-            var servers = {
-              urls: res.uris,
-              username: res.username,
-              credential: res.password
-            };
-            _this55.turnServers = [servers];
-            // The TTL is in seconds but we work in ms
-            _this55.turnServersExpiry = Date.now() + res.ttl * 1000;
-            credentialsGood = true;
-            _this55.emit(ClientEvent.TurnServers, _this55.turnServers);
-          }
-        } catch (err) {
-          _this55.logger.error("Failed to get TURN URIs", err);
-          if (err.httpStatus === 403) {
-            // We got a 403, so there's no point in looping forever.
-            _this55.logger.info("TURN access unavailable for this account: stopping credentials checks");
-            if (_this55.checkTurnServersIntervalID !== null) {
-              globalThis.clearInterval(_this55.checkTurnServersIntervalID);
-            }
-            _this55.checkTurnServersIntervalID = undefined;
-            _this55.emit(ClientEvent.TurnServersError, err, true); // fatal
-          } else {
-            // otherwise, if we failed for whatever reason, try again the next time we're called.
-            _this55.emit(ClientEvent.TurnServersError, err, false); // non-fatal
-          }
-        }
-      }
-      return credentialsGood;
-    })();
-  }
-
   /**
    * Set whether to allow a fallback ICE server should be used for negotiating a
    * WebRTC connection if the homeserver doesn't provide any servers. Defaults to
@@ -5854,14 +3565,14 @@ export class MatrixClient extends TypedEventEmitter {
     });
   }
   fetchClientWellKnown() {
-    var _this56 = this;
+    var _this31 = this;
     return _asyncToGenerator(function* () {
-      var _this56$getDomain;
+      var _this31$getDomain;
       // `getRawClientConfig` does not throw or reject on network errors, instead
       // it absorbs errors and returns `{}`.
-      _this56.clientWellKnownPromise = AutoDiscovery.getRawClientConfig((_this56$getDomain = _this56.getDomain()) !== null && _this56$getDomain !== void 0 ? _this56$getDomain : undefined);
-      _this56.clientWellKnown = yield _this56.clientWellKnownPromise;
-      _this56.emit(ClientEvent.ClientWellKnown, _this56.clientWellKnown);
+      _this31.clientWellKnownPromise = AutoDiscovery.getRawClientConfig((_this31$getDomain = _this31.getDomain()) !== null && _this31$getDomain !== void 0 ? _this31$getDomain : undefined);
+      _this31.clientWellKnown = yield _this31.clientWellKnownPromise;
+      _this31.emit(ClientEvent.ClientWellKnown, _this31.clientWellKnown);
     })();
   }
   getClientWellKnown() {
@@ -5883,11 +3594,11 @@ export class MatrixClient extends TypedEventEmitter {
   storeClientOptions() {
     // XXX: Intended private, used in code
     var primTypes = ["boolean", "string", "number"];
-    var serializableOpts = Object.entries(this.clientOpts).filter(_ref8 => {
-      var [key, value] = _ref8;
+    var serializableOpts = Object.entries(this.clientOpts).filter(_ref5 => {
+      var [key, value] = _ref5;
       return primTypes.includes(typeof value);
-    }).reduce((obj, _ref9) => {
-      var [key, value] = _ref9;
+    }).reduce((obj, _ref6) => {
+      var [key, value] = _ref6;
       obj[key] = value;
       return obj;
     }, {});
@@ -5907,16 +3618,16 @@ export class MatrixClient extends TypedEventEmitter {
   // TODO: on spec release, rename this to getMutualRooms
   // eslint-disable-next-line
   _unstable_getSharedRooms(userId) {
-    var _this57 = this;
+    var _this32 = this;
     return _asyncToGenerator(function* () {
       // Initial variant of the MSC
-      var sharedRoomsSupport = yield _this57.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_SHARED_ROOMS);
+      var sharedRoomsSupport = yield _this32.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_SHARED_ROOMS);
 
       // Newer variant that renamed shared rooms to mutual rooms
-      var mutualRoomsSupport = yield _this57.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_MUTUAL_ROOMS);
+      var mutualRoomsSupport = yield _this32.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_MUTUAL_ROOMS);
 
       // Latest variant that changed from path elements to query elements
-      var queryMutualRoomsSupport = yield _this57.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_QUERY_MUTUAL_ROOMS);
+      var queryMutualRoomsSupport = yield _this32.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_QUERY_MUTUAL_ROOMS);
       if (!sharedRoomsSupport && !mutualRoomsSupport && !queryMutualRoomsSupport) {
         throw Error("Server does not support the Mutual Rooms API");
       }
@@ -5944,7 +3655,7 @@ export class MatrixClient extends TypedEventEmitter {
         if (token != null && queryMutualRoomsSupport) {
           tokenQuery["batch_token"] = token;
         }
-        var res = yield _this57.http.authedRequest(Method.Get, path, _objectSpread(_objectSpread({}, query), tokenQuery), undefined, {
+        var res = yield _this32.http.authedRequest(Method.Get, path, _objectSpread(_objectSpread({}, query), tokenQuery), undefined, {
           prefix: ClientPrefix.Unstable
         });
         rooms.push(...res.joined);
@@ -5964,24 +3675,24 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns The server /versions response
    */
   getVersions() {
-    var _this58 = this;
+    var _this33 = this;
     return _asyncToGenerator(function* () {
-      if (_this58.serverVersionsPromise) {
-        return _this58.serverVersionsPromise;
+      if (_this33.serverVersionsPromise) {
+        return _this33.serverVersionsPromise;
       }
 
       // We send an authenticated request as of MSC4026
-      _this58.serverVersionsPromise = _this58.http.authedRequest(Method.Get, "/_matrix/client/versions", undefined, undefined, {
+      _this33.serverVersionsPromise = _this33.http.authedRequest(Method.Get, "/_matrix/client/versions", undefined, undefined, {
         prefix: ""
       }).catch(e => {
         // Need to unset this if it fails, otherwise we'll never retry
-        _this58.serverVersionsPromise = undefined;
+        _this33.serverVersionsPromise = undefined;
         // but rethrow the exception to anything that was waiting
         throw e;
       });
-      var serverVersions = yield _this58.serverVersionsPromise;
-      _this58.canSupport = yield buildFeatureSupportMap(serverVersions);
-      return _this58.serverVersionsPromise;
+      var serverVersions = yield _this33.serverVersionsPromise;
+      _this33.canSupport = yield buildFeatureSupportMap(serverVersions);
+      return _this33.serverVersionsPromise;
     })();
   }
 
@@ -5991,11 +3702,11 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Whether it is supported
    */
   isVersionSupported(version) {
-    var _this59 = this;
+    var _this34 = this;
     return _asyncToGenerator(function* () {
       var {
         versions
-      } = yield _this59.getVersions();
+      } = yield _this34.getVersions();
       return versions && versions.includes(version);
     })();
   }
@@ -6007,9 +3718,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns true if the feature is supported
    */
   doesServerSupportUnstableFeature(feature) {
-    var _this60 = this;
+    var _this35 = this;
     return _asyncToGenerator(function* () {
-      var response = yield _this60.getVersions();
+      var response = yield _this35.getVersions();
       if (!response) return false;
       var unstableFeatures = response["unstable_features"];
       return unstableFeatures && !!unstableFeatures[feature];
@@ -6024,9 +3735,9 @@ export class MatrixClient extends TypedEventEmitter {
    * for the preset.
    */
   doesServerForceEncryptionForPreset(presetName) {
-    var _this61 = this;
+    var _this36 = this;
     return _asyncToGenerator(function* () {
-      var response = yield _this61.getVersions();
+      var response = yield _this36.getVersions();
       if (!response) return false;
       var unstableFeatures = response["unstable_features"];
 
@@ -6036,9 +3747,9 @@ export class MatrixClient extends TypedEventEmitter {
     })();
   }
   doesServerSupportThread() {
-    var _this62 = this;
+    var _this37 = this;
     return _asyncToGenerator(function* () {
-      if (yield _this62.isVersionSupported("v1.4")) {
+      if (yield _this37.isVersionSupported("v1.4")) {
         return {
           threads: FeatureSupport.Stable,
           list: FeatureSupport.Stable,
@@ -6046,13 +3757,13 @@ export class MatrixClient extends TypedEventEmitter {
         };
       }
       try {
-        var [threadUnstable, threadStable, listUnstable, listStable, fwdPaginationUnstable, fwdPaginationStable] = yield Promise.all([_this62.doesServerSupportUnstableFeature("org.matrix.msc3440"), _this62.doesServerSupportUnstableFeature("org.matrix.msc3440.stable"), _this62.doesServerSupportUnstableFeature("org.matrix.msc3856"), _this62.doesServerSupportUnstableFeature("org.matrix.msc3856.stable"), _this62.doesServerSupportUnstableFeature("org.matrix.msc3715"), _this62.doesServerSupportUnstableFeature("org.matrix.msc3715.stable")]);
+        var [threadUnstable, threadStable, listUnstable, listStable, fwdPaginationUnstable, fwdPaginationStable] = yield Promise.all([_this37.doesServerSupportUnstableFeature("org.matrix.msc3440"), _this37.doesServerSupportUnstableFeature("org.matrix.msc3440.stable"), _this37.doesServerSupportUnstableFeature("org.matrix.msc3856"), _this37.doesServerSupportUnstableFeature("org.matrix.msc3856.stable"), _this37.doesServerSupportUnstableFeature("org.matrix.msc3715"), _this37.doesServerSupportUnstableFeature("org.matrix.msc3715.stable")]);
         return {
           threads: determineFeatureSupport(threadStable, threadUnstable),
           list: determineFeatureSupport(listStable, listUnstable),
           fwdPagination: determineFeatureSupport(fwdPaginationStable, fwdPaginationUnstable)
         };
-      } catch (_unused3) {
+      } catch (_unused) {
         return {
           threads: FeatureSupport.None,
           list: FeatureSupport.None,
@@ -6104,21 +3815,19 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns an object with `events` as `MatrixEvent[]` and optionally `nextBatch` if more relations are available.
    */
   relations(roomId, eventId, relationType, eventType) {
-    var _arguments8 = arguments,
-      _this63 = this;
+    var _arguments6 = arguments,
+      _this38 = this;
     return _asyncToGenerator(function* () {
       var _result$next_batch, _result$prev_batch;
-      var opts = _arguments8.length > 4 && _arguments8[4] !== undefined ? _arguments8[4] : {
+      var opts = _arguments6.length > 4 && _arguments6[4] !== undefined ? _arguments6[4] : {
         dir: Direction.Backward
       };
-      var fetchedEventType = eventType ? _this63.getEncryptedIfNeededEventType(roomId, eventType) : null;
-      var [eventResult, result] = yield Promise.all([_this63.fetchRoomEvent(roomId, eventId), _this63.fetchRelations(roomId, eventId, relationType, fetchedEventType, opts)]);
-      var mapper = _this63.getEventMapper();
+      var fetchedEventType = eventType ? _this38.getEncryptedIfNeededEventType(roomId, eventType) : null;
+      var [eventResult, result] = yield Promise.all([_this38.fetchRoomEvent(roomId, eventId), _this38.fetchRelations(roomId, eventId, relationType, fetchedEventType, opts)]);
+      var mapper = _this38.getEventMapper();
       var originalEvent = eventResult ? mapper(eventResult) : undefined;
       var events = result.chunk.map(mapper);
       if (fetchedEventType === EventType.RoomMessageEncrypted) {
-        var allEvents = originalEvent ? events.concat(originalEvent) : events;
-        yield Promise.all(allEvents.map(e => _this63.decryptEventIfNeeded(e)));
         if (eventType !== null) {
           events = events.filter(e => e.getType() === eventType);
         }
@@ -6135,18 +3844,6 @@ export class MatrixClient extends TypedEventEmitter {
     })();
   }
 
-  /**
-   * The app may wish to see if we have a key cached without
-   * triggering a user interaction.
-   *
-   * @deprecated Not supported for Rust Cryptography.
-   */
-  getCrossSigningCacheCallbacks() {
-    var _this$crypto4;
-    // XXX: Private member access
-    return (_this$crypto4 = this.crypto) === null || _this$crypto4 === void 0 ? void 0 : _this$crypto4.crossSigningInfo.getCacheCallbacks();
-  }
-
   /**
    * Generates a random string suitable for use as a client secret. <strong>This
    * method is experimental and may change.</strong>
@@ -6162,14 +3859,7 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns A decryption promise
    */
   decryptEventIfNeeded(event, options) {
-    if (event.shouldAttemptDecryption() && this.isCryptoEnabled()) {
-      event.attemptDecryption(this.cryptoBackend, options);
-    }
-    if (event.isBeingDecrypted()) {
-      return event.getDecryptionPromise();
-    } else {
-      return Promise.resolve();
-    }
+    return Promise.resolve();
   }
   termsUrlForService(serviceType, baseUrl) {
     switch (serviceType) {
@@ -6468,23 +4158,15 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise which resolves: On success, the empty object `{}`
    */
   logout() {
-    var _arguments9 = arguments,
-      _this64 = this;
+    var _arguments7 = arguments,
+      _this39 = this;
     return _asyncToGenerator(function* () {
-      var _this64$crypto;
-      var stopClient = _arguments9.length > 0 && _arguments9[0] !== undefined ? _arguments9[0] : false;
-      if ((_this64$crypto = _this64.crypto) !== null && _this64$crypto !== void 0 && (_this64$crypto = _this64$crypto.backupManager) !== null && _this64$crypto !== void 0 && _this64$crypto.getKeyBackupEnabled()) {
-        try {
-          while ((yield _this64.crypto.backupManager.backupPendingKeys(200)) > 0);
-        } catch (err) {
-          _this64.logger.error("Key backup request failed when logging out. Some keys may be missing from backup", err);
-        }
-      }
+      var stopClient = _arguments7.length > 0 && _arguments7[0] !== undefined ? _arguments7[0] : false;
       if (stopClient) {
-        _this64.stopClient();
-        _this64.http.abort();
+        _this39.stopClient();
+        _this39.http.abort();
       }
-      return _this64.http.authedRequest(Method.Post, "/logout");
+      return _this39.http.authedRequest(Method.Post, "/logout");
     })();
   }
 
@@ -6522,12 +4204,12 @@ export class MatrixClient extends TypedEventEmitter {
    * or UIA auth data.
    */
   requestLoginToken(auth) {
-    var _this65 = this;
+    var _this40 = this;
     return _asyncToGenerator(function* () {
       var body = {
         auth
       };
-      return _this65.http.authedRequest(Method.Post, "/login/get_token", undefined,
+      return _this40.http.authedRequest(Method.Post, "/login/get_token", undefined,
       // no query params
       body, {
         prefix: ClientPrefix.V1
@@ -6559,23 +4241,23 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   createRoom(options) {
-    var _this66 = this;
+    var _this41 = this;
     return _asyncToGenerator(function* () {
-      var _this66$identityServe;
+      var _this41$identityServe;
       // eslint-disable-line camelcase
       // some valid options include: room_alias_name, visibility, invite
 
       // inject the id_access_token if inviting 3rd party addresses
       var invitesNeedingToken = (options.invite_3pid || []).filter(i => !i.id_access_token);
-      if (invitesNeedingToken.length > 0 && (_this66$identityServe = _this66.identityServer) !== null && _this66$identityServe !== void 0 && _this66$identityServe.getAccessToken) {
-        var identityAccessToken = yield _this66.identityServer.getAccessToken();
+      if (invitesNeedingToken.length > 0 && (_this41$identityServe = _this41.identityServer) !== null && _this41$identityServe !== void 0 && _this41$identityServe.getAccessToken) {
+        var identityAccessToken = yield _this41.identityServer.getAccessToken();
         if (identityAccessToken) {
           for (var invite of invitesNeedingToken) {
             invite.id_access_token = identityAccessToken;
           }
         }
       }
-      return _this66.http.authedRequest(Method.Post, "/createRoom", undefined, options);
+      return _this41.http.authedRequest(Method.Post, "/createRoom", undefined, options);
     })();
   }
 
@@ -6759,7 +4441,7 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise which resolves: the empty object, `{}`.
    */
   setRoomReadMarkersHttpRequest(roomId, rmEventId, rrEventId, rpEventId) {
-    var _this67 = this;
+    var _this42 = this;
     return _asyncToGenerator(function* () {
       var path = utils.encodeUri("/rooms/$roomId/read_markers", {
         $roomId: roomId
@@ -6768,10 +4450,10 @@ export class MatrixClient extends TypedEventEmitter {
         [ReceiptType.FullyRead]: rmEventId,
         [ReceiptType.Read]: rrEventId
       };
-      if ((yield _this67.doesServerSupportUnstableFeature("org.matrix.msc2285.stable")) || (yield _this67.isVersionSupported("v1.4"))) {
+      if ((yield _this42.doesServerSupportUnstableFeature("org.matrix.msc2285.stable")) || (yield _this42.isVersionSupported("v1.4"))) {
         content[ReceiptType.ReadPrivate] = rpEventId;
       }
-      return _this67.http.authedRequest(Method.Post, path, undefined, content);
+      return _this42.http.authedRequest(Method.Post, path, undefined, content);
     })();
   }
 
@@ -6804,13 +4486,13 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   publicRooms() {
-    var _ref10 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     var {
         server,
         limit,
         since
-      } = _ref10,
-      options = _objectWithoutProperties(_ref10, _excluded);
+      } = _ref7,
+      options = _objectWithoutProperties(_ref7, _excluded);
     if (Object.keys(options).length === 0) {
       var queryParams = {
         server,
@@ -6928,11 +4610,11 @@ export class MatrixClient extends TypedEventEmitter {
    * @param options.limit - the maximum number of results to return. The server will apply a limit if unspecified.
    * @returns Promise which resolves: an array of results.
    */
-  searchUserDirectory(_ref11) {
+  searchUserDirectory(_ref8) {
     var {
       term,
       limit
-    } = _ref11;
+    } = _ref8;
     var body = {
       search_term: term
     };
@@ -7004,9 +4686,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns `true` if supported, otherwise `false`
    */
   doesServerSupportExtendedProfiles() {
-    var _this68 = this;
+    var _this43 = this;
     return _asyncToGenerator(function* () {
-      return _this68.doesServerSupportUnstableFeature(UNSTABLE_MSC4133_EXTENDED_PROFILES);
+      return _this43.doesServerSupportUnstableFeature(UNSTABLE_MSC4133_EXTENDED_PROFILES);
     })();
   }
 
@@ -7016,9 +4698,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns The prefix for use with `authedRequest`
    */
   getExtendedProfileRequestPrefix() {
-    var _this69 = this;
+    var _this44 = this;
     return _asyncToGenerator(function* () {
-      if (yield _this69.doesServerSupportUnstableFeature("uk.tcpip.msc4133.stable")) {
+      if (yield _this44.doesServerSupportUnstableFeature("uk.tcpip.msc4133.stable")) {
         return ClientPrefix.V3;
       }
       return "/_matrix/client/unstable/uk.tcpip.msc4133";
@@ -7036,15 +4718,15 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws A M_NOT_FOUND error if the profile could not be found.
    */
   getExtendedProfile(userId) {
-    var _this70 = this;
+    var _this45 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this70.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this45.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      return _this70.http.authedRequest(Method.Get, utils.encodeUri("/profile/$userId", {
+      return _this45.http.authedRequest(Method.Get, utils.encodeUri("/profile/$userId", {
         $userId: userId
       }), undefined, undefined, {
-        prefix: yield _this70.getExtendedProfileRequestPrefix()
+        prefix: yield _this45.getExtendedProfileRequestPrefix()
       });
     })();
   }
@@ -7061,16 +4743,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws A M_NOT_FOUND error if the key was not set OR the profile could not be found.
    */
   getExtendedProfileProperty(userId, key) {
-    var _this71 = this;
+    var _this46 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this71.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this46.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      var profile = yield _this71.http.authedRequest(Method.Get, utils.encodeUri("/profile/$userId/$key", {
+      var profile = yield _this46.http.authedRequest(Method.Get, utils.encodeUri("/profile/$userId/$key", {
         $userId: userId,
         $key: key
       }), undefined, undefined, {
-        prefix: yield _this71.getExtendedProfileRequestPrefix()
+        prefix: yield _this46.getExtendedProfileRequestPrefix()
       });
       return profile[key];
     })();
@@ -7086,19 +4768,19 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.
    */
   setExtendedProfileProperty(key, value) {
-    var _this72 = this;
+    var _this47 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this72.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this47.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      var userId = _this72.getUserId();
-      yield _this72.http.authedRequest(Method.Put, utils.encodeUri("/profile/$userId/$key", {
+      var userId = _this47.getUserId();
+      yield _this47.http.authedRequest(Method.Put, utils.encodeUri("/profile/$userId/$key", {
         $userId: userId,
         $key: key
       }), undefined, {
         [key]: value
       }, {
-        prefix: yield _this72.getExtendedProfileRequestPrefix()
+        prefix: yield _this47.getExtendedProfileRequestPrefix()
       });
     })();
   }
@@ -7112,17 +4794,17 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.
    */
   deleteExtendedProfileProperty(key) {
-    var _this73 = this;
+    var _this48 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this73.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this48.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      var userId = _this73.getUserId();
-      yield _this73.http.authedRequest(Method.Delete, utils.encodeUri("/profile/$userId/$key", {
+      var userId = _this48.getUserId();
+      yield _this48.http.authedRequest(Method.Delete, utils.encodeUri("/profile/$userId/$key", {
         $userId: userId,
         $key: key
       }), undefined, undefined, {
-        prefix: yield _this73.getExtendedProfileRequestPrefix()
+        prefix: yield _this48.getExtendedProfileRequestPrefix()
       });
     })();
   }
@@ -7138,16 +4820,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.
    */
   patchExtendedProfile(profile) {
-    var _this74 = this;
+    var _this49 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this74.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this49.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      var userId = _this74.getUserId();
-      return _this74.http.authedRequest(Method.Patch, utils.encodeUri("/profile/$userId", {
+      var userId = _this49.getUserId();
+      return _this49.http.authedRequest(Method.Patch, utils.encodeUri("/profile/$userId", {
         $userId: userId
       }), {}, profile, {
-        prefix: yield _this74.getExtendedProfileRequestPrefix()
+        prefix: yield _this49.getExtendedProfileRequestPrefix()
       });
     })();
   }
@@ -7162,16 +4844,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.
    */
   setExtendedProfile(profile) {
-    var _this75 = this;
+    var _this50 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this75.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this50.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      var userId = _this75.getUserId();
-      yield _this75.http.authedRequest(Method.Put, utils.encodeUri("/profile/$userId", {
+      var userId = _this50.getUserId();
+      yield _this50.http.authedRequest(Method.Put, utils.encodeUri("/profile/$userId", {
         $userId: userId
       }), {}, profile, {
-        prefix: yield _this75.getExtendedProfileRequestPrefix()
+        prefix: yield _this50.getExtendedProfileRequestPrefix()
       });
     })();
   }
@@ -7194,10 +4876,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   addThreePidOnly(data) {
-    var _this76 = this;
+    var _this51 = this;
     return _asyncToGenerator(function* () {
       var path = "/account/3pid/add";
-      return _this76.http.authedRequest(Method.Post, path, undefined, data);
+      return _this51.http.authedRequest(Method.Post, path, undefined, data);
     })();
   }
 
@@ -7213,10 +4895,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   bindThreePid(data) {
-    var _this77 = this;
+    var _this52 = this;
     return _asyncToGenerator(function* () {
       var path = "/account/3pid/bind";
-      return _this77.http.authedRequest(Method.Post, path, undefined, data);
+      return _this52.http.authedRequest(Method.Post, path, undefined, data);
     })();
   }
 
@@ -7234,15 +4916,15 @@ export class MatrixClient extends TypedEventEmitter {
   unbindThreePid(medium, address
   // eslint-disable-next-line camelcase
   ) {
-    var _this78 = this;
+    var _this53 = this;
     return _asyncToGenerator(function* () {
       var path = "/account/3pid/unbind";
       var data = {
         medium,
         address,
-        id_server: _this78.getIdentityServerUrl(true)
+        id_server: _this53.getIdentityServerUrl(true)
       };
-      return _this78.http.authedRequest(Method.Post, path, undefined, data);
+      return _this53.http.authedRequest(Method.Post, path, undefined, data);
     })();
   }
 
@@ -7364,13 +5046,13 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   getPushers() {
-    var _this79 = this;
+    var _this54 = this;
     return _asyncToGenerator(function* () {
-      var response = yield _this79.http.authedRequest(Method.Get, "/pushers");
+      var response = yield _this54.http.authedRequest(Method.Get, "/pushers");
 
       // Migration path for clients that connect to a homeserver that does not support
       // MSC3881 yet, see https://github.com/matrix-org/matrix-spec-proposals/blob/kerry/remote-push-toggle/proposals/3881-remote-push-notification-toggling.md#migration
-      if (!(yield _this79.doesServerSupportUnstableFeature("org.matrix.msc3881"))) {
+      if (!(yield _this54.doesServerSupportUnstableFeature("org.matrix.msc3881"))) {
         response.pushers = response.pushers.map(pusher => {
           if (!pusher.hasOwnProperty(PUSHER_ENABLED.name)) {
             pusher[PUSHER_ENABLED.name] = true;
@@ -7509,11 +5191,11 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise which resolves to the search response object.
    * @returns Rejects: with an error response.
    */
-  search(_ref12, abortSignal) {
+  search(_ref9, abortSignal) {
     var {
       body,
       next_batch: nextBatch
-    } = _ref12;
+    } = _ref9;
     var queryParams = {};
     if (nextBatch) {
       queryParams.next_batch = nextBatch;
@@ -7523,86 +5205,6 @@ export class MatrixClient extends TypedEventEmitter {
     });
   }
 
-  /**
-   * Upload keys
-   *
-   * @param content -  body of upload request
-   *
-   * @param opts - this method no longer takes any opts,
-   *  used to take opts.device_id but this was not removed from the spec as a redundant parameter
-   *
-   * @returns Promise which resolves: result object. Rejects: with
-   *     an error response ({@link MatrixError}).
-   */
-  uploadKeysRequest(content, opts) {
-    return this.http.authedRequest(Method.Post, "/keys/upload", undefined, content);
-  }
-  uploadKeySignatures(content) {
-    return this.http.authedRequest(Method.Post, "/keys/signatures/upload", undefined, content);
-  }
-
-  /**
-   * Download device keys
-   *
-   * @param userIds -  list of users to get keys for
-   *
-   * @param token - sync token to pass in the query request, to help
-   *   the HS give the most recent results
-   *
-   * @returns Promise which resolves: result object. Rejects: with
-   *     an error response ({@link MatrixError}).
-   */
-  downloadKeysForUsers(userIds) {
-    var {
-      token
-    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var content = {
-      device_keys: {}
-    };
-    if (token !== undefined) {
-      content.token = token;
-    }
-    userIds.forEach(u => {
-      content.device_keys[u] = [];
-    });
-    return this.http.authedRequest(Method.Post, "/keys/query", undefined, content);
-  }
-
-  /**
-   * Claim one-time keys
-   *
-   * @param devices -  a list of [userId, deviceId] pairs
-   *
-   * @param keyAlgorithm -  desired key type
-   *
-   * @param timeout - the time (in milliseconds) to wait for keys from remote
-   *     servers
-   *
-   * @returns Promise which resolves: result object. Rejects: with
-   *     an error response ({@link MatrixError}).
-   */
-  claimOneTimeKeys(devices) {
-    var keyAlgorithm = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "signed_curve25519";
-    var timeout = arguments.length > 2 ? arguments[2] : undefined;
-    var queries = {};
-    if (keyAlgorithm === undefined) {
-      keyAlgorithm = "signed_curve25519";
-    }
-    for (var [userId, _deviceId] of devices) {
-      var query = queries[userId] || {};
-      safeSet(queries, userId, query);
-      safeSet(query, _deviceId, keyAlgorithm);
-    }
-    var content = {
-      one_time_keys: queries
-    };
-    if (timeout) {
-      content.timeout = timeout;
-    }
-    var path = "/keys/claim";
-    return this.http.authedRequest(Method.Post, path, undefined, content);
-  }
-
   /**
    * Ask the server for a list of users who have changed their device lists
    * between a pair of sync tokens
@@ -7618,16 +5220,6 @@ export class MatrixClient extends TypedEventEmitter {
     };
     return this.http.authedRequest(Method.Get, "/keys/changes", qps);
   }
-  uploadDeviceSigningKeys(auth, keys) {
-    // API returns empty object
-    var data = Object.assign({}, keys);
-    if (auth) Object.assign(data, {
-      auth
-    });
-    return this.http.authedRequest(Method.Post, "/keys/device_signing/upload", undefined, data, {
-      prefix: ClientPrefix.Unstable
-    });
-  }
 
   /**
    * Register with an identity server using the OpenID token from the user's
@@ -7800,7 +5392,7 @@ export class MatrixClient extends TypedEventEmitter {
    * found MXIDs. Results where no user could be found will not be listed.
    */
   identityHashedLookup(addressPairs, identityAccessToken) {
-    var _this80 = this;
+    var _this55 = this;
     return _asyncToGenerator(function* () {
       var params = {
         // addresses: ["email@example.org", "10005550000"],
@@ -7809,7 +5401,7 @@ export class MatrixClient extends TypedEventEmitter {
       };
 
       // Get hash information first before trying to do a lookup
-      var hashes = yield _this80.getIdentityHashDetails(identityAccessToken);
+      var hashes = yield _this55.getIdentityHashDetails(identityAccessToken);
       if (!hashes || !hashes["lookup_pepper"] || !hashes["algorithms"]) {
         throw new Error("Unsupported identity server: bad response");
       }
@@ -7822,7 +5414,7 @@ export class MatrixClient extends TypedEventEmitter {
       // When picking an algorithm, we pick the hashed over no hashes
       if (hashes["algorithms"].includes("sha256")) {
         params["addresses"] = yield Promise.all(addressPairs.map(/*#__PURE__*/function () {
-          var _ref13 = _asyncToGenerator(function* (p) {
+          var _ref10 = _asyncToGenerator(function* (p) {
             var addr = p[0].toLowerCase(); // lowercase to get consistent hashes
             var med = p[1].toLowerCase();
             var hashBuffer = yield sha256("".concat(addr, " ").concat(med, " ").concat(params["pepper"]));
@@ -7833,8 +5425,8 @@ export class MatrixClient extends TypedEventEmitter {
             localMapping[hashed] = p[0];
             return hashed;
           });
-          return function (_x6) {
-            return _ref13.apply(this, arguments);
+          return function (_x4) {
+            return _ref10.apply(this, arguments);
           };
         }()));
         params["algorithm"] = "sha256";
@@ -7852,7 +5444,7 @@ export class MatrixClient extends TypedEventEmitter {
       } else {
         throw new Error("Unsupported identity server: unknown hash algorithm");
       }
-      var response = yield _this80.http.idServerRequest(Method.Post, "/lookup", params, IdentityPrefix.V2, identityAccessToken);
+      var response = yield _this55.http.idServerRequest(Method.Post, "/lookup", params, IdentityPrefix.V2, identityAccessToken);
       if (!(response !== null && response !== void 0 && response["mappings"])) return []; // no results
 
       var foundAddresses = [];
@@ -7886,12 +5478,12 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   lookupThreePid(medium, address, identityAccessToken) {
-    var _this81 = this;
+    var _this56 = this;
     return _asyncToGenerator(function* () {
       // Note: we're using the V2 API by calling this function, but our
       // function contract requires a V1 response. We therefore have to
       // convert it manually.
-      var response = yield _this81.identityHashedLookup([[address, medium]], identityAccessToken);
+      var response = yield _this56.identityHashedLookup([[address, medium]], identityAccessToken);
       var result = response.find(p => p.address === address);
       if (!result) {
         return {};
@@ -7923,16 +5515,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   bulkLookupThreePids(query, identityAccessToken) {
-    var _this82 = this;
+    var _this57 = this;
     return _asyncToGenerator(function* () {
       // Note: we're using the V2 API by calling this function, but our
       // function contract requires a V1 response. We therefore have to
       // convert it manually.
-      var response = yield _this82.identityHashedLookup(
+      var response = yield _this57.identityHashedLookup(
       // We have to reverse the query order to get [address, medium] pairs
       query.map(p => [p[1], p[0]]), identityAccessToken);
       var v1results = [];
-      var _loop2 = function* _loop2(mapping) {
+      var _loop = function* _loop(mapping) {
         var originalQuery = query.find(p => p[1] === mapping.address);
         if (!originalQuery) {
           throw new Error("Identity sever returned unexpected results");
@@ -7942,7 +5534,7 @@ export class MatrixClient extends TypedEventEmitter {
         mapping.address, mapping.mxid]);
       };
       for (var mapping of response) {
-        yield* _loop2(mapping);
+        yield* _loop(mapping);
       }
       return {
         threepids: v1results
@@ -8129,16 +5721,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise which resolves to the created space.
    */
   unstableCreateFileTree(name) {
-    var _this83 = this;
+    var _this58 = this;
     return _asyncToGenerator(function* () {
       var {
         room_id: roomId
-      } = yield _this83.createRoom({
+      } = yield _this58.createRoom({
         name: name,
         preset: Preset.PrivateChat,
         power_level_content_override: _objectSpread(_objectSpread({}, DEFAULT_TREE_POWER_LEVELS_TEMPLATE), {}, {
           users: {
-            [_this83.getUserId()]: 100
+            [_this58.getUserId()]: 100
           }
         }),
         creation_content: {
@@ -8150,15 +5742,9 @@ export class MatrixClient extends TypedEventEmitter {
           content: {
             [UNSTABLE_MSC3088_ENABLED.name]: true
           }
-        }, {
-          type: EventType.RoomEncryption,
-          state_key: "",
-          content: {
-            algorithm: olmlib.MEGOLM_ALGORITHM
-          }
         }]
       });
-      return new MSC3089TreeSpace(_this83, roomId);
+      return new MSC3089TreeSpace(_this58, roomId);
     })();
   }
 
@@ -8235,7 +5821,7 @@ export class MatrixClient extends TypedEventEmitter {
    * @param via - The list of servers which know about the room if only an ID was provided.
    */
   getRoomSummary(roomIdOrAlias, via) {
-    var _this84 = this;
+    var _this59 = this;
     return _asyncToGenerator(function* () {
       var paramOpts = {
         prefix: "/_matrix/client/unstable/im.nheko.summary"
@@ -8244,7 +5830,7 @@ export class MatrixClient extends TypedEventEmitter {
         var path = utils.encodeUri("/summary/$roomid", {
           $roomid: roomIdOrAlias
         });
-        return yield _this84.http.authedRequest(Method.Get, path, {
+        return yield _this59.http.authedRequest(Method.Get, path, {
           via
         }, undefined, paramOpts);
       } catch (e) {
@@ -8252,7 +5838,7 @@ export class MatrixClient extends TypedEventEmitter {
           var _path = utils.encodeUri("/rooms/$roomid/summary", {
             $roomid: roomIdOrAlias
           });
-          return yield _this84.http.authedRequest(Method.Get, _path, {
+          return yield _this59.http.authedRequest(Method.Get, _path, {
             via
           }, undefined, paramOpts);
         } else {
@@ -8304,9 +5890,9 @@ export class MatrixClient extends TypedEventEmitter {
    * Fetches information about the user for the configured access token.
    */
   whoami() {
-    var _this85 = this;
+    var _this60 = this;
     return _asyncToGenerator(function* () {
-      return _this85.http.authedRequest(Method.Get, "/account/whoami");
+      return _this60.http.authedRequest(Method.Get, "/account/whoami");
     })();
   }
 
@@ -8317,7 +5903,7 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: when the request fails (module:http-api.MatrixError)
    */
   timestampToEvent(roomId, timestamp, dir) {
-    var _this86 = this;
+    var _this61 = this;
     return _asyncToGenerator(function* () {
       var path = utils.encodeUri("/rooms/$roomId/timestamp_to_event", {
         $roomId: roomId
@@ -8327,7 +5913,7 @@ export class MatrixClient extends TypedEventEmitter {
         dir: dir
       };
       try {
-        return yield _this86.http.authedRequest(Method.Get, path, queryParams, undefined, {
+        return yield _this61.http.authedRequest(Method.Get, path, queryParams, undefined, {
           prefix: ClientPrefix.V1
         });
       } catch (err) {
@@ -8343,7 +5929,7 @@ export class MatrixClient extends TypedEventEmitter {
         // both indicate that this endpoint+verb combination is
         // not supported.
         err.httpStatus === 404 || err.httpStatus === 405)) {
-          return yield _this86.http.authedRequest(Method.Get, path, queryParams, undefined, {
+          return yield _this61.http.authedRequest(Method.Get, path, queryParams, undefined, {
             prefix: "/_matrix/client/unstable/org.matrix.msc3030"
           });
         }
@@ -8359,9 +5945,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @experimental - part of MSC2965
    */
   getAuthIssuer() {
-    var _this87 = this;
+    var _this62 = this;
     return _asyncToGenerator(function* () {
-      return _this87.http.request(Method.Get, "/auth_issuer", undefined, undefined, {
+      return _this62.http.request(Method.Get, "/auth_issuer", undefined, undefined, {
         prefix: ClientPrefix.Unstable + "/org.matrix.msc2965"
       });
     })();
@@ -8369,88 +5955,12 @@ export class MatrixClient extends TypedEventEmitter {
 }
 _defineProperty(MatrixClient, "RESTORE_BACKUP_ERROR_BAD_KEY", "RESTORE_BACKUP_ERROR_BAD_KEY");
 function getUnstableDelayQueryOpts(delayOpts) {
-  return Object.fromEntries(Object.entries(delayOpts).map(_ref14 => {
-    var [k, v] = _ref14;
+  return Object.fromEntries(Object.entries(delayOpts).map(_ref11 => {
+    var [k, v] = _ref11;
     return ["".concat(UNSTABLE_MSC4140_DELAYED_EVENTS, ".").concat(k), v];
   }));
 }
 
-/**
- * recalculates an accurate notifications count on event decryption.
- * Servers do not have enough knowledge about encrypted events to calculate an
- * accurate notification_count
- */
-export function fixNotificationCountOnDecryption(cli, event) {
-  var _actions$tweaks;
-  var ourUserId = cli.getUserId();
-  var eventId = event.getId();
-  var room = cli.getRoom(event.getRoomId());
-  if (!room || !ourUserId || !eventId) return;
-
-  // Due to threads, we can get relation events (eg. edits & reactions) that never get
-  // added to a timeline and so cannot be found in their own room (their edit / reaction
-  // still applies to the event it needs to, so it doesn't matter too much). However, if
-  // we try to process notification about this event, we'll get very confused because we
-  // won't be able to find the event in the room, so will assume it must be unread, even
-  // if it's actually read. We therefore skip anything that isn't in the room. This isn't
-  // *great*, so if we can fix the homeless events (eg. with MSC4023) then we should probably
-  // remove this workaround.
-  if (!room.findEventById(eventId)) {
-    logger.info("Decrypted event ".concat(event.getId(), " is not in room ").concat(room.roomId, ": ignoring"));
-    return;
-  }
-  var isThreadEvent = !!event.threadRootId && !event.isThreadRoot;
-  var hasReadEvent;
-  if (isThreadEvent) {
-    var thread = room.getThread(event.threadRootId);
-    hasReadEvent = thread ? thread.hasUserReadEvent(ourUserId, eventId) :
-    // If the thread object does not exist in the room yet, we don't
-    // want to calculate notification for this event yet. We have not
-    // restored the read receipts yet and can't accurately calculate
-    // notifications at this stage.
-    //
-    // This issue can likely go away when MSC3874 is implemented
-    true;
-  } else {
-    hasReadEvent = room.hasUserReadEvent(ourUserId, eventId);
-  }
-  if (hasReadEvent) {
-    // If the event has been read, ignore it.
-    return;
-  }
-  var actions = cli.getPushActionsForEvent(event, true);
-
-  // Ensure the unread counts are kept up to date if the event is encrypted
-  // We also want to make sure that the notification count goes up if we already
-  // have encrypted events to avoid other code from resetting 'highlight' to zero.
-  var newHighlight = !!(actions !== null && actions !== void 0 && (_actions$tweaks = actions.tweaks) !== null && _actions$tweaks !== void 0 && _actions$tweaks.highlight);
-  if (newHighlight) {
-    // TODO: Handle mentions received while the client is offline
-    // See also https://github.com/vector-im/element-web/issues/9069
-    var newCount = room.getUnreadCountForEventContext(NotificationCountType.Highlight, event) + 1;
-    if (isThreadEvent) {
-      room.setThreadUnreadNotificationCount(event.threadRootId, NotificationCountType.Highlight, newCount);
-    } else {
-      room.setUnreadNotificationCount(NotificationCountType.Highlight, newCount);
-    }
-  }
-
-  // `notify` is used in practice for incrementing the total count
-  var newNotify = !!(actions !== null && actions !== void 0 && actions.notify);
-
-  // The room total count is NEVER incremented by the server for encrypted rooms. We basically ignore
-  // the server here as it's always going to tell us to increment for encrypted events.
-  if (newNotify) {
-    // Total count is used to typically increment a room notification counter, but not loudly highlight it.
-    var _newCount = room.getUnreadCountForEventContext(NotificationCountType.Total, event) + 1;
-    if (isThreadEvent) {
-      room.setThreadUnreadNotificationCount(event.threadRootId, NotificationCountType.Total, _newCount);
-    } else {
-      room.setUnreadNotificationCount(NotificationCountType.Total, _newCount);
-    }
-  }
-}
-
 /**
  * Given an event, figure out the thread ID we should use for it in a receipt.
  *