matrix-js-sdk 41.8.0 → 41.9.0

package/lib/rust-crypto/rust-crypto.js

@@ -1,8 +1,5 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /*
 Copyright 2022-2023 The Matrix.org Foundation C.I.C.
 
@@ -49,9 +46,9 @@ import { DehydratedDeviceManager } from "./DehydratedDeviceManager.js";
 import { VerificationMethod } from "../types.js";
 import { keyFromAuthData } from "../common-crypto/key-passphrase.js";
 import { getHttpUriForMxc } from "../content-repo.js";
-var ALL_VERIFICATION_METHODS = [VerificationMethod.Sas, VerificationMethod.ScanQrCode, VerificationMethod.ShowQrCode, VerificationMethod.Reciprocate];
+const ALL_VERIFICATION_METHODS = [VerificationMethod.Sas, VerificationMethod.ScanQrCode, VerificationMethod.ShowQrCode, VerificationMethod.Reciprocate];
 /** The maximum time, in milliseconds, since we accepted an invite, that we should accept a key bundle. */
-export var MAX_INVITE_ACCEPTANCE_MS_FOR_KEY_BUNDLE = 24 * 60 * 60 * 1000; // 24 hours
+export const MAX_INVITE_ACCEPTANCE_MS_FOR_KEY_BUNDLE = 24 * 60 * 60 * 1000; // 24 hours
 
 /**
  * An implementation of {@link CryptoBackend} using the Rust matrix-sdk-crypto.
@@ -70,16 +67,9 @@ export class RustCrypto extends TypedEventEmitter {
   userId, /** The local user's Device ID. */
   _deviceId, /** Interface to server-side secret storage */
   secretStorage, /** Crypto callbacks provided by the application */
-  cryptoCallbacks) {
-    var enableEncryptedStateEvents = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : false;
+  cryptoCallbacks, /** Enable support for encrypted state events under MSC4362. */
+  enableEncryptedStateEvents = false) {
     super();
-    this.logger = logger;
-    this.olmMachine = olmMachine;
-    this.http = http;
-    this.userId = userId;
-    this.secretStorage = secretStorage;
-    this.cryptoCallbacks = cryptoCallbacks;
-    this.enableEncryptedStateEvents = enableEncryptedStateEvents;
     /**
      * The number of iterations to use when deriving a recovery key from a passphrase.
      */
@@ -109,6 +99,13 @@ export class RustCrypto extends TypedEventEmitter {
      * The verification methods we offer to the other side during an interactive verification.
      */
     _defineProperty(this, "_supportedVerificationMethods", ALL_VERIFICATION_METHODS);
+    this.logger = logger;
+    this.olmMachine = olmMachine;
+    this.http = http;
+    this.userId = userId;
+    this.secretStorage = secretStorage;
+    this.cryptoCallbacks = cryptoCallbacks;
+    this.enableEncryptedStateEvents = enableEncryptedStateEvents;
     this.outgoingRequestProcessor = new OutgoingRequestProcessor(logger, olmMachine, http);
     this.outgoingRequestsManager = new OutgoingRequestsManager(this.logger, olmMachine, this.outgoingRequestProcessor);
     this.keyClaimManager = new KeyClaimManager(olmMachine, this.outgoingRequestProcessor);
@@ -171,133 +168,115 @@ export class RustCrypto extends TypedEventEmitter {
     // can then be deleted.
     this.olmMachine.close();
   }
-  encryptEvent(event, _room) {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      var roomId = event.getRoomId();
-      var encryptor = _this.roomEncryptors[roomId];
-      if (!encryptor) {
-        throw new Error("Cannot encrypt event in unconfigured room ".concat(roomId));
-      }
-      yield encryptor.encryptEvent(event, _this.globalBlacklistUnverifiedDevices, _this.deviceIsolationMode);
-    })();
-  }
-  decryptEvent(event) {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      var roomId = event.getRoomId();
-      if (!roomId) {
-        // presumably, a to-device message. These are normally decrypted in preprocessToDeviceMessages
-        // so the fact it has come back here suggests that decryption failed.
-        //
-        // once we drop support for the libolm crypto implementation, we can stop passing to-device messages
-        // through decryptEvent and hence get rid of this case.
-        throw new Error("to-device event was not decrypted in preprocessToDeviceMessages");
-      }
-      return yield _this2.eventDecryptor.attemptEventDecryption(event, _this2.deviceIsolationMode);
-    })();
+  async encryptEvent(event, _room) {
+    const roomId = event.getRoomId();
+    const encryptor = this.roomEncryptors[roomId];
+    if (!encryptor) {
+      throw new Error(`Cannot encrypt event in unconfigured room ${roomId}`);
+    }
+    await encryptor.encryptEvent(event, this.globalBlacklistUnverifiedDevices, this.deviceIsolationMode);
+  }
+  async decryptEvent(event) {
+    const roomId = event.getRoomId();
+    if (!roomId) {
+      // presumably, a to-device message. These are normally decrypted in preprocessToDeviceMessages
+      // so the fact it has come back here suggests that decryption failed.
+      //
+      // once we drop support for the libolm crypto implementation, we can stop passing to-device messages
+      // through decryptEvent and hence get rid of this case.
+      throw new Error("to-device event was not decrypted in preprocessToDeviceMessages");
+    }
+    return await this.eventDecryptor.attemptEventDecryption(event, this.deviceIsolationMode);
   }
 
   /**
    * Implementation of {@link CryptoBackend#getBackupDecryptor}.
    */
-  getBackupDecryptor(backupInfo, privKey) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      if (!(privKey instanceof Uint8Array)) {
-        throw new Error("getBackupDecryptor: expects Uint8Array");
-      }
-      if (backupInfo.algorithm != "m.megolm_backup.v1.curve25519-aes-sha2") {
-        throw new Error("getBackupDecryptor: Unsupported algorithm ".concat(backupInfo.algorithm));
-      }
-      var backupDecryptionKey = RustSdkCryptoJs.BackupDecryptionKey.fromBase64(encodeBase64(privKey));
-      if (!decryptionKeyMatchesKeyBackupInfo(backupDecryptionKey, backupInfo)) {
-        throw new Error("getBackupDecryptor: key backup on server does not match the decryption key");
-      }
-      return _this3.backupManager.createBackupDecryptor(backupDecryptionKey);
-    })();
+  async getBackupDecryptor(backupInfo, privKey) {
+    if (!(privKey instanceof Uint8Array)) {
+      throw new Error(`getBackupDecryptor: expects Uint8Array`);
+    }
+    if (backupInfo.algorithm != "m.megolm_backup.v1.curve25519-aes-sha2") {
+      throw new Error(`getBackupDecryptor: Unsupported algorithm ${backupInfo.algorithm}`);
+    }
+    const backupDecryptionKey = RustSdkCryptoJs.BackupDecryptionKey.fromBase64(encodeBase64(privKey));
+    if (!decryptionKeyMatchesKeyBackupInfo(backupDecryptionKey, backupInfo)) {
+      throw new Error(`getBackupDecryptor: key backup on server does not match the decryption key`);
+    }
+    return this.backupManager.createBackupDecryptor(backupDecryptionKey);
   }
 
   /**
    * Implementation of {@link CryptoBackend#importBackedUpRoomKeys}.
    */
-  importBackedUpRoomKeys(keys, backupVersion, opts) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this4.backupManager.importBackedUpRoomKeys(keys, backupVersion, opts);
-    })();
+  async importBackedUpRoomKeys(keys, backupVersion, opts) {
+    return await this.backupManager.importBackedUpRoomKeys(keys, backupVersion, opts);
   }
 
   /**
    * Implementation of {@link CryptoBackend.maybeAcceptKeyBundle}.
    */
-  maybeAcceptKeyBundle(roomId, inviter) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      // TODO: retry this if it gets interrupted or it fails. (https://github.com/matrix-org/matrix-rust-sdk/issues/5112)
-      // TODO: do this in the background.
+  async maybeAcceptKeyBundle(roomId, inviter) {
+    // TODO: retry this if it gets interrupted or it fails. (https://github.com/matrix-org/matrix-rust-sdk/issues/5112)
+    // TODO: do this in the background.
 
-      var logger = new LogSpan(_this5.logger, "maybeAcceptKeyBundle(".concat(roomId, ", ").concat(inviter, ")"));
+    const logger = new LogSpan(this.logger, `maybeAcceptKeyBundle(${roomId}, ${inviter})`);
 
-      // Make sure we have an up-to-date idea of the inviter's cross-signing keys, so that we can check if the
-      // device that sent us the bundle data was correctly cross-signed.
-      //
-      // TODO: it would be nice to skip this step if we have an up-to-date copy of the inviter's cross-signing keys,
-      //   but we don't have an easy way to check that. Possibly the rust side could trigger a key request and then
-      //   block until it happens.
-      logger.info("Checking inviter cross-signing keys");
-      var request = _this5.olmMachine.queryKeysForUsers([new RustSdkCryptoJs.UserId(inviter)]);
-      yield _this5.outgoingRequestProcessor.makeOutgoingRequest(request);
-      var bundleData = yield _this5.olmMachine.getReceivedRoomKeyBundleData(new RustSdkCryptoJs.RoomId(roomId), new RustSdkCryptoJs.UserId(inviter));
-      if (!bundleData) {
-        logger.info("No key bundle found for user");
-        return false;
-      }
-      logger.info("Fetching key bundle ".concat(bundleData.url));
-      var url = getHttpUriForMxc(_this5.http.opts.baseUrl, bundleData.url, undefined, undefined, undefined, /* allowDirectLinks */false, /* allowRedirects */true, /* useAuthentication */true);
-      var encryptedBundle;
-      try {
-        var bundleUrl = new URL(url);
-        var encryptedBundleBlob = yield _this5.http.authedRequest(Method.Get, bundleUrl.pathname + bundleUrl.search, {}, undefined, {
-          rawResponseBody: true,
-          prefix: ""
-        });
-        logger.info("Received blob of length ".concat(encryptedBundleBlob.size));
-        encryptedBundle = new Uint8Array(yield encryptedBundleBlob.arrayBuffer());
-      } catch (err) {
-        logger.warn("Error downloading encrypted bundle from ".concat(url, ":"), err);
-        throw err;
-      }
-      try {
-        yield _this5.olmMachine.receiveRoomKeyBundle(bundleData, encryptedBundle);
-      } catch (err) {
-        logger.warn("Error receiving encrypted bundle:", err);
-        throw err;
-      } finally {
-        // Even if we were unable to import the bundle, we still clear the flag that indicates that we
-        // are waiting for the bundle to be received. The only reason this can happen is that the bundle was
-        // malformed somehow, so we don't want to keep retrying it.
-        yield _this5.olmMachine.clearRoomPendingKeyBundle(new RustSdkCryptoJs.RoomId(roomId));
-      }
-      return true;
-    })();
+    // Make sure we have an up-to-date idea of the inviter's cross-signing keys, so that we can check if the
+    // device that sent us the bundle data was correctly cross-signed.
+    //
+    // TODO: it would be nice to skip this step if we have an up-to-date copy of the inviter's cross-signing keys,
+    //   but we don't have an easy way to check that. Possibly the rust side could trigger a key request and then
+    //   block until it happens.
+    logger.info(`Checking inviter cross-signing keys`);
+    const request = this.olmMachine.queryKeysForUsers([new RustSdkCryptoJs.UserId(inviter)]);
+    await this.outgoingRequestProcessor.makeOutgoingRequest(request);
+    const bundleData = await this.olmMachine.getReceivedRoomKeyBundleData(new RustSdkCryptoJs.RoomId(roomId), new RustSdkCryptoJs.UserId(inviter));
+    if (!bundleData) {
+      logger.info("No key bundle found for user");
+      return false;
+    }
+    logger.info(`Fetching key bundle ${bundleData.url}`);
+    const url = getHttpUriForMxc(this.http.opts.baseUrl, bundleData.url, undefined, undefined, undefined, /* allowDirectLinks */false, /* allowRedirects */true, /* useAuthentication */true);
+    let encryptedBundle;
+    try {
+      const bundleUrl = new URL(url);
+      const encryptedBundleBlob = await this.http.authedRequest(Method.Get, bundleUrl.pathname + bundleUrl.search, {}, undefined, {
+        rawResponseBody: true,
+        prefix: ""
+      });
+      logger.info(`Received blob of length ${encryptedBundleBlob.size}`);
+      encryptedBundle = new Uint8Array(await encryptedBundleBlob.arrayBuffer());
+    } catch (err) {
+      logger.warn(`Error downloading encrypted bundle from ${url}:`, err);
+      throw err;
+    }
+    try {
+      await this.olmMachine.receiveRoomKeyBundle(bundleData, encryptedBundle);
+    } catch (err) {
+      logger.warn(`Error receiving encrypted bundle:`, err);
+      throw err;
+    } finally {
+      // Even if we were unable to import the bundle, we still clear the flag that indicates that we
+      // are waiting for the bundle to be received. The only reason this can happen is that the bundle was
+      // malformed somehow, so we don't want to keep retrying it.
+      await this.olmMachine.clearRoomPendingKeyBundle(new RustSdkCryptoJs.RoomId(roomId));
+    }
+    return true;
   }
 
   /**
    * Implementation of {@link CryptoBackend.markRoomAsPendingKeyBundle}.
    */
-  markRoomAsPendingKeyBundle(roomId, inviter) {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      yield _this6.olmMachine.storeRoomPendingKeyBundle(new RustSdkCryptoJs.RoomId(roomId), new RustSdkCryptoJs.UserId(inviter));
-    })();
+  async markRoomAsPendingKeyBundle(roomId, inviter) {
+    await this.olmMachine.storeRoomPendingKeyBundle(new RustSdkCryptoJs.RoomId(roomId), new RustSdkCryptoJs.UserId(inviter));
   }
   /**
    * Implementation of {@link CryptoApi#getVersion}.
    */
   getVersion() {
-    var versions = RustSdkCryptoJs.getVersions();
-    return "Rust SDK ".concat(versions.matrix_sdk_crypto, " (").concat(versions.git_sha, "), Vodozemac ").concat(versions.vodozemac);
+    const versions = RustSdkCryptoJs.getVersions();
+    return `Rust SDK ${versions.matrix_sdk_crypto} (${versions.git_sha}), Vodozemac ${versions.vodozemac}`;
   }
 
   /**
@@ -310,122 +289,93 @@ export class RustCrypto extends TypedEventEmitter {
   /**
    * Implementation of {@link CryptoApi#isEncryptionEnabledInRoom}.
    */
-  isEncryptionEnabledInRoom(roomId) {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      var roomSettings = yield _this7.olmMachine.getRoomSettings(new RustSdkCryptoJs.RoomId(roomId));
-      return Boolean(roomSettings === null || roomSettings === void 0 ? void 0 : roomSettings.algorithm);
-    })();
+  async isEncryptionEnabledInRoom(roomId) {
+    const roomSettings = await this.olmMachine.getRoomSettings(new RustSdkCryptoJs.RoomId(roomId));
+    return Boolean(roomSettings?.algorithm);
   }
 
   /**
    * Implementation of {@link CryptoApi#isStateEncryptionEnabledInRoom}.
    */
-  isStateEncryptionEnabledInRoom(roomId) {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      var roomSettings = yield _this8.olmMachine.getRoomSettings(new RustSdkCryptoJs.RoomId(roomId));
-      return Boolean(roomSettings === null || roomSettings === void 0 ? void 0 : roomSettings.encryptStateEvents);
-    })();
+  async isStateEncryptionEnabledInRoom(roomId) {
+    const roomSettings = await this.olmMachine.getRoomSettings(new RustSdkCryptoJs.RoomId(roomId));
+    return Boolean(roomSettings?.encryptStateEvents);
   }
 
   /**
    * Implementation of {@link CryptoApi#getOwnDeviceKeys}.
    */
-  getOwnDeviceKeys() {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      var keys = _this9.olmMachine.identityKeys;
-      return {
-        ed25519: keys.ed25519.toBase64(),
-        curve25519: keys.curve25519.toBase64()
-      };
-    })();
+  async getOwnDeviceKeys() {
+    const keys = this.olmMachine.identityKeys;
+    return {
+      ed25519: keys.ed25519.toBase64(),
+      curve25519: keys.curve25519.toBase64()
+    };
   }
   prepareToEncrypt(room) {
-    var encryptor = this.roomEncryptors[room.roomId];
+    const encryptor = this.roomEncryptors[room.roomId];
     if (encryptor) {
       encryptor.prepareForEncryption(this.globalBlacklistUnverifiedDevices, this.deviceIsolationMode);
     }
   }
   forceDiscardSession(roomId) {
-    var _this$roomEncryptors$;
-    return (_this$roomEncryptors$ = this.roomEncryptors[roomId]) === null || _this$roomEncryptors$ === void 0 ? void 0 : _this$roomEncryptors$.forceDiscardSession();
+    return this.roomEncryptors[roomId]?.forceDiscardSession();
   }
-  exportRoomKeys() {
-    var _this0 = this;
-    return _asyncToGenerator(function* () {
-      var raw = yield _this0.olmMachine.exportRoomKeys(() => true);
-      return JSON.parse(raw);
-    })();
+  async exportRoomKeys() {
+    const raw = await this.olmMachine.exportRoomKeys(() => true);
+    return JSON.parse(raw);
   }
-  exportRoomKeysAsJson() {
-    var _this1 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this1.olmMachine.exportRoomKeys(() => true);
-    })();
+  async exportRoomKeysAsJson() {
+    return await this.olmMachine.exportRoomKeys(() => true);
   }
-  importRoomKeys(keys, opts) {
-    var _this10 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this10.backupManager.importRoomKeys(keys, opts);
-    })();
+  async importRoomKeys(keys, opts) {
+    return await this.backupManager.importRoomKeys(keys, opts);
   }
-  importRoomKeysAsJson(keys, opts) {
-    var _this11 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this11.backupManager.importRoomKeysAsJson(keys, opts);
-    })();
+  async importRoomKeysAsJson(keys, opts) {
+    return await this.backupManager.importRoomKeysAsJson(keys, opts);
   }
 
   /**
    * Implementation of {@link CryptoApi.userHasCrossSigningKeys}.
    */
-  userHasCrossSigningKeys() {
-    var _arguments = arguments,
-      _this12 = this;
-    return _asyncToGenerator(function* () {
-      var userId = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : _this12.userId;
-      var downloadUncached = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : false;
-      // TODO: could probably do with a more efficient way of doing this than returning the whole set and searching
-      var rustTrackedUsers = yield _this12.olmMachine.trackedUsers();
-      var rustTrackedUser;
-      for (var u of rustTrackedUsers) {
-        if (userId === u.toString()) {
-          rustTrackedUser = u;
-          break;
-        }
+  async userHasCrossSigningKeys(userId = this.userId, downloadUncached = false) {
+    // TODO: could probably do with a more efficient way of doing this than returning the whole set and searching
+    const rustTrackedUsers = await this.olmMachine.trackedUsers();
+    let rustTrackedUser;
+    for (const u of rustTrackedUsers) {
+      if (userId === u.toString()) {
+        rustTrackedUser = u;
+        break;
       }
-      if (rustTrackedUser !== undefined) {
-        if (userId === _this12.userId) {
-          /* make sure we have an *up-to-date* idea of the user's cross-signing keys. This is important, because if we
-           * return "false" here, we will end up generating new cross-signing keys and replacing the existing ones.
-           */
-          var request = _this12.olmMachine.queryKeysForUsers(
-          // clone as rust layer will take ownership and it's reused later
-          [rustTrackedUser.clone()]);
-          yield _this12.outgoingRequestProcessor.makeOutgoingRequest(request);
-        }
-        var userIdentity = yield _this12.olmMachine.getIdentity(rustTrackedUser);
-        userIdentity === null || userIdentity === void 0 || userIdentity.free();
-        return userIdentity !== undefined;
-      } else if (downloadUncached) {
-        var _keyResult$master_key;
-        // Download the cross signing keys and check if the master key is available
-        var keyResult = yield _this12.downloadDeviceList(new Set([userId]));
-        var keys = (_keyResult$master_key = keyResult.master_keys) === null || _keyResult$master_key === void 0 ? void 0 : _keyResult$master_key[userId];
-
-        // No master key
-        if (!keys) return false;
-
-        // `keys` is an object with { [`ed25519:${pubKey}`]: pubKey }
-        // We assume only a single key, and we want the bare form without type
-        // prefix, so we select the values.
-        return Boolean(Object.values(keys.keys)[0]);
-      } else {
-        return false;
-      }
-    })();
+    }
+    if (rustTrackedUser !== undefined) {
+      if (userId === this.userId) {
+        /* make sure we have an *up-to-date* idea of the user's cross-signing keys. This is important, because if we
+         * return "false" here, we will end up generating new cross-signing keys and replacing the existing ones.
+         */
+        const request = this.olmMachine.queryKeysForUsers(
+        // clone as rust layer will take ownership and it's reused later
+        [rustTrackedUser.clone()]);
+        await this.outgoingRequestProcessor.makeOutgoingRequest(request);
+      }
+      const userIdentity = await this.olmMachine.getIdentity(rustTrackedUser);
+      userIdentity?.free();
+      return userIdentity !== undefined;
+    } else if (downloadUncached) {
+      // Download the cross signing keys and check if the master key is available
+      const keyResult = await this.downloadDeviceList(new Set([userId]));
+      const keys = keyResult.master_keys?.[userId];
+
+      // No master key
+      if (!keys) return false;
+
+      // `keys` is an object with { [`ed25519:${pubKey}`]: pubKey }
+      // We assume only a single key, and we want the bare form without type
+      // prefix, so we select the values.
+      return Boolean(Object.values(keys.keys)[0]);
+    } else {
+      return false;
+    }
   }
 
   /**
@@ -437,98 +387,82 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @returns A map `{@link DeviceMap}`.
    */
-  getUserDeviceInfo(userIds) {
-    var _arguments2 = arguments,
-      _this13 = this;
-    return _asyncToGenerator(function* () {
-      var downloadUncached = _arguments2.length > 1 && _arguments2[1] !== undefined ? _arguments2[1] : false;
-      var deviceMapByUserId = new Map();
-      var rustTrackedUsers = yield _this13.getOlmMachineOrThrow().trackedUsers();
-
-      // Convert RustSdkCryptoJs.UserId to a `Set<string>`
-      var trackedUsers = new Set();
-      rustTrackedUsers.forEach(rustUserId => trackedUsers.add(rustUserId.toString()));
-
-      // Keep untracked user to download their keys after
-      var untrackedUsers = new Set();
-      for (var _userId of userIds) {
-        // if this is a tracked user, we can just fetch the device list from the rust-sdk
-        // (NB: this is probably ok even if we race with a leave event such that we stop tracking the user's
-        // devices: the rust-sdk will return the last-known device list, which will be good enough.)
-        if (trackedUsers.has(_userId)) {
-          deviceMapByUserId.set(_userId, yield _this13.getUserDevices(_userId));
-        } else {
-          untrackedUsers.add(_userId);
-        }
+  async getUserDeviceInfo(userIds, downloadUncached = false) {
+    const deviceMapByUserId = new Map();
+    const rustTrackedUsers = await this.getOlmMachineOrThrow().trackedUsers();
+
+    // Convert RustSdkCryptoJs.UserId to a `Set<string>`
+    const trackedUsers = new Set();
+    rustTrackedUsers.forEach(rustUserId => trackedUsers.add(rustUserId.toString()));
+
+    // Keep untracked user to download their keys after
+    const untrackedUsers = new Set();
+    for (const userId of userIds) {
+      // if this is a tracked user, we can just fetch the device list from the rust-sdk
+      // (NB: this is probably ok even if we race with a leave event such that we stop tracking the user's
+      // devices: the rust-sdk will return the last-known device list, which will be good enough.)
+      if (trackedUsers.has(userId)) {
+        deviceMapByUserId.set(userId, await this.getUserDevices(userId));
+      } else {
+        untrackedUsers.add(userId);
       }
+    }
 
-      // for any users whose device lists we are not tracking, fall back to downloading the device list
-      // over HTTP.
-      if (downloadUncached && untrackedUsers.size >= 1) {
-        var queryResult = yield _this13.downloadDeviceList(untrackedUsers);
-        Object.entries(queryResult.device_keys).forEach(_ref => {
-          var _ref2 = _slicedToArray(_ref, 2),
-            userId = _ref2[0],
-            deviceKeys = _ref2[1];
-          return deviceMapByUserId.set(userId, deviceKeysToDeviceMap(deviceKeys));
-        });
-      }
-      return deviceMapByUserId;
-    })();
+    // for any users whose device lists we are not tracking, fall back to downloading the device list
+    // over HTTP.
+    if (downloadUncached && untrackedUsers.size >= 1) {
+      const queryResult = await this.downloadDeviceList(untrackedUsers);
+      Object.entries(queryResult.device_keys).forEach(([userId, deviceKeys]) => deviceMapByUserId.set(userId, deviceKeysToDeviceMap(deviceKeys)));
+    }
+    return deviceMapByUserId;
   }
 
   /**
    * Get the device list for the given user from the olm machine
    * @param userId - Rust SDK UserId
    */
-  getUserDevices(userId) {
-    var _this14 = this;
-    return _asyncToGenerator(function* () {
-      var rustUserId = new RustSdkCryptoJs.UserId(userId);
-
-      // For reasons I don't really understand, the Javascript FinalizationRegistry doesn't seem to run the
-      // registered callbacks when `userDevices` goes out of scope, nor when the individual devices in the array
-      // returned by `userDevices.devices` do so.
-      //
-      // This is particularly problematic, because each of those structures holds a reference to the
-      // VerificationMachine, which in turn holds a reference to the IndexeddbCryptoStore. Hence, we end up leaking
-      // open connections to the crypto store, which means the store can't be deleted on logout.
-      //
-      // To fix this, we explicitly call `.free` on each of the objects, which tells the rust code to drop the
-      // allocated memory and decrement the refcounts for the crypto store.
+  async getUserDevices(userId) {
+    const rustUserId = new RustSdkCryptoJs.UserId(userId);
 
-      // Wait for up to a second for any in-flight device list requests to complete.
-      // The reason for this isn't so much to avoid races (some level of raciness is
-      // inevitable for this method) but to make testing easier.
-      var userDevices = yield _this14.olmMachine.getUserDevices(rustUserId, 1);
+    // For reasons I don't really understand, the Javascript FinalizationRegistry doesn't seem to run the
+    // registered callbacks when `userDevices` goes out of scope, nor when the individual devices in the array
+    // returned by `userDevices.devices` do so.
+    //
+    // This is particularly problematic, because each of those structures holds a reference to the
+    // VerificationMachine, which in turn holds a reference to the IndexeddbCryptoStore. Hence, we end up leaking
+    // open connections to the crypto store, which means the store can't be deleted on logout.
+    //
+    // To fix this, we explicitly call `.free` on each of the objects, which tells the rust code to drop the
+    // allocated memory and decrement the refcounts for the crypto store.
+
+    // Wait for up to a second for any in-flight device list requests to complete.
+    // The reason for this isn't so much to avoid races (some level of raciness is
+    // inevitable for this method) but to make testing easier.
+    const userDevices = await this.olmMachine.getUserDevices(rustUserId, 1);
+    try {
+      const deviceArray = userDevices.devices();
       try {
-        var deviceArray = userDevices.devices();
-        try {
-          return new Map(deviceArray.map(device => [device.deviceId.toString(), rustDeviceToJsDevice(device, rustUserId)]));
-        } finally {
-          deviceArray.forEach(d => d.free());
-        }
+        return new Map(deviceArray.map(device => [device.deviceId.toString(), rustDeviceToJsDevice(device, rustUserId)]));
       } finally {
-        userDevices.free();
+        deviceArray.forEach(d => d.free());
       }
-    })();
+    } finally {
+      userDevices.free();
+    }
   }
 
   /**
    * Download the given user keys by calling `/keys/query` request
    * @param untrackedUsers - download keys of these users
    */
-  downloadDeviceList(untrackedUsers) {
-    var _this15 = this;
-    return _asyncToGenerator(function* () {
-      var queryBody = {
-        device_keys: {}
-      };
-      untrackedUsers.forEach(user => queryBody.device_keys[user] = []);
-      return yield _this15.http.authedRequest(Method.Post, "/_matrix/client/v3/keys/query", undefined, queryBody, {
-        prefix: ""
-      });
-    })();
+  async downloadDeviceList(untrackedUsers) {
+    const queryBody = {
+      device_keys: {}
+    };
+    untrackedUsers.forEach(user => queryBody.device_keys[user] = []);
+    return await this.http.authedRequest(Method.Post, "/_matrix/client/v3/keys/query", undefined, queryBody, {
+      prefix: ""
+    });
   }
 
   /**
@@ -552,21 +486,16 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * Implementation of {@link CryptoApi#setDeviceVerified}.
    */
-  setDeviceVerified(userId, deviceId) {
-    var _arguments3 = arguments,
-      _this16 = this;
-    return _asyncToGenerator(function* () {
-      var verified = _arguments3.length > 2 && _arguments3[2] !== undefined ? _arguments3[2] : true;
-      var device = yield _this16.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
-      if (!device) {
-        throw new Error("Unknown device ".concat(userId, "|").concat(deviceId));
-      }
-      try {
-        yield device.setLocalTrust(verified ? RustSdkCryptoJs.LocalTrust.Verified : RustSdkCryptoJs.LocalTrust.Unset);
-      } finally {
-        device.free();
-      }
-    })();
+  async setDeviceVerified(userId, deviceId, verified = true) {
+    const device = await this.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
+    if (!device) {
+      throw new Error(`Unknown device ${userId}|${deviceId}`);
+    }
+    try {
+      await device.setLocalTrust(verified ? RustSdkCryptoJs.LocalTrust.Verified : RustSdkCryptoJs.LocalTrust.Unset);
+    } finally {
+      device.free();
+    }
   }
 
   /**
@@ -574,287 +503,269 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * Implementation of {@link CryptoApi#crossSignDevice}.
    */
-  crossSignDevice(deviceId) {
-    var _this17 = this;
-    return _asyncToGenerator(function* () {
-      var device = yield _this17.olmMachine.getDevice(new RustSdkCryptoJs.UserId(_this17.userId), new RustSdkCryptoJs.DeviceId(deviceId));
-      if (!device) {
-        throw new Error("Unknown device ".concat(deviceId));
-      }
-      try {
-        var outgoingRequest = yield device.verify();
-        yield _this17.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
-      } finally {
-        device.free();
-      }
-    })();
+  async crossSignDevice(deviceId) {
+    const device = await this.olmMachine.getDevice(new RustSdkCryptoJs.UserId(this.userId), new RustSdkCryptoJs.DeviceId(deviceId));
+    if (!device) {
+      throw new Error(`Unknown device ${deviceId}`);
+    }
+    try {
+      const outgoingRequest = await device.verify();
+      await this.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
+    } finally {
+      device.free();
+    }
   }
 
   /**
    * Implementation of {@link CryptoApi#getDeviceVerificationStatus}.
    */
-  getDeviceVerificationStatus(userId, deviceId) {
-    var _this18 = this;
-    return _asyncToGenerator(function* () {
-      var device = yield _this18.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
-      if (!device) return null;
-      try {
-        return new DeviceVerificationStatus({
-          signedByOwner: device.isCrossSignedByOwner(),
-          crossSigningVerified: device.isCrossSigningTrusted(),
-          localVerified: device.isLocallyTrusted(),
-          trustCrossSignedDevices: _this18._trustCrossSignedDevices
-        });
-      } finally {
-        device.free();
-      }
-    })();
+  async getDeviceVerificationStatus(userId, deviceId) {
+    const device = await this.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
+    if (!device) return null;
+    try {
+      return new DeviceVerificationStatus({
+        signedByOwner: device.isCrossSignedByOwner(),
+        crossSigningVerified: device.isCrossSigningTrusted(),
+        localVerified: device.isLocallyTrusted(),
+        trustCrossSignedDevices: this._trustCrossSignedDevices
+      });
+    } finally {
+      device.free();
+    }
   }
 
   /**
    * Implementation of {@link CryptoApi#getUserVerificationStatus}.
    */
-  getUserVerificationStatus(userId) {
-    var _this19 = this;
-    return _asyncToGenerator(function* () {
-      var userIdentity = yield _this19.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
-      if (userIdentity === undefined) {
-        return new UserVerificationStatus(false, false, false);
-      }
-      var verified = userIdentity.isVerified();
-      var wasVerified = userIdentity.wasPreviouslyVerified();
-      var needsUserApproval = userIdentity instanceof RustSdkCryptoJs.OtherUserIdentity ? userIdentity.identityNeedsUserApproval() : false;
-      userIdentity.free();
-      return new UserVerificationStatus(verified, wasVerified, true, needsUserApproval);
-    })();
+  async getUserVerificationStatus(userId) {
+    const userIdentity = await this.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
+    if (userIdentity === undefined) {
+      return new UserVerificationStatus(false, false, false);
+    }
+    const verified = userIdentity.isVerified();
+    const wasVerified = userIdentity.wasPreviouslyVerified();
+    const needsUserApproval = userIdentity instanceof RustSdkCryptoJs.OtherUserIdentity ? userIdentity.identityNeedsUserApproval() : false;
+    userIdentity.free();
+    return new UserVerificationStatus(verified, wasVerified, true, needsUserApproval);
   }
 
   /**
    * Implementation of {@link CryptoApi#pinCurrentUserIdentity}.
    */
-  pinCurrentUserIdentity(userId) {
-    var _this20 = this;
-    return _asyncToGenerator(function* () {
-      var userIdentity = yield _this20.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
-      if (userIdentity === undefined) {
-        throw new Error("Cannot pin identity of unknown user");
-      }
-      if (userIdentity instanceof RustSdkCryptoJs.OwnUserIdentity) {
-        throw new Error("Cannot pin identity of own user");
-      }
-      yield userIdentity.pinCurrentMasterKey();
-    })();
+  async pinCurrentUserIdentity(userId) {
+    const userIdentity = await this.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
+    if (userIdentity === undefined) {
+      throw new Error("Cannot pin identity of unknown user");
+    }
+    if (userIdentity instanceof RustSdkCryptoJs.OwnUserIdentity) {
+      throw new Error("Cannot pin identity of own user");
+    }
+    await userIdentity.pinCurrentMasterKey();
   }
 
   /**
    * Implementation of {@link CryptoApi#withdrawVerificationRequirement}.
    */
-  withdrawVerificationRequirement(userId) {
-    var _this21 = this;
-    return _asyncToGenerator(function* () {
-      var userIdentity = yield _this21.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
-      if (userIdentity === undefined) {
-        throw new Error("Cannot withdraw verification of unknown user");
-      }
-      yield userIdentity.withdrawVerification();
-    })();
+  async withdrawVerificationRequirement(userId) {
+    const userIdentity = await this.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
+    if (userIdentity === undefined) {
+      throw new Error("Cannot withdraw verification of unknown user");
+    }
+    await userIdentity.withdrawVerification();
+  }
+
+  /**
+   * Implementation of {@link CryptoApi#getUserCrossSigningKeys}.
+   */
+  async getUserCrossSigningKeys(userId) {
+    const userIdentity = await this.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
+    if (!userIdentity) {
+      return null;
+    }
+    const result = {
+      master_key: JSON.parse(userIdentity.masterKey),
+      self_signing_key: JSON.parse(userIdentity.selfSigningKey)
+    };
+
+    // The USK is only visible for our own identity
+    if ("userSigningKey" in userIdentity) {
+      result.user_signing_key = JSON.parse(userIdentity.userSigningKey);
+    }
+    return result;
   }
 
   /**
    * Implementation of {@link CryptoApi#isCrossSigningReady}
    */
-  isCrossSigningReady() {
-    var _this22 = this;
-    return _asyncToGenerator(function* () {
-      var _yield$_this22$getCro = yield _this22.getCrossSigningStatus(),
-        privateKeysInSecretStorage = _yield$_this22$getCro.privateKeysInSecretStorage,
-        privateKeysCachedLocally = _yield$_this22$getCro.privateKeysCachedLocally;
-      var hasKeysInCache = Boolean(privateKeysCachedLocally.masterKey) && Boolean(privateKeysCachedLocally.selfSigningKey) && Boolean(privateKeysCachedLocally.userSigningKey);
-      var identity = yield _this22.getOwnIdentity();
+  async isCrossSigningReady() {
+    const {
+      privateKeysInSecretStorage,
+      privateKeysCachedLocally
+    } = await this.getCrossSigningStatus();
+    const hasKeysInCache = Boolean(privateKeysCachedLocally.masterKey) && Boolean(privateKeysCachedLocally.selfSigningKey) && Boolean(privateKeysCachedLocally.userSigningKey);
+    const identity = await this.getOwnIdentity();
 
-      // Cross-signing is ready if the public identity is trusted, and the private keys
-      // are either cached, or accessible via secret-storage.
-      return !!(identity !== null && identity !== void 0 && identity.isVerified()) && (hasKeysInCache || privateKeysInSecretStorage);
-    })();
+    // Cross-signing is ready if the public identity is trusted, and the private keys
+    // are either cached, or accessible via secret-storage.
+    return !!identity?.isVerified() && (hasKeysInCache || privateKeysInSecretStorage);
   }
 
   /**
    * Implementation of {@link CryptoApi#getCrossSigningKeyId}
    */
-  getCrossSigningKeyId() {
-    var _arguments4 = arguments,
-      _this23 = this;
-    return _asyncToGenerator(function* () {
-      var type = _arguments4.length > 0 && _arguments4[0] !== undefined ? _arguments4[0] : CrossSigningKey.Master;
-      var userIdentity = yield _this23.getOwnIdentity();
-      if (!userIdentity) {
-        // The public keys are not available on this device
+  async getCrossSigningKeyId(type = CrossSigningKey.Master) {
+    const userIdentity = await this.getOwnIdentity();
+    if (!userIdentity) {
+      // The public keys are not available on this device
+      return null;
+    }
+    try {
+      const crossSigningStatus = await this.olmMachine.crossSigningStatus();
+      const privateKeysOnDevice = crossSigningStatus.hasMaster && crossSigningStatus.hasUserSigning && crossSigningStatus.hasSelfSigning;
+      if (!privateKeysOnDevice) {
+        // The private keys are not available on this device
         return null;
       }
-      try {
-        var crossSigningStatus = yield _this23.olmMachine.crossSigningStatus();
-        var privateKeysOnDevice = crossSigningStatus.hasMaster && crossSigningStatus.hasUserSigning && crossSigningStatus.hasSelfSigning;
-        if (!privateKeysOnDevice) {
-          // The private keys are not available on this device
-          return null;
-        }
-        if (!userIdentity.isVerified()) {
-          // We have both public and private keys, but they don't match!
+      if (!userIdentity.isVerified()) {
+        // We have both public and private keys, but they don't match!
+        return null;
+      }
+      let key;
+      switch (type) {
+        case CrossSigningKey.Master:
+          key = userIdentity.masterKey;
+          break;
+        case CrossSigningKey.SelfSigning:
+          key = userIdentity.selfSigningKey;
+          break;
+        case CrossSigningKey.UserSigning:
+          key = userIdentity.userSigningKey;
+          break;
+        default:
+          // Unknown type
           return null;
-        }
-        var key;
-        switch (type) {
-          case CrossSigningKey.Master:
-            key = userIdentity.masterKey;
-            break;
-          case CrossSigningKey.SelfSigning:
-            key = userIdentity.selfSigningKey;
-            break;
-          case CrossSigningKey.UserSigning:
-            key = userIdentity.userSigningKey;
-            break;
-          default:
-            // Unknown type
-            return null;
-        }
-        var parsedKey = JSON.parse(key);
-        // `keys` is an object with { [`ed25519:${pubKey}`]: pubKey }
-        // We assume only a single key, and we want the bare form without type
-        // prefix, so we select the values.
-        return Object.values(parsedKey.keys)[0];
-      } finally {
-        userIdentity.free();
       }
-    })();
+      const parsedKey = JSON.parse(key);
+      // `keys` is an object with { [`ed25519:${pubKey}`]: pubKey }
+      // We assume only a single key, and we want the bare form without type
+      // prefix, so we select the values.
+      return Object.values(parsedKey.keys)[0];
+    } finally {
+      userIdentity.free();
+    }
   }
 
   /**
    * Implementation of {@link CryptoApi#bootstrapCrossSigning}
    */
-  bootstrapCrossSigning(opts) {
-    var _this24 = this;
-    return _asyncToGenerator(function* () {
-      yield _this24.crossSigningIdentity.bootstrapCrossSigning(opts);
-    })();
+  async bootstrapCrossSigning(opts) {
+    await this.crossSigningIdentity.bootstrapCrossSigning(opts);
   }
 
   /**
    * Implementation of {@link CryptoApi#isSecretStorageReady}
    */
-  isSecretStorageReady() {
-    var _this25 = this;
-    return _asyncToGenerator(function* () {
-      return (yield _this25.getSecretStorageStatus()).ready;
-    })();
+  async isSecretStorageReady() {
+    return (await this.getSecretStorageStatus()).ready;
   }
 
   /**
    * Implementation of {@link CryptoApi#getSecretStorageStatus}
    */
-  getSecretStorageStatus() {
-    var _this26 = this;
-    return _asyncToGenerator(function* () {
-      // make sure that the cross-signing keys are stored
-      var secretsToCheck = ["m.cross_signing.master", "m.cross_signing.user_signing", "m.cross_signing.self_signing"];
+  async getSecretStorageStatus() {
+    // make sure that the cross-signing keys are stored
+    const secretsToCheck = ["m.cross_signing.master", "m.cross_signing.user_signing", "m.cross_signing.self_signing"];
 
-      // If key backup is active, we also need to check that the backup decryption key is stored
-      var keyBackupEnabled = (yield _this26.backupManager.getActiveBackupVersion()) != null;
-      if (keyBackupEnabled) {
-        secretsToCheck.push("m.megolm_backup.v1");
-      }
-      var defaultKeyId = yield _this26.secretStorage.getDefaultKeyId();
-      var result = {
-        // Assume we have all secrets until proven otherwise
-        ready: true,
-        defaultKeyId,
-        secretStorageKeyValidityMap: {}
-      };
-      for (var secretName of secretsToCheck) {
-        // Check which keys this particular secret is encrypted with
-        var record = (yield _this26.secretStorage.isStored(secretName)) || {};
-
-        // If it's encrypted with the right key, it is valid
-        var secretStored = !!defaultKeyId && defaultKeyId in record;
-        result.secretStorageKeyValidityMap[secretName] = secretStored;
-        result.ready = result.ready && secretStored;
-      }
-      return result;
-    })();
+    // If key backup is active, we also need to check that the backup decryption key is stored
+    const keyBackupEnabled = (await this.backupManager.getActiveBackupVersion()) != null;
+    if (keyBackupEnabled) {
+      secretsToCheck.push("m.megolm_backup.v1");
+    }
+    const defaultKeyId = await this.secretStorage.getDefaultKeyId();
+    const result = {
+      // Assume we have all secrets until proven otherwise
+      ready: true,
+      defaultKeyId,
+      secretStorageKeyValidityMap: {}
+    };
+    for (const secretName of secretsToCheck) {
+      // Check which keys this particular secret is encrypted with
+      const record = (await this.secretStorage.isStored(secretName)) || {};
+
+      // If it's encrypted with the right key, it is valid
+      const secretStored = !!defaultKeyId && defaultKeyId in record;
+      result.secretStorageKeyValidityMap[secretName] = secretStored;
+      result.ready = result.ready && secretStored;
+    }
+    return result;
   }
 
   /**
    * Implementation of {@link CryptoApi#bootstrapSecretStorage}
    */
-  bootstrapSecretStorage() {
-    var _arguments5 = arguments,
-      _this27 = this;
-    return _asyncToGenerator(function* () {
-      var _ref3 = _arguments5.length > 0 && _arguments5[0] !== undefined ? _arguments5[0] : {},
-        createSecretStorageKey = _ref3.createSecretStorageKey,
-        setupNewSecretStorage = _ref3.setupNewSecretStorage,
-        setupNewKeyBackup = _ref3.setupNewKeyBackup;
-      // If an AES Key is already stored in the secret storage and setupNewSecretStorage is not set
-      // we don't want to create a new key
-      var isNewSecretStorageKeyNeeded = setupNewSecretStorage || !(yield _this27.secretStorageHasAESKey());
-      if (isNewSecretStorageKeyNeeded) {
-        if (!createSecretStorageKey) {
-          throw new Error("unable to create a new secret storage key, createSecretStorageKey is not set");
-        }
-
-        // Create a new storage key and add it to secret storage
-        _this27.logger.info("bootstrapSecretStorage: creating new secret storage key");
-        var recoveryKey = yield createSecretStorageKey();
-        if (!recoveryKey) {
-          throw new Error("createSecretStorageKey() callback did not return a secret storage key");
-        }
-        yield _this27.addSecretStorageKeyToSecretStorage(recoveryKey);
-      }
-      var crossSigningPrivateKeys = yield _this27.olmMachine.exportCrossSigningKeys();
-      var hasPrivateKeys = crossSigningPrivateKeys && crossSigningPrivateKeys.masterKey !== undefined && crossSigningPrivateKeys.self_signing_key !== undefined && crossSigningPrivateKeys.userSigningKey !== undefined;
-
-      // If we have cross-signing private keys cached, store them in secret
-      // storage if they are not there already.
-      if (hasPrivateKeys && (isNewSecretStorageKeyNeeded || !(yield secretStorageContainsCrossSigningKeys(_this27.secretStorage)))) {
-        _this27.logger.info("bootstrapSecretStorage: cross-signing keys not yet exported; doing so now.");
-        yield _this27.secretStorage.store("m.cross_signing.master", crossSigningPrivateKeys.masterKey);
-        yield _this27.secretStorage.store("m.cross_signing.user_signing", crossSigningPrivateKeys.userSigningKey);
-        yield _this27.secretStorage.store("m.cross_signing.self_signing", crossSigningPrivateKeys.self_signing_key);
-      }
+  async bootstrapSecretStorage({
+    createSecretStorageKey,
+    setupNewSecretStorage,
+    setupNewKeyBackup
+  } = {}) {
+    // If an AES Key is already stored in the secret storage and setupNewSecretStorage is not set
+    // we don't want to create a new key
+    const isNewSecretStorageKeyNeeded = setupNewSecretStorage || !(await this.secretStorageHasAESKey());
+    if (isNewSecretStorageKeyNeeded) {
+      if (!createSecretStorageKey) {
+        throw new Error("unable to create a new secret storage key, createSecretStorageKey is not set");
+      }
+
+      // Create a new storage key and add it to secret storage
+      this.logger.info("bootstrapSecretStorage: creating new secret storage key");
+      const recoveryKey = await createSecretStorageKey();
+      if (!recoveryKey) {
+        throw new Error("createSecretStorageKey() callback did not return a secret storage key");
+      }
+      await this.addSecretStorageKeyToSecretStorage(recoveryKey);
+    }
+    const crossSigningPrivateKeys = await this.olmMachine.exportCrossSigningKeys();
+    const hasPrivateKeys = crossSigningPrivateKeys && crossSigningPrivateKeys.masterKey !== undefined && crossSigningPrivateKeys.self_signing_key !== undefined && crossSigningPrivateKeys.userSigningKey !== undefined;
+
+    // If we have cross-signing private keys cached, store them in secret
+    // storage if they are not there already.
+    if (hasPrivateKeys && (isNewSecretStorageKeyNeeded || !(await secretStorageContainsCrossSigningKeys(this.secretStorage)))) {
+      this.logger.info("bootstrapSecretStorage: cross-signing keys not yet exported; doing so now.");
+      await this.secretStorage.store("m.cross_signing.master", crossSigningPrivateKeys.masterKey);
+      await this.secretStorage.store("m.cross_signing.user_signing", crossSigningPrivateKeys.userSigningKey);
+      await this.secretStorage.store("m.cross_signing.self_signing", crossSigningPrivateKeys.self_signing_key);
+    }
 
-      // likewise with the key backup key: if we have one, store it in secret storage (if it's not already there)
-      // also don't bother storing it if we're about to set up a new backup
-      if (!setupNewKeyBackup) {
-        yield _this27.saveBackupKeyToStorage();
-      } else {
-        yield _this27.resetKeyBackup();
-      }
-    })();
+    // likewise with the key backup key: if we have one, store it in secret storage (if it's not already there)
+    // also don't bother storing it if we're about to set up a new backup
+    if (!setupNewKeyBackup) {
+      await this.saveBackupKeyToStorage();
+    } else {
+      await this.resetKeyBackup();
+    }
   }
 
   /**
    * If we have a backup key for the current, trusted backup in cache,
    * save it to secret storage.
    */
-  saveBackupKeyToStorage() {
-    var _this28 = this;
-    return _asyncToGenerator(function* () {
-      var keyBackupInfo = yield _this28.backupManager.getServerBackupInfo();
-      if (!keyBackupInfo || !keyBackupInfo.version) {
-        _this28.logger.info("Not saving backup key to secret storage: no backup info");
-        return;
-      }
-      var backupKeys = yield _this28.olmMachine.getBackupKeys();
-      if (!backupKeys.decryptionKey) {
-        _this28.logger.info("Not saving backup key to secret storage: no backup key");
-        return;
-      }
-      if (!decryptionKeyMatchesKeyBackupInfo(backupKeys.decryptionKey, keyBackupInfo)) {
-        _this28.logger.info("Not saving backup key to secret storage: decryption key does not match backup info");
-        return;
-      }
-      var backupKeyBase64 = backupKeys.decryptionKey.toBase64();
-      yield _this28.secretStorage.store("m.megolm_backup.v1", backupKeyBase64);
-    })();
+  async saveBackupKeyToStorage() {
+    const keyBackupInfo = await this.backupManager.getServerBackupInfo();
+    if (!keyBackupInfo || !keyBackupInfo.version) {
+      this.logger.info("Not saving backup key to secret storage: no backup info");
+      return;
+    }
+    const backupKeys = await this.olmMachine.getBackupKeys();
+    if (!backupKeys.decryptionKey) {
+      this.logger.info("Not saving backup key to secret storage: no backup key");
+      return;
+    }
+    if (!decryptionKeyMatchesKeyBackupInfo(backupKeys.decryptionKey, keyBackupInfo)) {
+      this.logger.info("Not saving backup key to secret storage: decryption key does not match backup info");
+      return;
+    }
+    const backupKeyBase64 = backupKeys.decryptionKey.toBase64();
+    await this.secretStorage.store("m.megolm_backup.v1", backupKeyBase64);
   }
 
   /**
@@ -865,18 +776,14 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @param secretStorageKey - The secret storage key to add in the secret storage.
    */
-  addSecretStorageKeyToSecretStorage(secretStorageKey) {
-    var _this29 = this;
-    return _asyncToGenerator(function* () {
-      var _secretStorageKey$key, _secretStorageKey$key2, _this29$cryptoCallbac, _this29$cryptoCallbac2;
-      var secretStorageKeyObject = yield _this29.secretStorage.addKey(SECRET_STORAGE_ALGORITHM_V1_AES, {
-        passphrase: (_secretStorageKey$key = secretStorageKey.keyInfo) === null || _secretStorageKey$key === void 0 ? void 0 : _secretStorageKey$key.passphrase,
-        name: (_secretStorageKey$key2 = secretStorageKey.keyInfo) === null || _secretStorageKey$key2 === void 0 ? void 0 : _secretStorageKey$key2.name,
-        key: secretStorageKey.privateKey
-      });
-      yield _this29.secretStorage.setDefaultKeyId(secretStorageKeyObject.keyId);
-      (_this29$cryptoCallbac = (_this29$cryptoCallbac2 = _this29.cryptoCallbacks).cacheSecretStorageKey) === null || _this29$cryptoCallbac === void 0 || _this29$cryptoCallbac.call(_this29$cryptoCallbac2, secretStorageKeyObject.keyId, secretStorageKeyObject.keyInfo, secretStorageKey.privateKey);
-    })();
+  async addSecretStorageKeyToSecretStorage(secretStorageKey) {
+    const secretStorageKeyObject = await this.secretStorage.addKey(SECRET_STORAGE_ALGORITHM_V1_AES, {
+      passphrase: secretStorageKey.keyInfo?.passphrase,
+      name: secretStorageKey.keyInfo?.name,
+      key: secretStorageKey.privateKey
+    });
+    await this.secretStorage.setDefaultKeyId(secretStorageKeyObject.keyId);
+    this.cryptoCallbacks.cacheSecretStorageKey?.(secretStorageKeyObject.keyId, secretStorageKeyObject.keyInfo, secretStorageKey.privateKey);
   }
 
   /**
@@ -884,86 +791,73 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @returns True if an AES key is in the secret storage
    */
-  secretStorageHasAESKey() {
-    var _this30 = this;
-    return _asyncToGenerator(function* () {
-      // See if we already have an AES secret-storage key.
-      var secretStorageKeyTuple = yield _this30.secretStorage.getKey();
-      if (!secretStorageKeyTuple) return false;
-      var _secretStorageKeyTupl = _slicedToArray(secretStorageKeyTuple, 2),
-        keyInfo = _secretStorageKeyTupl[1];
+  async secretStorageHasAESKey() {
+    // See if we already have an AES secret-storage key.
+    const secretStorageKeyTuple = await this.secretStorage.getKey();
+    if (!secretStorageKeyTuple) return false;
+    const [, keyInfo] = secretStorageKeyTuple;
 
-      // Check if the key is an AES key
-      return keyInfo.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES;
-    })();
+    // Check if the key is an AES key
+    return keyInfo.algorithm === SECRET_STORAGE_ALGORITHM_V1_AES;
   }
 
   /**
    * Implementation of {@link CryptoApi#getCrossSigningStatus}
    */
-  getCrossSigningStatus() {
-    var _this31 = this;
-    return _asyncToGenerator(function* () {
-      var userIdentity = yield _this31.getOwnIdentity();
-      var publicKeysOnDevice = Boolean(userIdentity === null || userIdentity === void 0 ? void 0 : userIdentity.masterKey) && Boolean(userIdentity === null || userIdentity === void 0 ? void 0 : userIdentity.selfSigningKey) && Boolean(userIdentity === null || userIdentity === void 0 ? void 0 : userIdentity.userSigningKey);
-      userIdentity === null || userIdentity === void 0 || userIdentity.free();
-      var privateKeysInSecretStorage = yield secretStorageContainsCrossSigningKeys(_this31.secretStorage);
-      var crossSigningStatus = yield _this31.getOlmMachineOrThrow().crossSigningStatus();
-      return {
-        publicKeysOnDevice,
-        privateKeysInSecretStorage,
-        privateKeysCachedLocally: {
-          masterKey: Boolean(crossSigningStatus === null || crossSigningStatus === void 0 ? void 0 : crossSigningStatus.hasMaster),
-          userSigningKey: Boolean(crossSigningStatus === null || crossSigningStatus === void 0 ? void 0 : crossSigningStatus.hasUserSigning),
-          selfSigningKey: Boolean(crossSigningStatus === null || crossSigningStatus === void 0 ? void 0 : crossSigningStatus.hasSelfSigning)
-        }
-      };
-    })();
+  async getCrossSigningStatus() {
+    const userIdentity = await this.getOwnIdentity();
+    const publicKeysOnDevice = Boolean(userIdentity?.masterKey) && Boolean(userIdentity?.selfSigningKey) && Boolean(userIdentity?.userSigningKey);
+    userIdentity?.free();
+    const privateKeysInSecretStorage = await secretStorageContainsCrossSigningKeys(this.secretStorage);
+    const crossSigningStatus = await this.getOlmMachineOrThrow().crossSigningStatus();
+    return {
+      publicKeysOnDevice,
+      privateKeysInSecretStorage,
+      privateKeysCachedLocally: {
+        masterKey: Boolean(crossSigningStatus?.hasMaster),
+        userSigningKey: Boolean(crossSigningStatus?.hasUserSigning),
+        selfSigningKey: Boolean(crossSigningStatus?.hasSelfSigning)
+      }
+    };
   }
 
   /**
    * Implementation of {@link CryptoApi#createRecoveryKeyFromPassphrase}
    */
-  createRecoveryKeyFromPassphrase(password) {
-    var _this32 = this;
-    return _asyncToGenerator(function* () {
-      if (password) {
-        // Generate the key from the passphrase
-        // first we generate a random salt
-        var salt = secureRandomString(32);
-        // then we derive the key from the passphrase
-        var recoveryKey = yield deriveRecoveryKeyFromPassphrase(password, salt, _this32.RECOVERY_KEY_DERIVATION_ITERATIONS);
-        return {
-          keyInfo: {
-            passphrase: {
-              algorithm: "m.pbkdf2",
-              iterations: _this32.RECOVERY_KEY_DERIVATION_ITERATIONS,
-              salt
-            }
-          },
-          privateKey: recoveryKey,
-          encodedPrivateKey: encodeRecoveryKey(recoveryKey)
-        };
-      } else {
-        // Using the navigator crypto API to generate the private key
-        var key = new Uint8Array(32);
-        globalThis.crypto.getRandomValues(key);
-        return {
-          privateKey: key,
-          encodedPrivateKey: encodeRecoveryKey(key)
-        };
-      }
-    })();
+  async createRecoveryKeyFromPassphrase(password) {
+    if (password) {
+      // Generate the key from the passphrase
+      // first we generate a random salt
+      const salt = secureRandomString(32);
+      // then we derive the key from the passphrase
+      const recoveryKey = await deriveRecoveryKeyFromPassphrase(password, salt, this.RECOVERY_KEY_DERIVATION_ITERATIONS);
+      return {
+        keyInfo: {
+          passphrase: {
+            algorithm: "m.pbkdf2",
+            iterations: this.RECOVERY_KEY_DERIVATION_ITERATIONS,
+            salt
+          }
+        },
+        privateKey: recoveryKey,
+        encodedPrivateKey: encodeRecoveryKey(recoveryKey)
+      };
+    } else {
+      // Using the navigator crypto API to generate the private key
+      const key = new Uint8Array(32);
+      globalThis.crypto.getRandomValues(key);
+      return {
+        privateKey: key,
+        encodedPrivateKey: encodeRecoveryKey(key)
+      };
+    }
   }
 
   /**
    * Implementation of {@link CryptoApi#getEncryptionInfoForEvent}.
    */
-  getEncryptionInfoForEvent(event) {
-    var _this33 = this;
-    return _asyncToGenerator(function* () {
-      return _this33.eventDecryptor.getEncryptionInfoForEvent(event);
-    })();
+  async getEncryptionInfoForEvent(event) {
+    return this.eventDecryptor.getEncryptionInfoForEvent(event);
   }
 
   /**
@@ -976,7 +870,7 @@ export class RustCrypto extends TypedEventEmitter {
    * @returns the VerificationRequests that are in progress
    */
   getVerificationRequestsToDeviceInProgress(userId) {
-    var requests = this.olmMachine.getVerificationRequests(new RustSdkCryptoJs.UserId(userId));
+    const requests = this.olmMachine.getVerificationRequests(new RustSdkCryptoJs.UserId(userId));
     return requests.filter(request => request.roomId === undefined && !request.isCancelled()).map(request => this.makeVerificationRequest(request));
   }
 
@@ -993,13 +887,10 @@ export class RustCrypto extends TypedEventEmitter {
    */
   findVerificationRequestDMInProgress(roomId, userId) {
     if (!userId) throw new Error("missing userId");
-    var requests = this.olmMachine.getVerificationRequests(new RustSdkCryptoJs.UserId(userId));
+    const requests = this.olmMachine.getVerificationRequests(new RustSdkCryptoJs.UserId(userId));
 
     // Search for the verification request for the given room id
-    var request = requests.find(request => {
-      var _request$roomId;
-      return ((_request$roomId = request.roomId) === null || _request$roomId === void 0 ? void 0 : _request$roomId.toString()) === roomId && !request.isCancelled();
-    });
+    const request = requests.find(request => request.roomId?.toString() === roomId && !request.isCancelled());
     if (request) {
       return this.makeVerificationRequest(request);
     }
@@ -1008,32 +899,29 @@ export class RustCrypto extends TypedEventEmitter {
   /**
    * Implementation of {@link CryptoApi#requestVerificationDM}
    */
-  requestVerificationDM(userId, roomId) {
-    var _this34 = this;
-    return _asyncToGenerator(function* () {
-      var userIdentity = yield _this34.olmMachine.getIdentity(new RustSdkCryptoJs.UserId(userId));
-      if (!userIdentity) throw new Error("unknown userId ".concat(userId));
-      try {
-        // Transform the verification methods into rust objects
-        var methods = _this34._supportedVerificationMethods.map(method => verificationMethodIdentifierToMethod(method));
-        // Get the request content to send to the DM room
-        var verCont = yield userIdentity.verificationRequestContent(methods);
-
-        // TODO: due to https://github.com/matrix-org/matrix-rust-sdk/issues/5643, we need to fix up the verification request content to include `msgtype`.
-        var verContObj = JSON.parse(verCont);
-        verContObj["msgtype"] = "m.key.verification.request";
-        var verificationEventContent = JSON.stringify(verContObj);
-
-        // Send the request content to send to the DM room
-        var eventId = yield _this34.sendVerificationRequestContent(roomId, verificationEventContent);
-
-        // Get a verification request
-        var request = yield userIdentity.requestVerification(new RustSdkCryptoJs.RoomId(roomId), new RustSdkCryptoJs.EventId(eventId), methods);
-        return _this34.makeVerificationRequest(request);
-      } finally {
-        userIdentity.free();
-      }
-    })();
+  async requestVerificationDM(userId, roomId) {
+    const userIdentity = await this.olmMachine.getIdentity(new RustSdkCryptoJs.UserId(userId));
+    if (!userIdentity) throw new Error(`unknown userId ${userId}`);
+    try {
+      // Transform the verification methods into rust objects
+      const methods = this._supportedVerificationMethods.map(method => verificationMethodIdentifierToMethod(method));
+      // Get the request content to send to the DM room
+      const verCont = userIdentity.verificationRequestContent(methods);
+
+      // TODO: due to https://github.com/matrix-org/matrix-rust-sdk/issues/5643, we need to fix up the verification request content to include `msgtype`.
+      const verContObj = JSON.parse(verCont);
+      verContObj["msgtype"] = "m.key.verification.request";
+      const verificationEventContent = JSON.stringify(verContObj);
+
+      // Send the request content to send to the DM room
+      const eventId = await this.sendVerificationRequestContent(roomId, verificationEventContent);
+
+      // Get a verification request
+      const request = userIdentity.requestVerification(new RustSdkCryptoJs.RoomId(roomId), new RustSdkCryptoJs.EventId(eventId), methods);
+      return this.makeVerificationRequest(request);
+    } finally {
+      userIdentity.free();
+    }
   }
 
   /**
@@ -1047,17 +935,15 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @returns the event id
    */
-  sendVerificationRequestContent(roomId, verificationEventContent) {
-    var _this35 = this;
-    return _asyncToGenerator(function* () {
-      var txId = secureRandomString(32);
-      // Send the verification request content to the DM room
-      var _yield$_this35$http$a = yield _this35.http.authedRequest(Method.Put, "/_matrix/client/v3/rooms/".concat(encodeURIComponent(roomId), "/send/m.room.message/").concat(encodeURIComponent(txId)), undefined, verificationEventContent, {
-          prefix: ""
-        }),
-        eventId = _yield$_this35$http$a.event_id;
-      return eventId;
-    })();
+  async sendVerificationRequestContent(roomId, verificationEventContent) {
+    const txId = secureRandomString(32);
+    // Send the verification request content to the DM room
+    const {
+      event_id: eventId
+    } = await this.http.authedRequest(Method.Put, `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${encodeURIComponent(txId)}`, undefined, verificationEventContent, {
+      prefix: ""
+    });
+    return eventId;
   }
   /**
    * Set the verification methods we offer to the other side during an interactive verification.
@@ -1066,7 +952,7 @@ export class RustCrypto extends TypedEventEmitter {
    */
   setSupportedVerificationMethods(methods) {
     // by default, the Rust SDK does not offer `m.qr_code.scan.v1`, but we do want to offer that.
-    this._supportedVerificationMethods = methods !== null && methods !== void 0 ? methods : ALL_VERIFICATION_METHODS;
+    this._supportedVerificationMethods = methods ?? ALL_VERIFICATION_METHODS;
   }
 
   /**
@@ -1078,24 +964,18 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @returns a VerificationRequest when the request has been sent to the other party.
    */
-  requestOwnUserVerification() {
-    var _this36 = this;
-    return _asyncToGenerator(function* () {
-      var userIdentity = yield _this36.getOwnIdentity();
-      if (userIdentity === undefined) {
-        throw new Error("cannot request verification for this device when there is no existing cross-signing key");
-      }
-      try {
-        var _yield$userIdentity$r = yield userIdentity.requestVerification(_this36._supportedVerificationMethods.map(verificationMethodIdentifierToMethod)),
-          _yield$userIdentity$r2 = _slicedToArray(_yield$userIdentity$r, 2),
-          request = _yield$userIdentity$r2[0],
-          outgoingRequest = _yield$userIdentity$r2[1];
-        yield _this36.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
-        return _this36.makeVerificationRequest(request);
-      } finally {
-        userIdentity.free();
-      }
-    })();
+  async requestOwnUserVerification() {
+    const userIdentity = await this.getOwnIdentity();
+    if (userIdentity === undefined) {
+      throw new Error("cannot request verification for this device when there is no existing cross-signing key");
+    }
+    try {
+      const [request, outgoingRequest] = await userIdentity.requestVerification(this._supportedVerificationMethods.map(verificationMethodIdentifierToMethod));
+      await this.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
+      return this.makeVerificationRequest(request);
+    } finally {
+      userIdentity.free();
+    }
   }
 
   /**
@@ -1110,24 +990,18 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @returns a VerificationRequest when the request has been sent to the other party.
    */
-  requestDeviceVerification(userId, deviceId) {
-    var _this37 = this;
-    return _asyncToGenerator(function* () {
-      var device = yield _this37.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
-      if (!device) {
-        throw new Error("Not a known device");
-      }
-      try {
-        var _device$requestVerifi = device.requestVerification(_this37._supportedVerificationMethods.map(verificationMethodIdentifierToMethod)),
-          _device$requestVerifi2 = _slicedToArray(_device$requestVerifi, 2),
-          request = _device$requestVerifi2[0],
-          outgoingRequest = _device$requestVerifi2[1];
-        yield _this37.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
-        return _this37.makeVerificationRequest(request);
-      } finally {
-        device.free();
-      }
-    })();
+  async requestDeviceVerification(userId, deviceId) {
+    const device = await this.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
+    if (!device) {
+      throw new Error("Not a known device");
+    }
+    try {
+      const [request, outgoingRequest] = device.requestVerification(this._supportedVerificationMethods.map(verificationMethodIdentifierToMethod));
+      await this.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
+      return this.makeVerificationRequest(request);
+    } finally {
+      device.free();
+    }
   }
 
   /**
@@ -1137,13 +1011,10 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @returns the key, if any, or null
    */
-  getSessionBackupPrivateKey() {
-    var _this38 = this;
-    return _asyncToGenerator(function* () {
-      var backupKeys = yield _this38.olmMachine.getBackupKeys();
-      if (!backupKeys.decryptionKey) return null;
-      return decodeBase64(backupKeys.decryptionKey.toBase64());
-    })();
+  async getSessionBackupPrivateKey() {
+    const backupKeys = await this.olmMachine.getBackupKeys();
+    if (!backupKeys.decryptionKey) return null;
+    return decodeBase64(backupKeys.decryptionKey.toBase64());
   }
 
   /**
@@ -1154,37 +1025,31 @@ export class RustCrypto extends TypedEventEmitter {
    * @param key - the backup decryption key
    * @param version - the backup version for this key.
    */
-  storeSessionBackupPrivateKey(key, version) {
-    var _this39 = this;
-    return _asyncToGenerator(function* () {
-      var base64Key = encodeBase64(key);
-      if (!version) {
-        throw new Error("storeSessionBackupPrivateKey: version is required");
-      }
-      yield _this39.backupManager.saveBackupDecryptionKey(RustSdkCryptoJs.BackupDecryptionKey.fromBase64(base64Key), version);
-    })();
+  async storeSessionBackupPrivateKey(key, version) {
+    const base64Key = encodeBase64(key);
+    if (!version) {
+      throw new Error("storeSessionBackupPrivateKey: version is required");
+    }
+    await this.backupManager.saveBackupDecryptionKey(RustSdkCryptoJs.BackupDecryptionKey.fromBase64(base64Key), version);
   }
 
   /**
    * Implementation of {@link CryptoApi#loadSessionBackupPrivateKeyFromSecretStorage}.
    */
-  loadSessionBackupPrivateKeyFromSecretStorage() {
-    var _this40 = this;
-    return _asyncToGenerator(function* () {
-      var backupKey = yield _this40.secretStorage.get("m.megolm_backup.v1");
-      if (!backupKey) {
-        throw new Error("loadSessionBackupPrivateKeyFromSecretStorage: missing decryption key in secret storage");
-      }
-      var keyBackupInfo = yield _this40.backupManager.getServerBackupInfo();
-      if (!keyBackupInfo || !keyBackupInfo.version) {
-        throw new Error("loadSessionBackupPrivateKeyFromSecretStorage: unable to get backup version");
-      }
-      var backupDecryptionKey = RustSdkCryptoJs.BackupDecryptionKey.fromBase64(backupKey);
-      if (!decryptionKeyMatchesKeyBackupInfo(backupDecryptionKey, keyBackupInfo)) {
-        throw new DecryptionKeyDoesNotMatchError("loadSessionBackupPrivateKeyFromSecretStorage: decryption key does not match backup info");
-      }
-      yield _this40.backupManager.saveBackupDecryptionKey(backupDecryptionKey, keyBackupInfo.version);
-    })();
+  async loadSessionBackupPrivateKeyFromSecretStorage() {
+    const backupKey = await this.secretStorage.get("m.megolm_backup.v1");
+    if (!backupKey) {
+      throw new Error("loadSessionBackupPrivateKeyFromSecretStorage: missing decryption key in secret storage");
+    }
+    const keyBackupInfo = await this.backupManager.getServerBackupInfo();
+    if (!keyBackupInfo || !keyBackupInfo.version) {
+      throw new Error("loadSessionBackupPrivateKeyFromSecretStorage: unable to get backup version");
+    }
+    const backupDecryptionKey = RustSdkCryptoJs.BackupDecryptionKey.fromBase64(backupKey);
+    if (!decryptionKeyMatchesKeyBackupInfo(backupDecryptionKey, keyBackupInfo)) {
+      throw new DecryptionKeyDoesNotMatchError("loadSessionBackupPrivateKeyFromSecretStorage: decryption key does not match backup info");
+    }
+    await this.backupManager.saveBackupDecryptionKey(backupDecryptionKey, keyBackupInfo.version);
   }
 
   /**
@@ -1192,21 +1057,15 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * Implementation of {@link CryptoApi#getActiveSessionBackupVersion}.
    */
-  getActiveSessionBackupVersion() {
-    var _this41 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this41.backupManager.getActiveBackupVersion();
-    })();
+  async getActiveSessionBackupVersion() {
+    return await this.backupManager.getActiveBackupVersion();
   }
 
   /**
    * Implementation of {@link CryptoApi#getKeyBackupInfo}.
    */
-  getKeyBackupInfo() {
-    var _this42 = this;
-    return _asyncToGenerator(function* () {
-      return (yield _this42.backupManager.getServerBackupInfo()) || null;
-    })();
+  async getKeyBackupInfo() {
+    return (await this.backupManager.getServerBackupInfo()) || null;
   }
 
   /**
@@ -1214,11 +1073,8 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * Implementation of {@link CryptoApi#isKeyBackupTrusted}.
    */
-  isKeyBackupTrusted(info) {
-    var _this43 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this43.backupManager.isKeyBackupTrusted(info);
-    })();
+  async isKeyBackupTrusted(info) {
+    return await this.backupManager.isKeyBackupTrusted(info);
   }
 
   /**
@@ -1226,61 +1082,49 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * Implementation of {@link CryptoApi#checkKeyBackupAndEnable}.
    */
-  checkKeyBackupAndEnable() {
-    var _this44 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this44.backupManager.checkKeyBackupAndEnable(true);
-    })();
+  async checkKeyBackupAndEnable() {
+    return await this.backupManager.checkKeyBackupAndEnable(true);
   }
 
   /**
    * Implementation of {@link CryptoApi#deleteKeyBackupVersion}.
    */
-  deleteKeyBackupVersion(version) {
-    var _this45 = this;
-    return _asyncToGenerator(function* () {
-      yield _this45.backupManager.deleteKeyBackupVersion(version);
-    })();
+  async deleteKeyBackupVersion(version) {
+    await this.backupManager.deleteKeyBackupVersion(version);
   }
 
   /**
    * Implementation of {@link CryptoApi#resetKeyBackup}.
    */
-  resetKeyBackup() {
-    var _this46 = this;
-    return _asyncToGenerator(function* () {
-      var backupInfo = yield _this46.backupManager.setupKeyBackup(o => _this46.signObject(o));
-      yield _this46.pushSecretToVerifiedDevices("m.megolm_backup.v1");
+  async resetKeyBackup() {
+    const backupInfo = await this.backupManager.setupKeyBackup(o => this.signObject(o));
+    await this.pushSecretToVerifiedDevices("m.megolm_backup.v1");
 
-      // we want to store the private key in 4S
-      // need to check if 4S is set up?
-      if (yield _this46.secretStorageHasAESKey()) {
-        yield _this46.secretStorage.store("m.megolm_backup.v1", backupInfo.decryptionKey.toBase64());
-      }
+    // we want to store the private key in 4S
+    // need to check if 4S is set up?
+    if (await this.secretStorageHasAESKey()) {
+      await this.secretStorage.store("m.megolm_backup.v1", backupInfo.decryptionKey.toBase64());
+    }
 
-      // we can check and start async
-      _this46.checkKeyBackupAndEnable();
-    })();
+    // we can check and start async
+    void this.checkKeyBackupAndEnable();
   }
 
   /**
    * Implementation of {@link CryptoApi#disableKeyStorage}.
    */
-  disableKeyStorage() {
-    var _this47 = this;
-    return _asyncToGenerator(function* () {
-      // Get the key backup version we're using
-      var info = yield _this47.getKeyBackupInfo();
-      if (info !== null && info !== void 0 && info.version) {
-        yield _this47.deleteKeyBackupVersion(info.version);
-      } else {
-        _this47.logger.error("Can't delete key backup version: no version available");
-      }
+  async disableKeyStorage() {
+    // Get the key backup version we're using
+    const info = await this.getKeyBackupInfo();
+    if (info?.version) {
+      await this.deleteKeyBackupVersion(info.version);
+    } else {
+      this.logger.error("Can't delete key backup version: no version available");
+    }
 
-      // also turn off 4S, since this is also storing keys on the server.
-      yield _this47.deleteSecretStorage();
-      yield _this47.dehydratedDeviceManager.delete();
-    })();
+    // also turn off 4S, since this is also storing keys on the server.
+    await this.deleteSecretStorage();
+    await this.dehydratedDeviceManager.delete();
   }
 
   /**
@@ -1291,257 +1135,218 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @param obj - The object to sign
    */
-  signObject(obj) {
-    var _this48 = this;
-    return _asyncToGenerator(function* () {
-      var sigs = new Map(Object.entries(obj.signatures || {}));
-      var unsigned = obj.unsigned;
-      delete obj.signatures;
-      delete obj.unsigned;
-      var userSignatures = sigs.get(_this48.userId) || {};
-      var canonalizedJson = anotherjson.stringify(obj);
-      var signatures = yield _this48.olmMachine.sign(canonalizedJson);
-      var map = JSON.parse(signatures.asJSON());
-      sigs.set(_this48.userId, _objectSpread(_objectSpread({}, userSignatures), map[_this48.userId]));
-      if (unsigned !== undefined) obj.unsigned = unsigned;
-      obj.signatures = Object.fromEntries(sigs.entries());
-    })();
+  async signObject(obj) {
+    const sigs = new Map(Object.entries(obj.signatures || {}));
+    const unsigned = obj.unsigned;
+    delete obj.signatures;
+    delete obj.unsigned;
+    const userSignatures = sigs.get(this.userId) || {};
+    const canonalizedJson = anotherjson.stringify(obj);
+    const signatures = await this.olmMachine.sign(canonalizedJson);
+    const map = JSON.parse(signatures.asJSON());
+    sigs.set(this.userId, _objectSpread(_objectSpread({}, userSignatures), map[this.userId]));
+    if (unsigned !== undefined) obj.unsigned = unsigned;
+    obj.signatures = Object.fromEntries(sigs.entries());
   }
 
   /**
    * Implementation of {@link CryptoApi#restoreKeyBackupWithPassphrase}.
    */
-  restoreKeyBackupWithPassphrase(passphrase, opts) {
-    var _this49 = this;
-    return _asyncToGenerator(function* () {
-      var backupInfo = yield _this49.backupManager.getServerBackupInfo();
-      if (!(backupInfo !== null && backupInfo !== void 0 && backupInfo.version)) {
-        throw new Error("No backup info available");
-      }
-      var privateKey = yield keyFromAuthData(backupInfo.auth_data, passphrase);
+  async restoreKeyBackupWithPassphrase(passphrase, opts) {
+    const backupInfo = await this.backupManager.getServerBackupInfo();
+    if (!backupInfo?.version) {
+      throw new Error("No backup info available");
+    }
+    const privateKey = await keyFromAuthData(backupInfo.auth_data, passphrase);
 
-      // Cache the key
-      yield _this49.storeSessionBackupPrivateKey(privateKey, backupInfo.version);
-      return _this49.restoreKeyBackup(opts);
-    })();
+    // Cache the key
+    await this.storeSessionBackupPrivateKey(privateKey, backupInfo.version);
+    return this.restoreKeyBackup(opts);
   }
 
   /**
    * Implementation of {@link CryptoApi#restoreKeyBackup}.
    */
-  restoreKeyBackup(opts) {
-    var _this50 = this;
-    return _asyncToGenerator(function* () {
-      // Get the decryption key from the crypto store
-      var backupKeys = yield _this50.olmMachine.getBackupKeys();
-      var decryptionKey = backupKeys.decryptionKey,
-        backupVersion = backupKeys.backupVersion;
-      if (!decryptionKey || !backupVersion) throw new Error("No decryption key found in crypto store");
-      var decodedDecryptionKey = decodeBase64(decryptionKey.toBase64());
-      var backupInfo = yield _this50.backupManager.requestKeyBackupVersion(backupVersion);
-      if (!backupInfo) throw new Error("Backup version to restore ".concat(backupVersion, " not found on server"));
-      var backupDecryptor = yield _this50.getBackupDecryptor(backupInfo, decodedDecryptionKey);
-      try {
-        var _opts$progressCallbac;
-        opts === null || opts === void 0 || (_opts$progressCallbac = opts.progressCallback) === null || _opts$progressCallbac === void 0 || _opts$progressCallbac.call(opts, {
-          stage: ImportRoomKeyStage.Fetch
-        });
-        return yield _this50.backupManager.restoreKeyBackup(backupVersion, backupDecryptor, opts);
-      } finally {
-        // Free to avoid to keep in memory the decryption key stored in it. To avoid to exposing it to an attacker.
-        backupDecryptor.free();
-      }
-    })();
+  async restoreKeyBackup(opts) {
+    // Get the decryption key from the crypto store
+    const backupKeys = await this.olmMachine.getBackupKeys();
+    const {
+      decryptionKey,
+      backupVersion
+    } = backupKeys;
+    if (!decryptionKey || !backupVersion) throw new Error("No decryption key found in crypto store");
+    const decodedDecryptionKey = decodeBase64(decryptionKey.toBase64());
+    const backupInfo = await this.backupManager.requestKeyBackupVersion(backupVersion);
+    if (!backupInfo) throw new Error(`Backup version to restore ${backupVersion} not found on server`);
+    const backupDecryptor = await this.getBackupDecryptor(backupInfo, decodedDecryptionKey);
+    try {
+      opts?.progressCallback?.({
+        stage: ImportRoomKeyStage.Fetch
+      });
+      return await this.backupManager.restoreKeyBackup(backupVersion, backupDecryptor, opts);
+    } finally {
+      // Free to avoid to keep in memory the decryption key stored in it. To avoid to exposing it to an attacker.
+      backupDecryptor.free();
+    }
   }
 
   /**
    * Implementation of {@link CryptoApi#isDehydrationSupported}.
    */
-  isDehydrationSupported() {
-    var _this51 = this;
-    return _asyncToGenerator(function* () {
-      return yield _this51.dehydratedDeviceManager.isSupported();
-    })();
+  async isDehydrationSupported() {
+    return await this.dehydratedDeviceManager.isSupported();
   }
 
   /**
    * Implementation of {@link CryptoApi#startDehydration}.
    */
-  startDehydration() {
-    var _arguments6 = arguments,
-      _this52 = this;
-    return _asyncToGenerator(function* () {
-      var opts = _arguments6.length > 0 && _arguments6[0] !== undefined ? _arguments6[0] : {};
-      if (!(yield _this52.isCrossSigningReady()) || !(yield _this52.isSecretStorageReady())) {
-        throw new Error("Device dehydration requires cross-signing and secret storage to be set up");
-      }
-      return yield _this52.dehydratedDeviceManager.start(opts || {});
-    })();
+  async startDehydration(opts = {}) {
+    if (!(await this.isCrossSigningReady()) || !(await this.isSecretStorageReady())) {
+      throw new Error("Device dehydration requires cross-signing and secret storage to be set up");
+    }
+    return await this.dehydratedDeviceManager.start(opts || {});
   }
 
   /**
    * Implementation of {@link CryptoApi#importSecretsBundle}.
    */
-  importSecretsBundle(secrets) {
-    var _this53 = this;
-    return _asyncToGenerator(function* () {
-      var secretsBundle = RustSdkCryptoJs.SecretsBundle.from_json(secrets);
-      yield _this53.getOlmMachineOrThrow().importSecretsBundle(secretsBundle); // this method frees the SecretsBundle
-    })();
+  async importSecretsBundle(secrets) {
+    const secretsBundle = RustSdkCryptoJs.SecretsBundle.from_json(secrets);
+    await this.getOlmMachineOrThrow().importSecretsBundle(secretsBundle); // this method frees the SecretsBundle
   }
 
   /**
    * Implementation of {@link CryptoApi#exportSecretsBundle}.
    */
-  exportSecretsBundle() {
-    var _this54 = this;
-    return _asyncToGenerator(function* () {
-      var secretsBundle = yield _this54.getOlmMachineOrThrow().exportSecretsBundle();
-      var secrets = secretsBundle.to_json();
-      secretsBundle.free();
-      return secrets;
-    })();
+  async exportSecretsBundle() {
+    const secretsBundle = await this.getOlmMachineOrThrow().exportSecretsBundle();
+    const secrets = secretsBundle.to_json();
+    secretsBundle.free();
+    return secrets;
   }
 
   /**
    * Implementation of {@link CryptoApi#encryptToDeviceMessages}.
    */
-  encryptToDeviceMessages(eventType, devices, payload) {
-    var _this55 = this;
-    return _asyncToGenerator(function* () {
-      var logger = new LogSpan(_this55.logger, "encryptToDeviceMessages");
-      var uniqueUsers = new Set(devices.map(_ref4 => {
-        var userId = _ref4.userId;
-        return userId;
-      }));
-
-      // This will ensure we have Olm sessions for all of the users' devices.
-      // However, we only care about some of the devices.
-      // So, perhaps we can optimise this later on.
-      yield _this55.keyClaimManager.ensureSessionsForUsers(logger, Array.from(uniqueUsers).map(userId => new RustSdkCryptoJs.UserId(userId)));
-      var batch = {
-        batch: [],
-        eventType: EventType.RoomMessageEncrypted
-      };
-      yield Promise.all(devices.map(/*#__PURE__*/function () {
-        var _ref6 = _asyncToGenerator(function* (_ref5) {
-          var userId = _ref5.userId,
-            deviceId = _ref5.deviceId;
-          var device = yield _this55.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
-          if (device) {
-            var encryptedPayload = JSON.parse(yield device.encryptToDeviceEvent(eventType, payload));
-            batch.batch.push({
-              deviceId,
-              userId,
-              payload: encryptedPayload
-            });
-          } else {
-            _this55.logger.warn("encryptToDeviceMessages: unknown device ".concat(userId, ":").concat(deviceId));
-          }
+  async encryptToDeviceMessages(eventType, devices, payload) {
+    const logger = new LogSpan(this.logger, "encryptToDeviceMessages");
+    const uniqueUsers = new Set(devices.map(({
+      userId
+    }) => userId));
+
+    // This will ensure we have Olm sessions for all of the users' devices.
+    // However, we only care about some of the devices.
+    // So, perhaps we can optimise this later on.
+    await this.keyClaimManager.ensureSessionsForUsers(logger, Array.from(uniqueUsers).map(userId => new RustSdkCryptoJs.UserId(userId)));
+    const batch = {
+      batch: [],
+      eventType: EventType.RoomMessageEncrypted
+    };
+    await Promise.all(devices.map(async ({
+      userId,
+      deviceId
+    }) => {
+      const device = await this.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
+      if (device) {
+        const encryptedPayload = JSON.parse(await device.encryptToDeviceEvent(eventType, payload));
+        batch.batch.push({
+          deviceId,
+          userId,
+          payload: encryptedPayload
         });
-        return function (_x) {
-          return _ref6.apply(this, arguments);
-        };
-      }()));
-      return batch;
-    })();
+      } else {
+        this.logger.warn(`encryptToDeviceMessages: unknown device ${userId}:${deviceId}`);
+      }
+    }));
+    return batch;
   }
 
   /**
    * Implementation of {@link CryptoApi#resetEncryption}.
    */
-  resetEncryption(authUploadDeviceSigningKeys) {
-    var _this56 = this;
-    return _asyncToGenerator(function* () {
-      _this56.logger.debug("resetEncryption: resetting encryption");
+  async resetEncryption(authUploadDeviceSigningKeys) {
+    this.logger.debug("resetEncryption: resetting encryption");
 
-      // Delete the dehydrated device, since any existing one will be signed
-      // by the wrong cross-signing key
-      _this56.dehydratedDeviceManager.delete();
+    // Delete the dehydrated device, since any existing one will be signed
+    // by the wrong cross-signing key
+    void this.dehydratedDeviceManager.delete();
 
-      // Disable backup, and delete all the backups from the server
-      yield _this56.backupManager.deleteAllKeyBackupVersions();
-      yield _this56.deleteSecretStorage();
+    // Disable backup, and delete all the backups from the server
+    await this.backupManager.deleteAllKeyBackupVersions();
+    await this.deleteSecretStorage();
 
-      // Reset the cross-signing keys
-      yield _this56.crossSigningIdentity.bootstrapCrossSigning({
-        setupNewCrossSigning: true,
-        authUploadDeviceSigningKeys
-      });
+    // Reset the cross-signing keys
+    await this.crossSigningIdentity.bootstrapCrossSigning({
+      setupNewCrossSigning: true,
+      authUploadDeviceSigningKeys
+    });
 
-      // Create a new key backup
-      yield _this56.resetKeyBackup();
-      _this56.logger.debug("resetEncryption: ended");
-    })();
+    // Create a new key backup
+    await this.resetKeyBackup();
+    this.logger.debug("resetEncryption: ended");
   }
 
   /**
    * Removes the secret storage key, default key pointer and all (known) secret storage data
    * from the user's account data
    */
-  deleteSecretStorage() {
-    var _this57 = this;
-    return _asyncToGenerator(function* () {
-      // Remove the stored secrets in the secret storage
-      yield _this57.secretStorage.store("m.cross_signing.master", null);
-      yield _this57.secretStorage.store("m.cross_signing.self_signing", null);
-      yield _this57.secretStorage.store("m.cross_signing.user_signing", null);
-      yield _this57.secretStorage.store("m.megolm_backup.v1", null);
+  async deleteSecretStorage() {
+    // Remove the stored secrets in the secret storage
+    await this.secretStorage.store("m.cross_signing.master", null);
+    await this.secretStorage.store("m.cross_signing.self_signing", null);
+    await this.secretStorage.store("m.cross_signing.user_signing", null);
+    await this.secretStorage.store("m.megolm_backup.v1", null);
 
-      // Remove the recovery key
-      var defaultKeyId = yield _this57.secretStorage.getDefaultKeyId();
-      if (defaultKeyId) yield _this57.secretStorage.store("m.secret_storage.key.".concat(defaultKeyId), null);
-      // Disable the recovery key and the secret storage
-      yield _this57.secretStorage.setDefaultKeyId(null);
-    })();
+    // Remove the recovery key
+    const defaultKeyId = await this.secretStorage.getDefaultKeyId();
+    if (defaultKeyId) await this.secretStorage.store(`m.secret_storage.key.${defaultKeyId}`, null);
+    // Disable the recovery key and the secret storage
+    await this.secretStorage.setDefaultKeyId(null);
   }
 
   /**
    * Implementation of {@link CryptoApi#shareRoomHistoryWithUser}.
    */
-  shareRoomHistoryWithUser(roomId, userId) {
-    var _this58 = this;
-    return _asyncToGenerator(function* () {
-      var logger = new LogSpan(_this58.logger, "shareRoomHistoryWithUser(".concat(roomId, ", ").concat(userId, ")"));
+  async shareRoomHistoryWithUser(roomId, userId) {
+    const logger = new LogSpan(this.logger, `shareRoomHistoryWithUser(${roomId}, ${userId})`);
 
-      // 0. We can only share room history if our user has set up cross-signing.
-      var identity = yield _this58.getOwnIdentity();
-      if (!(identity !== null && identity !== void 0 && identity.isVerified())) {
-        logger.warn("Not sharing message history as the current device is not verified by our cross-signing identity");
-        return;
-      }
-      logger.info("Sharing message history");
+    // 0. We can only share room history if our user has set up cross-signing.
+    const identity = await this.getOwnIdentity();
+    if (!identity?.isVerified()) {
+      logger.warn("Not sharing message history as the current device is not verified by our cross-signing identity");
+      return;
+    }
+    logger.info("Sharing message history");
 
-      // 1. Download keys from backup.
-      if (!(yield _this58.getOlmMachineOrThrow().hasDownloadedAllRoomKeys(new RustSdkCryptoJs.RoomId(roomId)))) {
-        yield _this58.backupManager.downloadLatestRoomKeyBackup(roomId);
-        yield _this58.getOlmMachineOrThrow().setHasDownloadedAllRoomKeys(new RustSdkCryptoJs.RoomId(roomId));
-      }
+    // 1. Download keys from backup.
+    if (!(await this.getOlmMachineOrThrow().hasDownloadedAllRoomKeys(new RustSdkCryptoJs.RoomId(roomId)))) {
+      await this.backupManager.downloadLatestRoomKeyBackup(roomId);
+      await this.getOlmMachineOrThrow().setHasDownloadedAllRoomKeys(new RustSdkCryptoJs.RoomId(roomId));
+    }
 
-      // 2. Construct the key bundle
-      var bundle = yield _this58.getOlmMachineOrThrow().buildRoomKeyBundle(new RustSdkCryptoJs.RoomId(roomId));
-      if (!bundle) {
-        logger.info("No keys to share");
-        return;
-      }
+    // 2. Construct the key bundle
+    const bundle = await this.getOlmMachineOrThrow().buildRoomKeyBundle(new RustSdkCryptoJs.RoomId(roomId));
+    if (!bundle) {
+      logger.info("No keys to share");
+      return;
+    }
 
-      // 3. Upload the encrypted bundle to the server
-      var uploadResponse = yield _this58.http.uploadContent(bundle.encryptedData);
-      logger.info("Uploaded encrypted key blob: ".concat(JSON.stringify(uploadResponse)));
+    // 3. Upload the encrypted bundle to the server
+    const uploadResponse = await this.http.uploadContent(bundle.encryptedData);
+    logger.info(`Uploaded encrypted key blob: ${JSON.stringify(uploadResponse)}`);
 
-      // 4. We may not share a room with the user, so get a fresh list of devices for the invited user.
-      var req = _this58.getOlmMachineOrThrow().queryKeysForUsers([new RustSdkCryptoJs.UserId(userId)]);
-      yield _this58.outgoingRequestProcessor.makeOutgoingRequest(req);
+    // 4. We may not share a room with the user, so get a fresh list of devices for the invited user.
+    const req = this.getOlmMachineOrThrow().queryKeysForUsers([new RustSdkCryptoJs.UserId(userId)]);
+    await this.outgoingRequestProcessor.makeOutgoingRequest(req);
 
-      // 5. Establish Olm sessions with all of the recipient's devices.
-      yield _this58.keyClaimManager.ensureSessionsForUsers(logger, [new RustSdkCryptoJs.UserId(userId)]);
+    // 5. Establish Olm sessions with all of the recipient's devices.
+    await this.keyClaimManager.ensureSessionsForUsers(logger, [new RustSdkCryptoJs.UserId(userId)]);
 
-      // 6. Send to-device messages to the recipient to share the keys.
-      var requests = yield _this58.getOlmMachineOrThrow().shareRoomKeyBundleData(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.RoomId(roomId), uploadResponse.content_uri, bundle.mediaEncryptionInfo, RustSdkCryptoJs.CollectStrategy.identityBasedStrategy());
-      for (var _req of requests) {
-        yield _this58.outgoingRequestProcessor.makeOutgoingRequest(_req);
-      }
-    })();
+    // 6. Send to-device messages to the recipient to share the keys.
+    const requests = await this.getOlmMachineOrThrow().shareRoomKeyBundleData(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.RoomId(roomId), uploadResponse.content_uri, bundle.mediaEncryptionInfo, RustSdkCryptoJs.CollectStrategy.identityBasedStrategy());
+    for (const req of requests) {
+      await this.outgoingRequestProcessor.makeOutgoingRequest(req);
+    }
   }
 
   ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1558,17 +1363,13 @@ export class RustCrypto extends TypedEventEmitter {
    * @param devices - the received device list updates
    * @returns A list of processed to-device messages.
    */
-  receiveSyncChanges(_ref7) {
-    var _this59 = this;
-    return _asyncToGenerator(function* () {
-      var events = _ref7.events,
-        _ref7$oneTimeKeysCoun = _ref7.oneTimeKeysCounts,
-        oneTimeKeysCounts = _ref7$oneTimeKeysCoun === void 0 ? new Map() : _ref7$oneTimeKeysCoun,
-        unusedFallbackKeys = _ref7.unusedFallbackKeys,
-        _ref7$devices = _ref7.devices,
-        devices = _ref7$devices === void 0 ? new RustSdkCryptoJs.DeviceLists() : _ref7$devices;
-      return yield _this59.olmMachine.receiveSyncChanges(events ? JSON.stringify(events) : "[]", devices, oneTimeKeysCounts, unusedFallbackKeys);
-    })();
+  async receiveSyncChanges({
+    events,
+    oneTimeKeysCounts = new Map(),
+    unusedFallbackKeys,
+    devices = new RustSdkCryptoJs.DeviceLists()
+  }) {
+    return await this.olmMachine.receiveSyncChanges(events ? JSON.stringify(events) : "[]", devices, oneTimeKeysCounts, unusedFallbackKeys);
   }
 
   /** called by the sync loop to preprocess incoming to-device messages
@@ -1576,87 +1377,80 @@ export class RustCrypto extends TypedEventEmitter {
    * @param events - the received to-device messages
    * @returns A list of preprocessed to-device messages.
    */
-  preprocessToDeviceMessages(events) {
-    var _this60 = this;
-    return _asyncToGenerator(function* () {
-      // send the received to-device messages into receiveSyncChanges. We have no info on device-list changes,
-      // one-time-keys, or fallback keys, so just pass empty data.
-      var processed = yield _this60.receiveSyncChanges({
-        events
-      });
-      var received = [];
-      var _loop = function* _loop() {
-        var parsedMessage = JSON.parse(message.rawEvent);
-
-        // look for interesting to-device messages
-        if (parsedMessage.type === EventType.KeyVerificationRequest) {
-          var sender = parsedMessage.sender;
-          var transactionId = parsedMessage.content.transaction_id;
-          if (transactionId && sender) {
-            _this60.onIncomingKeyVerificationRequest(sender, transactionId);
-          }
+  async preprocessToDeviceMessages(events) {
+    // send the received to-device messages into receiveSyncChanges. We have no info on device-list changes,
+    // one-time-keys, or fallback keys, so just pass empty data.
+    const processed = await this.receiveSyncChanges({
+      events
+    });
+    const received = [];
+    for (const message of processed) {
+      const parsedMessage = JSON.parse(message.rawEvent);
+
+      // look for interesting to-device messages
+      if (parsedMessage.type === EventType.KeyVerificationRequest) {
+        const sender = parsedMessage.sender;
+        const transactionId = parsedMessage.content.transaction_id;
+        if (transactionId && sender) {
+          this.onIncomingKeyVerificationRequest(sender, transactionId);
         }
-        switch (message.type) {
-          case RustSdkCryptoJs.ProcessedToDeviceEventType.Decrypted:
-            {
-              var _encryptionInfo$sende;
-              var encryptionInfo = message.encryptionInfo;
-              received.push({
-                message: parsedMessage,
-                encryptionInfo: {
-                  sender: encryptionInfo.sender.toString(),
-                  senderDevice: (_encryptionInfo$sende = encryptionInfo.senderDevice) === null || _encryptionInfo$sende === void 0 ? void 0 : _encryptionInfo$sende.toString(),
-                  senderCurve25519KeyBase64: encryptionInfo.senderCurve25519Key,
-                  senderVerified: encryptionInfo.isSenderVerified()
-                }
-              });
-
-              // If we have received a room key bundle message, and have recently joined the room in question,
-              // tell the Rust SDK to try and accept the key bundle.
-              //
-              // We don't actually need to validate the contents of the bundle message, or do
-              // anything with its contents at all. We simply want to inform the Rust SDK we have
-              // received a new room key bundle that we might be able to download.
-              if (isRoomKeyBundleMessage(parsedMessage)) {
-                var roomId = parsedMessage.content.room_id;
-                var pendingDetails = yield _this60.olmMachine.getPendingKeyBundleDetailsForRoom(new RustSdkCryptoJs.RoomId(roomId));
-                // Only accept the key bundle if we joined the room less than 24 hours ago.
-                if (!pendingDetails) {
-                  _this60.logger.debug("Not yet accepting key bundle for room where we are not awaiting a bundle: ".concat(roomId));
-                } else if (Date.now() - pendingDetails.inviteAcceptedAtMillis > MAX_INVITE_ACCEPTANCE_MS_FOR_KEY_BUNDLE) {
-                  _this60.logger.info("Ignoring key bundle for room we joined too long ago: ".concat(roomId, ", joining time: ").concat(new Date(pendingDetails.inviteAcceptedAtMillis).toISOString()));
-                } else {
-                  _this60.logger.info("Considering key bundle for recently-joined room ".concat(roomId));
-                  // Don't block for the import to happen, here, as this is called from inside the `/sync` loop.
-                  _this60.maybeAcceptKeyBundle(roomId, pendingDetails.inviterId.toString()).catch(err => {
-                    _this60.logger.error("Error attempting to download key bundle for room ".concat(roomId));
-                    _this60.logger.error(err);
-                  });
-                }
+      }
+      switch (message.type) {
+        case RustSdkCryptoJs.ProcessedToDeviceEventType.Decrypted:
+          {
+            const encryptionInfo = message.encryptionInfo;
+            received.push({
+              message: parsedMessage,
+              encryptionInfo: {
+                sender: encryptionInfo.sender.toString(),
+                senderDevice: encryptionInfo.senderDevice?.toString(),
+                senderCurve25519KeyBase64: encryptionInfo.senderCurve25519Key,
+                senderVerified: encryptionInfo.isSenderVerified()
+              }
+            });
+
+            // If we have received a room key bundle message, and have recently joined the room in question,
+            // tell the Rust SDK to try and accept the key bundle.
+            //
+            // We don't actually need to validate the contents of the bundle message, or do
+            // anything with its contents at all. We simply want to inform the Rust SDK we have
+            // received a new room key bundle that we might be able to download.
+            if (isRoomKeyBundleMessage(parsedMessage)) {
+              const roomId = parsedMessage.content.room_id;
+              const pendingDetails = await this.olmMachine.getPendingKeyBundleDetailsForRoom(new RustSdkCryptoJs.RoomId(roomId));
+              // Only accept the key bundle if we joined the room less than 24 hours ago.
+              if (!pendingDetails) {
+                this.logger.debug(`Not yet accepting key bundle for room where we are not awaiting a bundle: ${roomId}`);
+              } else if (Date.now() - pendingDetails.inviteAcceptedAtMillis > MAX_INVITE_ACCEPTANCE_MS_FOR_KEY_BUNDLE) {
+                this.logger.info(`Ignoring key bundle for room we joined too long ago: ${roomId}, joining time: ${new Date(pendingDetails.inviteAcceptedAtMillis).toISOString()}`);
+              } else {
+                this.logger.info(`Considering key bundle for recently-joined room ${roomId}`);
+                // Don't block for the import to happen, here, as this is called from inside the `/sync` loop.
+                this.maybeAcceptKeyBundle(roomId, pendingDetails.inviterId.toString()).catch(err => {
+                  this.logger.error(`Error attempting to download key bundle for room ${roomId}`);
+                  this.logger.error(err);
+                });
               }
-              break;
-            }
-          case RustSdkCryptoJs.ProcessedToDeviceEventType.PlainText:
-            {
-              received.push({
-                message: parsedMessage,
-                encryptionInfo: null
-              });
-              break;
             }
-          case RustSdkCryptoJs.ProcessedToDeviceEventType.UnableToDecrypt:
-            // ignore messages we cannot decrypt
             break;
-          case RustSdkCryptoJs.ProcessedToDeviceEventType.Invalid:
-            // ignore invalid messages
+          }
+        case RustSdkCryptoJs.ProcessedToDeviceEventType.PlainText:
+          {
+            received.push({
+              message: parsedMessage,
+              encryptionInfo: null
+            });
             break;
-        }
-      };
-      for (var message of processed) {
-        yield* _loop();
+          }
+        case RustSdkCryptoJs.ProcessedToDeviceEventType.UnableToDecrypt:
+          // ignore messages we cannot decrypt
+          break;
+        case RustSdkCryptoJs.ProcessedToDeviceEventType.Invalid:
+          // ignore invalid messages
+          break;
       }
-      return received;
-    })();
+    }
+    return received;
   }
 
   /** called by the sync loop to process one time key counts and unused fallback keys
@@ -1664,18 +1458,15 @@ export class RustCrypto extends TypedEventEmitter {
    * @param oneTimeKeysCounts - the received one time key counts
    * @param unusedFallbackKeys - the received unused fallback keys
    */
-  processKeyCounts(oneTimeKeysCounts, unusedFallbackKeys) {
-    var _this61 = this;
-    return _asyncToGenerator(function* () {
-      var mapOneTimeKeysCount = oneTimeKeysCounts && new Map(Object.entries(oneTimeKeysCounts));
-      var setUnusedFallbackKeys = unusedFallbackKeys && new Set(unusedFallbackKeys);
-      if (mapOneTimeKeysCount !== undefined || setUnusedFallbackKeys !== undefined) {
-        yield _this61.receiveSyncChanges({
-          oneTimeKeysCounts: mapOneTimeKeysCount,
-          unusedFallbackKeys: setUnusedFallbackKeys
-        });
-      }
-    })();
+  async processKeyCounts(oneTimeKeysCounts, unusedFallbackKeys) {
+    const mapOneTimeKeysCount = oneTimeKeysCounts && new Map(Object.entries(oneTimeKeysCounts));
+    const setUnusedFallbackKeys = unusedFallbackKeys && new Set(unusedFallbackKeys);
+    if (mapOneTimeKeysCount !== undefined || setUnusedFallbackKeys !== undefined) {
+      await this.receiveSyncChanges({
+        oneTimeKeysCounts: mapOneTimeKeysCount,
+        unusedFallbackKeys: setUnusedFallbackKeys
+      });
+    }
   }
 
   /** called by the sync loop to process the notification that device lists have
@@ -1683,15 +1474,11 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @param deviceLists - device_lists field from /sync
    */
-  processDeviceLists(deviceLists) {
-    var _this62 = this;
-    return _asyncToGenerator(function* () {
-      var _deviceLists$changed, _deviceLists$left;
-      var devices = new RustSdkCryptoJs.DeviceLists((_deviceLists$changed = deviceLists.changed) === null || _deviceLists$changed === void 0 ? void 0 : _deviceLists$changed.map(userId => new RustSdkCryptoJs.UserId(userId)), (_deviceLists$left = deviceLists.left) === null || _deviceLists$left === void 0 ? void 0 : _deviceLists$left.map(userId => new RustSdkCryptoJs.UserId(userId)));
-      yield _this62.receiveSyncChanges({
-        devices
-      });
-    })();
+  async processDeviceLists(deviceLists) {
+    const devices = new RustSdkCryptoJs.DeviceLists(deviceLists.changed?.map(userId => new RustSdkCryptoJs.UserId(userId)), deviceLists.left?.map(userId => new RustSdkCryptoJs.UserId(userId)));
+    await this.receiveSyncChanges({
+      devices
+    });
   }
 
   /** called by the sync loop on m.room.encryption events
@@ -1699,40 +1486,37 @@ export class RustCrypto extends TypedEventEmitter {
    * @param room - in which the event was received
    * @param event - encryption event to be processed
    */
-  onCryptoEvent(room, event) {
-    var _this63 = this;
-    return _asyncToGenerator(function* () {
-      var config = event.getContent();
-      var settings = new RustSdkCryptoJs.RoomSettings();
-      if (config.algorithm === "m.megolm.v1.aes-sha2") {
-        settings.algorithm = RustSdkCryptoJs.EncryptionAlgorithm.MegolmV1AesSha2;
-      } else {
-        // Among other situations, this happens if the crypto state event is redacted.
-        _this63.logger.warn("Room ".concat(room.roomId, ": ignoring crypto event with invalid algorithm ").concat(config.algorithm));
-        return;
-      }
-      if (config["io.element.msc4362.encrypt_state_events"] && _this63.enableEncryptedStateEvents) {
-        _this63.logger.info("crypto Enabling state event encryption...");
-        settings.encryptStateEvents = true;
-      }
-      try {
-        settings.sessionRotationPeriodMs = config.rotation_period_ms;
-        settings.sessionRotationPeriodMessages = config.rotation_period_msgs;
-        yield _this63.olmMachine.setRoomSettings(new RustSdkCryptoJs.RoomId(room.roomId), settings);
-      } catch (e) {
-        _this63.logger.warn("Room ".concat(room.roomId, ": ignoring crypto event which caused error: ").concat(e));
-        return;
-      }
+  async onCryptoEvent(room, event) {
+    const config = event.getContent();
+    const settings = new RustSdkCryptoJs.RoomSettings();
+    if (config.algorithm === "m.megolm.v1.aes-sha2") {
+      settings.algorithm = RustSdkCryptoJs.EncryptionAlgorithm.MegolmV1AesSha2;
+    } else {
+      // Among other situations, this happens if the crypto state event is redacted.
+      this.logger.warn(`Room ${room.roomId}: ignoring crypto event with invalid algorithm ${config.algorithm}`);
+      return;
+    }
+    if (config["io.element.msc4362.encrypt_state_events"] && this.enableEncryptedStateEvents) {
+      this.logger.info("crypto Enabling state event encryption...");
+      settings.encryptStateEvents = true;
+    }
+    try {
+      settings.sessionRotationPeriodMs = config.rotation_period_ms;
+      settings.sessionRotationPeriodMessages = config.rotation_period_msgs;
+      await this.olmMachine.setRoomSettings(new RustSdkCryptoJs.RoomId(room.roomId), settings);
+    } catch (e) {
+      this.logger.warn(`Room ${room.roomId}: ignoring crypto event which caused error: ${e}`);
+      return;
+    }
 
-      // If we got this far, the SDK found the event acceptable.
-      // We need to either create or update the active RoomEncryptor.
-      var existingEncryptor = _this63.roomEncryptors[room.roomId];
-      if (existingEncryptor) {
-        existingEncryptor.onCryptoEvent(config);
-      } else {
-        _this63.roomEncryptors[room.roomId] = new RoomEncryptor(_this63.logger.getChild("[".concat(room.roomId, " encryption]")), _this63.olmMachine, _this63.keyClaimManager, _this63.outgoingRequestsManager, room, config);
-      }
-    })();
+    // If we got this far, the SDK found the event acceptable.
+    // We need to either create or update the active RoomEncryptor.
+    const existingEncryptor = this.roomEncryptors[room.roomId];
+    if (existingEncryptor) {
+      existingEncryptor.onCryptoEvent(config);
+    } else {
+      this.roomEncryptors[room.roomId] = new RoomEncryptor(this.logger.getChild(`[${room.roomId} encryption]`), this.olmMachine, this.keyClaimManager, this.outgoingRequestsManager, room, config);
+    }
   }
 
   /** called by the sync loop after processing each sync.
@@ -1751,11 +1535,8 @@ export class RustCrypto extends TypedEventEmitter {
   /**
    * Implementation of {@link CryptoApi#markAllTrackedUsersAsDirty}.
    */
-  markAllTrackedUsersAsDirty() {
-    var _this64 = this;
-    return _asyncToGenerator(function* () {
-      yield _this64.olmMachine.markAllTrackedUsersAsDirty();
-    })();
+  async markAllTrackedUsersAsDirty() {
+    await this.olmMachine.markAllTrackedUsersAsDirty();
   }
 
   /**
@@ -1766,13 +1547,13 @@ export class RustCrypto extends TypedEventEmitter {
    *    content of the message; for in-room messages it is the event ID.
    */
   onIncomingKeyVerificationRequest(sender, transactionId) {
-    var request = this.olmMachine.getVerificationRequest(new RustSdkCryptoJs.UserId(sender), transactionId);
+    const request = this.olmMachine.getVerificationRequest(new RustSdkCryptoJs.UserId(sender), transactionId);
     if (request) {
       this.emit(CryptoEvent.VerificationRequestReceived, this.makeVerificationRequest(request));
     } else {
       // There are multiple reasons this can happen; probably the most likely is that the event is an
       // in-room event which is too old.
-      this.logger.info("Ignoring just-received verification request ".concat(transactionId, " which did not start a rust-side verification"));
+      this.logger.info(`Ignoring just-received verification request ${transactionId} which did not start a rust-side verification`);
     }
   }
 
@@ -1794,16 +1575,16 @@ export class RustCrypto extends TypedEventEmitter {
    * @param oldMembership - The previous membership state. Null if it's a new member.
    */
   onRoomMembership(event, member, oldMembership) {
-    var roomId = event.getRoomId();
+    const roomId = event.getRoomId();
 
     // If it's our own membership, and we are no longer joined, clear any indication that we are waiting for a key
     // bundle.
     if (oldMembership === KnownMembership.Join && member.membership !== KnownMembership.Join && member.userId === this.olmMachine.userId.toString()) {
       this.olmMachine.clearRoomPendingKeyBundle(new RustSdkCryptoJs.RoomId(roomId)).catch(e => {
-        this.logger.error("Error clearing room pending key bundle indicator for ".concat(roomId, ": ").concat(e));
+        this.logger.error(`Error clearing room pending key bundle indicator for ${roomId}: ${e}`);
       });
     }
-    var enc = this.roomEncryptors[roomId];
+    const enc = this.roomEncryptors[roomId];
     if (!enc) {
       // not encrypting in this room
       return;
@@ -1840,8 +1621,8 @@ export class RustCrypto extends TypedEventEmitter {
       return;
     }
     if (event.getStateKey() !== this.olmMachine.userId.toString() && event.getContent().membership !== KnownMembership.Join) {
-      this.logger.info("Rotating session for room ".concat(event.getRoomId(), " due to member leaving the room"));
-      this.forceDiscardSession(event.getRoomId());
+      this.logger.info(`Rotating session for room ${event.getRoomId()} due to member leaving the room`);
+      void this.forceDiscardSession(event.getRoomId());
     }
   }
 
@@ -1853,22 +1634,18 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @param keys - details of the updated keys
    */
-  onRoomKeysUpdated(keys) {
-    var _this65 = this;
-    return _asyncToGenerator(function* () {
-      for (var key of keys) {
-        _this65.onRoomKeyUpdated(key);
-      }
-      _this65.backupManager.maybeUploadKey();
-    })();
+  async onRoomKeysUpdated(keys) {
+    for (const key of keys) {
+      this.onRoomKeyUpdated(key);
+    }
+    void this.backupManager.maybeUploadKey();
   }
   onRoomKeyUpdated(key) {
-    var _this66 = this;
     if (this.stopped) return;
-    this.logger.debug("Got update for session ".concat(key.sessionId, " from sender ").concat(key.senderKey.toBase64(), " in ").concat(key.roomId.toString()));
-    var pendingList = this.eventDecryptor.getEventsPendingRoomKey(key.roomId.toString(), key.sessionId);
+    this.logger.debug(`Got update for session ${key.sessionId} from sender ${key.senderKey.toBase64()} in ${key.roomId.toString()}`);
+    const pendingList = this.eventDecryptor.getEventsPendingRoomKey(key.roomId.toString(), key.sessionId);
     if (pendingList.length === 0) return;
-    this.logger.debug("Retrying decryption on events:", pendingList.map(e => "".concat(e.getId())));
+    this.logger.debug("Retrying decryption on events:", pendingList.map(e => `${e.getId()}`));
 
     // Have another go at decrypting events with this key.
     //
@@ -1876,15 +1653,12 @@ export class RustCrypto extends TypedEventEmitter {
     // so we don't wait for the decryption to complete. In any case, there is no need to wait:
     // MatrixEvent.attemptDecryption ensures that there is only one decryption attempt happening at once,
     // and deduplicates repeated attempts for the same event.
-    var _loop2 = function _loop2(ev) {
-      ev.attemptDecryption(_this66, {
+    for (const ev of pendingList) {
+      ev.attemptDecryption(this, {
         isRetry: true
       }).catch(_e => {
-        _this66.logger.info("Still unable to decrypt event ".concat(ev.getId(), " after receiving key"));
+        this.logger.info(`Still unable to decrypt event ${ev.getId()} after receiving key`);
       });
-    };
-    for (var ev of pendingList) {
-      _loop2(ev);
     }
   }
 
@@ -1896,25 +1670,22 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @param withheld - Details of the withheld sessions.
    */
-  onRoomKeysWithheld(withheld) {
-    var _this67 = this;
-    return _asyncToGenerator(function* () {
-      for (var session of withheld) {
-        _this67.logger.debug("Got withheld message for session ".concat(session.sessionId, " in ").concat(session.roomId.toString()));
-        var pendingList = _this67.eventDecryptor.getEventsPendingRoomKey(session.roomId.toString(), session.sessionId);
-        if (pendingList.length === 0) return;
-
-        // The easiest way to update the status of the event is to have another go at decrypting it.
-        _this67.logger.debug("Retrying decryption on events:", pendingList.map(e => "".concat(e.getId())));
-        for (var ev of pendingList) {
-          ev.attemptDecryption(_this67, {
-            isRetry: true
-          }).catch(_e => {
-            // It's somewhat expected that we still can't decrypt here.
-          });
-        }
+  async onRoomKeysWithheld(withheld) {
+    for (const session of withheld) {
+      this.logger.debug(`Got withheld message for session ${session.sessionId} in ${session.roomId.toString()}`);
+      const pendingList = this.eventDecryptor.getEventsPendingRoomKey(session.roomId.toString(), session.sessionId);
+      if (pendingList.length === 0) return;
+
+      // The easiest way to update the status of the event is to have another go at decrypting it.
+      this.logger.debug("Retrying decryption on events:", pendingList.map(e => `${e.getId()}`));
+      for (const ev of pendingList) {
+        ev.attemptDecryption(this, {
+          isRetry: true
+        }).catch(_e => {
+          // It's somewhat expected that we still can't decrypt here.
+        });
       }
-    })();
+    }
   }
 
   /**
@@ -1925,19 +1696,16 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @param userId - the user with the updated identity
    */
-  onUserIdentityUpdated(userId) {
-    var _this68 = this;
-    return _asyncToGenerator(function* () {
-      var newVerification = yield _this68.getUserVerificationStatus(userId.toString());
-      _this68.emit(CryptoEvent.UserTrustStatusChanged, userId.toString(), newVerification);
-
-      // If our own user identity has changed, we may now trust the key backup where we did not before.
-      // So, re-check the key backup status and enable it if available.
-      if (userId.toString() === _this68.userId) {
-        _this68.emit(CryptoEvent.KeysChanged, {});
-        yield _this68.checkKeyBackupAndEnable();
-      }
-    })();
+  async onUserIdentityUpdated(userId) {
+    const newVerification = await this.getUserVerificationStatus(userId.toString());
+    this.emit(CryptoEvent.UserTrustStatusChanged, userId.toString(), newVerification);
+
+    // If our own user identity has changed, we may now trust the key backup where we did not before.
+    // So, re-check the key backup status and enable it if available.
+    if (userId.toString() === this.userId) {
+      this.emit(CryptoEvent.KeysChanged, {});
+      await this.checkKeyBackupAndEnable();
+    }
   }
 
   /**
@@ -1950,12 +1718,9 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @param userIds - an array of user IDs of users whose devices have updated.
    */
-  onDevicesUpdated(userIds) {
-    var _this69 = this;
-    return _asyncToGenerator(function* () {
-      _this69.emit(CryptoEvent.WillUpdateDevices, userIds, false);
-      _this69.emit(CryptoEvent.DevicesUpdated, userIds, false);
-    })();
+  async onDevicesUpdated(userIds) {
+    this.emit(CryptoEvent.WillUpdateDevices, userIds, false);
+    this.emit(CryptoEvent.DevicesUpdated, userIds, false);
   }
 
   /**
@@ -1970,19 +1735,16 @@ export class RustCrypto extends TypedEventEmitter {
    * @param name - the secret name
    * @param value - the secret value
    */
-  handleSecretReceived(name, value) {
-    var _this70 = this;
-    return _asyncToGenerator(function* () {
-      _this70.logger.debug("onReceiveSecret: Received secret ".concat(name));
-      if (name === "m.megolm_backup.v1") {
-        return yield _this70.backupManager.handleBackupSecretReceived(value);
-        // XXX at this point we should probably try to download the backup and import the keys,
-        // or at least retry for the current decryption failures?
-        // Maybe add some signaling when a new secret is received, and let clients handle it?
-        // as it's where the restore from backup APIs are exposed.
-      }
-      return false;
-    })();
+  async handleSecretReceived(name, value) {
+    this.logger.debug(`onReceiveSecret: Received secret ${name}`);
+    if (name === "m.megolm_backup.v1") {
+      return await this.backupManager.handleBackupSecretReceived(value);
+      // XXX at this point we should probably try to download the backup and import the keys,
+      // or at least retry for the current decryption failures?
+      // Maybe add some signaling when a new secret is received, and let clients handle it?
+      // as it's where the restore from backup APIs are exposed.
+    }
+    return false;
   }
 
   /**
@@ -1992,21 +1754,18 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @param name - The name of the secret received.
    */
-  checkSecrets(name) {
-    var _this71 = this;
-    return _asyncToGenerator(function* () {
-      var pendingValues = yield _this71.olmMachine.getSecretsFromInbox(name);
-      for (var value of pendingValues) {
-        if (yield _this71.handleSecretReceived(name, value)) {
-          // If we have a valid secret for that name there is no point of processing the other secrets values.
-          // It's probably the same secret shared by another device.
-          break;
-        }
+  async checkSecrets(name) {
+    const pendingValues = await this.olmMachine.getSecretsFromInbox(name);
+    for (const value of pendingValues) {
+      if (await this.handleSecretReceived(name, value)) {
+        // If we have a valid secret for that name there is no point of processing the other secrets values.
+        // It's probably the same secret shared by another device.
+        break;
       }
+    }
 
-      // Important to call this after handling the secrets as good hygiene.
-      yield _this71.olmMachine.deleteSecretsFromInbox(name);
-    })();
+    // Important to call this after handling the secrets as good hygiene.
+    await this.olmMachine.deleteSecretsFromInbox(name);
   }
 
   /**
@@ -2015,42 +1774,34 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @param event - live event
    */
-  onLiveEventFromSync(event) {
-    var _this72 = this;
-    return _asyncToGenerator(function* () {
-      // Ignore state event or remote echo
-      // transaction_id is provided in case of remote echo {@link https://spec.matrix.org/v1.7/client-server-api/#local-echo}
-      if (event.isState() || !!event.getUnsigned().transaction_id) return;
-      var processEvent = /*#__PURE__*/function () {
-        var _ref8 = _asyncToGenerator(function* (evt) {
-          // Process only verification event
-          if (isVerificationEvent(event)) {
-            yield _this72.onKeyVerificationEvent(evt);
-          }
-        });
-        return function processEvent(_x2) {
-          return _ref8.apply(this, arguments);
-        };
-      }();
-
-      // If the event is encrypted of in failure, we wait for decryption
-      if (event.isDecryptionFailure() || event.isEncrypted()) {
-        // 5 mins
-        var TIMEOUT_DELAY = 5 * 60 * 1000;
-
-        // After 5mins, we are not expecting the event to be decrypted
-        var timeoutId = setTimeout(() => event.off(MatrixEventEvent.Decrypted, onDecrypted), TIMEOUT_DELAY);
-        var onDecrypted = (decryptedEvent, error) => {
-          if (error) return;
-          clearTimeout(timeoutId);
-          event.off(MatrixEventEvent.Decrypted, onDecrypted);
-          processEvent(decryptedEvent);
-        };
-        event.on(MatrixEventEvent.Decrypted, onDecrypted);
-      } else {
-        yield processEvent(event);
+  async onLiveEventFromSync(event) {
+    // Ignore state event or remote echo
+    // transaction_id is provided in case of remote echo {@link https://spec.matrix.org/v1.7/client-server-api/#local-echo}
+    if (event.isState() || !!event.getUnsigned().transaction_id) return;
+    const processEvent = async evt => {
+      // Process only verification event
+      if (isVerificationEvent(event)) {
+        await this.onKeyVerificationEvent(evt);
       }
-    })();
+    };
+
+    // If the event is encrypted of in failure, we wait for decryption
+    if (event.isDecryptionFailure() || event.isEncrypted()) {
+      // 5 mins
+      const TIMEOUT_DELAY = 5 * 60 * 1000;
+
+      // After 5mins, we are not expecting the event to be decrypted
+      const timeoutId = setTimeout(() => event.off(MatrixEventEvent.Decrypted, onDecrypted), TIMEOUT_DELAY);
+      const onDecrypted = (decryptedEvent, error) => {
+        if (error) return;
+        clearTimeout(timeoutId);
+        event.off(MatrixEventEvent.Decrypted, onDecrypted);
+        void processEvent(decryptedEvent);
+      };
+      event.on(MatrixEventEvent.Decrypted, onDecrypted);
+    } else {
+      await processEvent(event);
+    }
   }
 
   /**
@@ -2058,45 +1809,42 @@ export class RustCrypto extends TypedEventEmitter {
    *
    * @param event - a key validation request event.
    */
-  onKeyVerificationEvent(event) {
-    var _this73 = this;
-    return _asyncToGenerator(function* () {
-      var roomId = event.getRoomId();
-      var senderId = event.getSender();
-      if (!roomId) {
-        throw new Error("missing roomId in the event");
-      }
-      if (!senderId) {
-        throw new Error("missing sender in the event");
-      }
-      _this73.logger.debug("Incoming verification event ".concat(event.getId(), " type ").concat(event.getType(), " from ").concat(event.getSender()));
-      var isRoomVerificationRequest = event.getType() === EventType.RoomMessage && event.getContent().msgtype === MsgType.KeyVerificationRequest;
-      if (isRoomVerificationRequest) {
-        // Before processing an in-room verification request, we need to
-        // make sure we have the sender's device information - otherwise we
-        // will immediately abort verification. So we explicitly fetch it
-        // from /keys/query and wait for that request to complete before we
-        // call receiveVerificationEvent.
-        var req = _this73.getOlmMachineOrThrow().queryKeysForUsers([new RustSdkCryptoJs.UserId(senderId)]);
-        yield _this73.outgoingRequestProcessor.makeOutgoingRequest(req);
-      }
-      yield _this73.getOlmMachineOrThrow().receiveVerificationEvent(JSON.stringify({
-        event_id: event.getId(),
-        type: event.getType(),
-        sender: senderId,
-        state_key: event.getStateKey(),
-        content: event.getContent(),
-        origin_server_ts: event.getTs()
-      }), new RustSdkCryptoJs.RoomId(roomId));
-      if (isRoomVerificationRequest) {
-        _this73.onIncomingKeyVerificationRequest(senderId, event.getId());
-      }
+  async onKeyVerificationEvent(event) {
+    const roomId = event.getRoomId();
+    const senderId = event.getSender();
+    if (!roomId) {
+      throw new Error("missing roomId in the event");
+    }
+    if (!senderId) {
+      throw new Error("missing sender in the event");
+    }
+    this.logger.debug(`Incoming verification event ${event.getId()} type ${event.getType()} from ${event.getSender()}`);
+    const isRoomVerificationRequest = event.getType() === EventType.RoomMessage && event.getContent().msgtype === MsgType.KeyVerificationRequest;
+    if (isRoomVerificationRequest) {
+      // Before processing an in-room verification request, we need to
+      // make sure we have the sender's device information - otherwise we
+      // will immediately abort verification. So we explicitly fetch it
+      // from /keys/query and wait for that request to complete before we
+      // call receiveVerificationEvent.
+      const req = this.getOlmMachineOrThrow().queryKeysForUsers([new RustSdkCryptoJs.UserId(senderId)]);
+      await this.outgoingRequestProcessor.makeOutgoingRequest(req);
+    }
+    await this.getOlmMachineOrThrow().receiveVerificationEvent(JSON.stringify({
+      event_id: event.getId(),
+      type: event.getType(),
+      sender: senderId,
+      state_key: event.getStateKey(),
+      content: event.getContent(),
+      origin_server_ts: event.getTs()
+    }), new RustSdkCryptoJs.RoomId(roomId));
+    if (isRoomVerificationRequest) {
+      this.onIncomingKeyVerificationRequest(senderId, event.getId());
+    }
 
-      // that may have caused us to queue up outgoing requests, so make sure we send them.
-      _this73.outgoingRequestsManager.doProcessOutgoingRequests().catch(e => {
-        _this73.logger.warn("onKeyVerificationRequest: Error processing outgoing requests", e);
-      });
-    })();
+    // that may have caused us to queue up outgoing requests, so make sure we send them.
+    this.outgoingRequestsManager.doProcessOutgoingRequests().catch(e => {
+      this.logger.warn("onKeyVerificationRequest: Error processing outgoing requests", e);
+    });
   }
 
   /**
@@ -2105,79 +1853,69 @@ export class RustCrypto extends TypedEventEmitter {
    * Not part of the public crypto-api interface.
    * Used during migration from legacy js-crypto to update local trust if needed.
    */
-  getOwnIdentity() {
-    var _this74 = this;
-    return _asyncToGenerator(function* () {
-      var identity = yield _this74.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(_this74.userId));
-      return identity;
-    })();
+  async getOwnIdentity() {
+    const identity = await this.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(this.userId));
+    return identity;
   }
 
   /**
    * Push a secret to all of the current user's verified devices.
    */
-  pushSecretToVerifiedDevices(name) {
-    var _this75 = this;
-    return _asyncToGenerator(function* () {
-      var logger = new LogSpan(_this75.logger, "pushSecretToVerifiedDevices");
-      yield _this75.keyClaimManager.ensureSessionsForUsers(logger, [new RustSdkCryptoJs.UserId(_this75.userId)]);
-      yield _this75.olmMachine.pushSecretToVerifiedDevices(name);
-      _this75.outgoingRequestsManager.doProcessOutgoingRequests().catch(e => {
-        logger.warn("pushSecretToVerifiedDevices: Error processing outgoing requests", e);
-      });
-    })();
+  async pushSecretToVerifiedDevices(name) {
+    const logger = new LogSpan(this.logger, "pushSecretToVerifiedDevices");
+    await this.keyClaimManager.ensureSessionsForUsers(logger, [new RustSdkCryptoJs.UserId(this.userId)]);
+    await this.olmMachine.pushSecretToVerifiedDevices(name);
+    this.outgoingRequestsManager.doProcessOutgoingRequests().catch(e => {
+      logger.warn("pushSecretToVerifiedDevices: Error processing outgoing requests", e);
+    });
   }
 }
 class EventDecryptor {
   constructor(logger, olmMachine, perSessionBackupDownloader) {
-    this.logger = logger;
-    this.olmMachine = olmMachine;
-    this.perSessionBackupDownloader = perSessionBackupDownloader;
     /**
      * Events which we couldn't decrypt due to unknown sessions / indexes.
      *
      * Map from roomId to sessionId to Set of MatrixEvents
      */
     _defineProperty(this, "eventsPendingKey", new MapWithDefault(() => new MapWithDefault(() => new Set())));
+    this.logger = logger;
+    this.olmMachine = olmMachine;
+    this.perSessionBackupDownloader = perSessionBackupDownloader;
   }
-  attemptEventDecryption(event, isolationMode) {
-    var _this76 = this;
-    return _asyncToGenerator(function* () {
-      // add the event to the pending list *before* attempting to decrypt.
-      // then, if the key turns up while decryption is in progress (and
-      // decryption fails), we will schedule a retry.
-      // (fixes https://github.com/vector-im/element-web/issues/5001)
-      _this76.addEventToPendingList(event);
-      var trustRequirement;
-      switch (isolationMode.kind) {
-        case DeviceIsolationModeKind.AllDevicesIsolationMode:
-          trustRequirement = RustSdkCryptoJs.TrustRequirement.Untrusted;
-          break;
-        case DeviceIsolationModeKind.OnlySignedDevicesIsolationMode:
-          trustRequirement = RustSdkCryptoJs.TrustRequirement.CrossSignedOrLegacy;
-          break;
-      }
-      try {
-        var _res$forwarder;
-        var res = yield _this76.olmMachine.decryptRoomEvent(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()), new RustSdkCryptoJs.DecryptionSettings(trustRequirement));
-
-        // Success. We can remove the event from the pending list, if
-        // that hasn't already happened.
-        _this76.removeEventFromPendingList(event);
-        return {
-          clearEvent: JSON.parse(res.event),
-          claimedEd25519Key: res.senderClaimedEd25519Key,
-          senderCurve25519Key: res.senderCurve25519Key,
-          keyForwardedBy: (_res$forwarder = res.forwarder) === null || _res$forwarder === void 0 ? void 0 : _res$forwarder.toString()
-        };
-      } catch (err) {
-        if (err instanceof RustSdkCryptoJs.MegolmDecryptionError) {
-          _this76.onMegolmDecryptionError(event, err, yield _this76.perSessionBackupDownloader.getServerBackupInfo());
-        } else {
-          throw new DecryptionError(DecryptionFailureCode.UNKNOWN_ERROR, "Unknown error");
-        }
+  async attemptEventDecryption(event, isolationMode) {
+    // add the event to the pending list *before* attempting to decrypt.
+    // then, if the key turns up while decryption is in progress (and
+    // decryption fails), we will schedule a retry.
+    // (fixes https://github.com/vector-im/element-web/issues/5001)
+    this.addEventToPendingList(event);
+    let trustRequirement;
+    switch (isolationMode.kind) {
+      case DeviceIsolationModeKind.AllDevicesIsolationMode:
+        trustRequirement = RustSdkCryptoJs.TrustRequirement.Untrusted;
+        break;
+      case DeviceIsolationModeKind.OnlySignedDevicesIsolationMode:
+        trustRequirement = RustSdkCryptoJs.TrustRequirement.CrossSignedOrLegacy;
+        break;
+    }
+    try {
+      const res = await this.olmMachine.decryptRoomEvent(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()), new RustSdkCryptoJs.DecryptionSettings(trustRequirement));
+
+      // Success. We can remove the event from the pending list, if
+      // that hasn't already happened.
+      this.removeEventFromPendingList(event);
+      return {
+        clearEvent: JSON.parse(res.event),
+        claimedEd25519Key: res.senderClaimedEd25519Key,
+        senderCurve25519Key: res.senderCurve25519Key,
+        keyForwardedBy: res.forwarder?.toString()
+      };
+    } catch (err) {
+      if (err instanceof RustSdkCryptoJs.MegolmDecryptionError) {
+        this.onMegolmDecryptionError(event, err, await this.perSessionBackupDownloader.getServerBackupInfo());
+      } else {
+        throw new DecryptionError(DecryptionFailureCode.UNKNOWN_ERROR, "Unknown error");
       }
-    })();
+    }
   }
 
   /**
@@ -2191,8 +1929,8 @@ class EventDecryptor {
    *     `undefined` if our attempt to check failed.
    */
   onMegolmDecryptionError(event, err, serverBackupInfo) {
-    var content = event.getWireContent();
-    var errorDetails = {
+    const content = event.getWireContent();
+    const errorDetails = {
       sender_key: content.sender_key,
       session_id: content.session_id
     };
@@ -2203,7 +1941,7 @@ class EventDecryptor {
 
       // If the server is telling us our membership at the time the event
       // was sent, and it isn't "join", we use a different error code.
-      var membership = event.getMembershipAtEvent();
+      const membership = event.getMembershipAtEvent();
       if (membership && membership !== KnownMembership.Join && membership !== KnownMembership.Invite) {
         throw new DecryptionError(DecryptionFailureCode.HISTORICAL_MESSAGE_USER_NOT_JOINED, "This message was sent when we were not a member of the room.", errorDetails);
       }
@@ -2224,7 +1962,7 @@ class EventDecryptor {
     if (err.maybe_withheld) {
       // Unfortunately the Rust SDK API doesn't let us distinguish between different withheld cases, other than
       // by string-matching.
-      var failureCode = err.maybe_withheld === "The sender has disabled encrypting to unverified devices." ? DecryptionFailureCode.MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE : DecryptionFailureCode.MEGOLM_KEY_WITHHELD;
+      const failureCode = err.maybe_withheld === "The sender has disabled encrypting to unverified devices." ? DecryptionFailureCode.MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE : DecryptionFailureCode.MEGOLM_KEY_WITHHELD;
       throw new DecryptionError(failureCode, err.maybe_withheld, errorDetails);
     }
     switch (err.code) {
@@ -2257,24 +1995,21 @@ class EventDecryptor {
         throw new DecryptionError(DecryptionFailureCode.UNKNOWN_ERROR, err.description, errorDetails);
     }
   }
-  getEncryptionInfoForEvent(event) {
-    var _this77 = this;
-    return _asyncToGenerator(function* () {
-      if (!event.getClearContent() || event.isDecryptionFailure()) {
-        // not successfully decrypted
-        return null;
-      }
+  async getEncryptionInfoForEvent(event) {
+    if (!event.getClearContent() || event.isDecryptionFailure()) {
+      // not successfully decrypted
+      return null;
+    }
 
-      // special-case outgoing events, which the rust crypto-sdk will barf on
-      if (event.status !== null) {
-        return {
-          shieldColour: EventShieldColour.NONE,
-          shieldReason: null
-        };
-      }
-      var encryptionInfo = yield _this77.olmMachine.getRoomEventEncryptionInfo(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()));
-      return rustEncryptionInfoToJsEncryptionInfo(_this77.logger, encryptionInfo);
-    })();
+    // special-case outgoing events, which the rust crypto-sdk will barf on
+    if (event.status !== null) {
+      return {
+        shieldColour: EventShieldColour.NONE,
+        shieldReason: null
+      };
+    }
+    const encryptionInfo = await this.olmMachine.getRoomEventEncryptionInfo(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()));
+    return rustEncryptionInfoToJsEncryptionInfo(this.logger, encryptionInfo);
   }
 
   /**
@@ -2283,9 +2018,9 @@ class EventDecryptor {
    * Returns a list of events which were encrypted by `session` and could not be decrypted
    */
   getEventsPendingRoomKey(roomId, sessionId) {
-    var roomPendingEvents = this.eventsPendingKey.get(roomId);
+    const roomPendingEvents = this.eventsPendingKey.get(roomId);
     if (!roomPendingEvents) return [];
-    var sessionPendingEvents = roomPendingEvents.get(sessionId);
+    const sessionPendingEvents = roomPendingEvents.get(sessionId);
     if (!sessionPendingEvents) return [];
     return [...sessionPendingEvents];
   }
@@ -2294,11 +2029,11 @@ class EventDecryptor {
    * Add an event to the list of those awaiting their session keys.
    */
   addEventToPendingList(event) {
-    var roomId = event.getRoomId();
+    const roomId = event.getRoomId();
     // We shouldn't have events without a room id here.
     if (!roomId) return;
-    var roomPendingEvents = this.eventsPendingKey.getOrCreate(roomId);
-    var sessionPendingEvents = roomPendingEvents.getOrCreate(event.getWireContent().session_id);
+    const roomPendingEvents = this.eventsPendingKey.getOrCreate(roomId);
+    const sessionPendingEvents = roomPendingEvents.getOrCreate(event.getWireContent().session_id);
     sessionPendingEvents.add(event);
   }
 
@@ -2306,11 +2041,11 @@ class EventDecryptor {
    * Remove an event from the list of those awaiting their session keys.
    */
   removeEventFromPendingList(event) {
-    var roomId = event.getRoomId();
+    const roomId = event.getRoomId();
     if (!roomId) return;
-    var roomPendingEvents = this.eventsPendingKey.getOrCreate(roomId);
+    const roomPendingEvents = this.eventsPendingKey.getOrCreate(roomId);
     if (!roomPendingEvents) return;
-    var sessionPendingEvents = roomPendingEvents.get(event.getWireContent().session_id);
+    const sessionPendingEvents = roomPendingEvents.get(event.getWireContent().session_id);
     if (!sessionPendingEvents) return;
     sessionPendingEvents.delete(event);
 
@@ -2340,8 +2075,8 @@ function rustEncryptionInfoToJsEncryptionInfo(logger, encryptionInfo) {
   }
 
   // TODO: use strict shield semantics.
-  var shieldState = encryptionInfo.shieldState(false);
-  var shieldColour;
+  const shieldState = encryptionInfo.shieldState(false);
+  let shieldColour;
   switch (shieldState.color) {
     case RustSdkCryptoJs.ShieldColor.Grey:
       shieldColour = EventShieldColour.GREY;
@@ -2352,7 +2087,7 @@ function rustEncryptionInfoToJsEncryptionInfo(logger, encryptionInfo) {
     default:
       shieldColour = EventShieldColour.RED;
   }
-  var shieldReason;
+  let shieldReason;
   switch (shieldState.code) {
     case undefined:
     case null: