@openclaw/matrix 2026.7.1-beta.1 → 2026.7.1-beta.4

package/node_modules/matrix-js-sdk/lib/rust-crypto/backup.js

@@ -1,5 +1,3 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /*
 Copyright 2023 - 2024 The Matrix.org Foundation C.I.C.
@@ -51,11 +49,13 @@ export class RustBackupManager extends TypedEventEmitter {
     _defineProperty(this, "stopped", false);
     /** whether {@link backupKeysLoop} is currently running */
     _defineProperty(this, "backupKeysLoopRunning", false);
+    /** The logger to use */
+    _defineProperty(this, "logger", void 0);
     _defineProperty(this, "keyBackupCheckInProgress", null);
-    this.logger = logger;
     this.olmMachine = olmMachine;
     this.http = http;
     this.outgoingRequestProcessor = outgoingRequestProcessor;
+    this.logger = logger.getChild("[RustBackupManager]");
   }
 
   /**
@@ -70,12 +70,9 @@ export class RustBackupManager extends TypedEventEmitter {
   /**
    * Get the backup version we are currently backing up to, if any
    */
-  getActiveBackupVersion() {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      if (!(yield _this.olmMachine.isBackupEnabled())) return null;
-      return _this.activeBackupVersion;
-    })();
+  async getActiveBackupVersion() {
+    if (!(await this.olmMachine.isBackupEnabled())) return null;
+    return this.activeBackupVersion;
   }
 
   /**
@@ -86,14 +83,11 @@ export class RustBackupManager extends TypedEventEmitter {
    *
    * If there was no backup on the server, `null`. If our attempt to check resulted in an error, `undefined`.
    */
-  getServerBackupInfo() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      // Do a validity check if we haven't already done one. The check is likely to fail if we don't yet have the
-      // backup keys -- but as a side-effect, it will populate `serverBackupInfo`.
-      yield _this2.checkKeyBackupAndEnable(false);
-      return _this2.serverBackupInfo;
-    })();
+  async getServerBackupInfo() {
+    // Do a validity check if we haven't already done one. The check is likely to fail if we don't yet have the
+    // backup keys -- but as a side-effect, it will populate `serverBackupInfo`.
+    await this.checkKeyBackupAndEnable(false);
+    return this.serverBackupInfo;
   }
 
   /**
@@ -101,24 +95,22 @@ export class RustBackupManager extends TypedEventEmitter {
    *
    * @param info - key backup info dict from {@link CryptoApi.getKeyBackupInfo}.
    */
-  isKeyBackupTrusted(info) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      var signatureVerification = yield _this3.olmMachine.verifyBackup(info);
-      var backupKeys = yield _this3.olmMachine.getBackupKeys();
-      var decryptionKey = backupKeys === null || backupKeys === void 0 ? void 0 : backupKeys.decryptionKey;
-      var backupMatchesSavedPrivateKey = !!decryptionKey && _this3.backupInfoMatchesBackupDecryptionKey(info, decryptionKey);
-      return {
-        matchesDecryptionKey: backupMatchesSavedPrivateKey,
-        trusted: signatureVerification.trusted()
-      };
-    })();
+  async isKeyBackupTrusted(info) {
+    const signatureVerification = await this.olmMachine.verifyBackup(info);
+    const backupKeys = await this.olmMachine.getBackupKeys();
+    const decryptionKey = backupKeys?.decryptionKey;
+    const backupMatchesSavedPrivateKey = !!decryptionKey && this.backupInfoMatchesBackupDecryptionKey(info, decryptionKey);
+    return {
+      matchesDecryptionKey: backupMatchesSavedPrivateKey,
+      trusted: signatureVerification.trusted()
+    };
   }
 
   /**
    * Re-check the key backup and enable/disable it as appropriate.
    *
-   * @param force - whether we should force a re-check even if one has already happened.
+   * @param force - whether we should force a re-check even if one has already happened. If this is
+   *   `false`, and we have already done a check, `null` is returned rather than the actual info on the key backup.
    */
   checkKeyBackupAndEnable(force) {
     if (!force && this.checkedForBackup) {
@@ -137,69 +129,68 @@ export class RustBackupManager extends TypedEventEmitter {
   /**
    * Handles a backup secret received event and store it if it matches the current backup version.
    *
+   * Also enables key backup upload if it was not previously enabled, and the encryption key matches the received
+   * decryption key.
+   *
    * @param secret - The secret as received from a `m.secret.send` or `io.element.msc4385.secret.push` event for secret `m.megolm_backup.v1`.
    * @returns true if the secret is valid and has been stored, false otherwise.
    */
-  handleBackupSecretReceived(secret) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      var _latestBackupInfo;
-      // Currently we only receive the decryption key without any key backup version. It is important to
-      // check that the secret is valid for the current version before storing it.
-      // We force a check to ensure to have the latest version.
-      var latestBackupInfo;
-      try {
-        latestBackupInfo = yield _this4.requestKeyBackupVersion();
-      } catch (e) {
-        _this4.logger.warn("handleBackupSecretReceived: Error checking for latest key backup", e);
-        return false;
-      }
-      if (!((_latestBackupInfo = latestBackupInfo) !== null && _latestBackupInfo !== void 0 && _latestBackupInfo.version)) {
-        // There is no server-side key backup.
-        // This decryption key is useless to us.
-        _this4.logger.warn("handleBackupSecretReceived: Received a backup decryption key, but there is no server-side key backup");
-        return false;
-      }
-      var backupDecryptionKey;
-      try {
-        backupDecryptionKey = RustSdkCryptoJs.BackupDecryptionKey.fromBase64(secret);
-      } catch (e) {
-        _this4.logger.warn("handleBackupSecretReceived: Invalid backup decryption key", e);
+  async handleBackupSecretReceived(secret) {
+    // Currently we only receive the decryption key without any key backup version. It is important to
+    // check that the secret is valid for the current version before storing it.
+    // We force a check to ensure to have the latest version.
+    let latestBackupInfo;
+    try {
+      latestBackupInfo = await this.requestKeyBackupVersion();
+    } catch (e) {
+      this.logger.warn("handleBackupSecretReceived: Error checking for latest key backup", e);
+      return false;
+    }
+    if (!latestBackupInfo?.version) {
+      // There is no server-side key backup.
+      // This decryption key is useless to us.
+      this.logger.warn("handleBackupSecretReceived: Received a backup decryption key, but there is no server-side key backup");
+      return false;
+    }
+    let backupDecryptionKey;
+    try {
+      backupDecryptionKey = RustSdkCryptoJs.BackupDecryptionKey.fromBase64(secret);
+    } catch (e) {
+      this.logger.warn("handleBackupSecretReceived: Invalid backup decryption key", e);
+      return false;
+    }
+    try {
+      const privateKeyMatches = this.backupInfoMatchesBackupDecryptionKey(latestBackupInfo, backupDecryptionKey);
+      if (!privateKeyMatches) {
+        this.logger.warn(`handleBackupSecretReceived: Private decryption key does not match the public key of the current server-side backup version (${latestBackupInfo.version})`);
+        // just ignore the secret
         return false;
       }
-      try {
-        var privateKeyMatches = _this4.backupInfoMatchesBackupDecryptionKey(latestBackupInfo, backupDecryptionKey);
-        if (!privateKeyMatches) {
-          _this4.logger.warn("handleBackupSecretReceived: Private decryption key does not match the public key of the current server-side backup version (".concat(latestBackupInfo.version, ")"));
-          // just ignore the secret
-          return false;
-        }
-        _this4.logger.info("handleBackupSecretReceived: Valid decryption key for the current server-side backup version (".concat(latestBackupInfo.version, ") received"));
-        yield _this4.saveBackupDecryptionKey(backupDecryptionKey, latestBackupInfo.version);
-        // Check if the backup should be enabled (e.g. if it's properly
-        // signed), and enable it if it should
-        if (_this4.keyBackupCheckInProgress) {
-          yield _this4.keyBackupCheckInProgress;
-        }
-        _this4.keyBackupCheckInProgress = _this4.doCheckKeyBackup(latestBackupInfo).finally(() => {
-          _this4.keyBackupCheckInProgress = null;
-        });
-        yield _this4.keyBackupCheckInProgress;
-        return true;
-      } catch (e) {
-        _this4.logger.warn("handleBackupSecretReceived: Unable to validate backup decryption key", e);
+      this.logger.info(`handleBackupSecretReceived: Valid decryption key for the current server-side backup version (${latestBackupInfo.version}) received`);
+      await this.saveBackupDecryptionKey(backupDecryptionKey, latestBackupInfo.version);
+
+      // Check if backup upload should be enabled (e.g. the encryption key matches the decryption key),
+      // and enable it if so.
+      if (this.keyBackupCheckInProgress) {
+        this.logger.debug("handleBackupSecretReceived: waiting for ongoing keybackup check to complete");
+        await this.keyBackupCheckInProgress;
       }
-      return false;
-    })();
+      this.logger.debug("handleBackupSecretReceived: checking if we can enable keybackup upload");
+      this.keyBackupCheckInProgress = this.doCheckKeyBackup(latestBackupInfo).finally(() => {
+        this.keyBackupCheckInProgress = null;
+      });
+      await this.keyBackupCheckInProgress;
+      return true;
+    } catch (e) {
+      this.logger.warn("handleBackupSecretReceived: Unable to validate backup decryption key", e);
+    }
+    return false;
   }
-  saveBackupDecryptionKey(backupDecryptionKey, version) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      yield _this5.olmMachine.saveBackupDecryptionKey(backupDecryptionKey, version);
-      // Emit an event that we have a new backup decryption key, so that the sdk can start
-      // importing keys from backup if needed.
-      _this5.emit(CryptoEvent.KeyBackupDecryptionKeyCached, version);
-    })();
+  async saveBackupDecryptionKey(backupDecryptionKey, version) {
+    await this.olmMachine.saveBackupDecryptionKey(backupDecryptionKey, version);
+    // Emit an event that we have a new backup decryption key, so that the sdk can start
+    // importing keys from backup if needed.
+    this.emit(CryptoEvent.KeyBackupDecryptionKeyCached, version);
   }
 
   /**
@@ -209,11 +200,8 @@ export class RustBackupManager extends TypedEventEmitter {
    * @param opts - options object
    * @returns a promise which resolves once the keys have been imported
    */
-  importRoomKeys(keys, opts) {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      yield _this6.importRoomKeysAsJson(JSON.stringify(keys), opts);
-    })();
+  async importRoomKeys(keys, opts) {
+    await this.importRoomKeysAsJson(JSON.stringify(keys), opts);
   }
 
   /**
@@ -224,125 +212,111 @@ export class RustBackupManager extends TypedEventEmitter {
    * @param opts - options object
    * @returns a promise which resolves once the keys have been imported
    */
-  importRoomKeysAsJson(jsonKeys, opts) {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      yield _this7.olmMachine.importExportedRoomKeys(jsonKeys, (progress, total) => {
-        var _opts$progressCallbac;
-        var importOpt = {
-          total: Number(total),
-          successes: Number(progress),
-          stage: ImportRoomKeyStage.LoadKeys,
-          failures: 0
-        };
-        opts === null || opts === void 0 || (_opts$progressCallbac = opts.progressCallback) === null || _opts$progressCallbac === void 0 || _opts$progressCallbac.call(opts, importOpt);
-      });
-    })();
+  async importRoomKeysAsJson(jsonKeys, opts) {
+    await this.olmMachine.importExportedRoomKeys(jsonKeys, (progress, total) => {
+      const importOpt = {
+        total: Number(total),
+        successes: Number(progress),
+        stage: ImportRoomKeyStage.LoadKeys,
+        failures: 0
+      };
+      opts?.progressCallback?.(importOpt);
+    });
   }
 
   /**
    * Implementation of {@link CryptoBackend#importBackedUpRoomKeys}.
    */
-  importBackedUpRoomKeys(keys, backupVersion, opts) {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      var keysByRoom = new Map();
-      for (var key of keys) {
-        var roomId = new RustSdkCryptoJs.RoomId(key.room_id);
-        if (!keysByRoom.has(roomId)) {
-          keysByRoom.set(roomId, new Map());
-        }
-        keysByRoom.get(roomId).set(key.session_id, key);
+  async importBackedUpRoomKeys(keys, backupVersion, opts) {
+    const keysByRoom = new Map();
+    for (const key of keys) {
+      const roomId = new RustSdkCryptoJs.RoomId(key.room_id);
+      if (!keysByRoom.has(roomId)) {
+        keysByRoom.set(roomId, new Map());
       }
-      yield _this8.olmMachine.importBackedUpRoomKeys(keysByRoom, (progress, total, failures) => {
-        var _opts$progressCallbac2;
-        var importOpt = {
-          total: Number(total),
-          successes: Number(progress),
-          stage: ImportRoomKeyStage.LoadKeys,
-          failures: Number(failures)
-        };
-        opts === null || opts === void 0 || (_opts$progressCallbac2 = opts.progressCallback) === null || _opts$progressCallbac2 === void 0 || _opts$progressCallbac2.call(opts, importOpt);
-      }, backupVersion);
-    })();
+      keysByRoom.get(roomId).set(key.session_id, key);
+    }
+    await this.olmMachine.importBackedUpRoomKeys(keysByRoom, (progress, total, failures) => {
+      const importOpt = {
+        total: Number(total),
+        successes: Number(progress),
+        stage: ImportRoomKeyStage.LoadKeys,
+        failures: Number(failures)
+      };
+      opts?.progressCallback?.(importOpt);
+    }, backupVersion);
   }
   /** Helper to check the key backup status, and enable/disable it as appropriate
    *
    * A KeyBackupInfo can be passed if it was fetched recently, to avoid trying to
    * re-fetch it from the server.
    */
-  doCheckKeyBackup(backupInfo) {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      _this9.logger.debug("Checking key backup status...");
-      try {
-        if (!backupInfo) {
-          backupInfo = yield _this9.requestKeyBackupVersion();
-        }
-      } catch (e) {
-        _this9.logger.warn("Error checking for active key backup", e);
-        _this9.serverBackupInfo = undefined;
-        return null;
+  async doCheckKeyBackup(backupInfo) {
+    this.logger.debug("Checking key backup status...");
+    try {
+      if (!backupInfo) {
+        backupInfo = await this.requestKeyBackupVersion();
       }
-      _this9.checkedForBackup = true;
-      if (backupInfo && !backupInfo.version) {
-        _this9.logger.warn("active backup lacks a useful 'version'; ignoring it");
-        backupInfo = undefined;
+    } catch (e) {
+      this.logger.warn("Error checking for active key backup", e);
+      this.serverBackupInfo = undefined;
+      return null;
+    }
+    this.checkedForBackup = true;
+    if (backupInfo && !backupInfo.version) {
+      this.logger.warn("active backup lacks a useful 'version'; ignoring it");
+      backupInfo = undefined;
+    }
+    this.serverBackupInfo = backupInfo;
+    const activeVersion = await this.getActiveBackupVersion();
+    if (!backupInfo) {
+      if (activeVersion !== null) {
+        this.logger.debug("No key backup present on server: disabling key backup");
+        await this.disableKeyBackup();
+      } else {
+        this.logger.debug("No key backup present on server: not enabling key backup");
       }
-      _this9.serverBackupInfo = backupInfo;
-      var activeVersion = yield _this9.getActiveBackupVersion();
-      if (!backupInfo) {
-        if (activeVersion !== null) {
-          _this9.logger.debug("No key backup present on server: disabling key backup");
-          yield _this9.disableKeyBackup();
-        } else {
-          _this9.logger.debug("No key backup present on server: not enabling key backup");
-        }
-        return null;
+      return null;
+    }
+    const trustInfo = await this.isKeyBackupTrusted(backupInfo);
+
+    // Per the spec, we should enable key upload if either (a) the backup is signed by a trusted key, or
+    // (b) the public key matches the private decryption key that we have received from 4S.
+    if (!trustInfo.matchesDecryptionKey && !trustInfo.trusted) {
+      if (activeVersion !== null) {
+        this.logger.debug("Key backup present on server but not trusted: disabling key backup");
+        await this.disableKeyBackup();
+      } else {
+        this.logger.debug("Key backup present on server but not trusted: not enabling key backup");
       }
-      var trustInfo = yield _this9.isKeyBackupTrusted(backupInfo);
-
-      // Per the spec, we should enable key upload if either (a) the backup is signed by a trusted key, or
-      // (b) the public key matches the private decryption key that we have received from 4S.
-      if (!trustInfo.matchesDecryptionKey && !trustInfo.trusted) {
-        if (activeVersion !== null) {
-          _this9.logger.debug("Key backup present on server but not trusted: disabling key backup");
-          yield _this9.disableKeyBackup();
-        } else {
-          _this9.logger.debug("Key backup present on server but not trusted: not enabling key backup");
-        }
+    } else {
+      if (activeVersion === null) {
+        this.logger.debug(`Found usable key backup v${backupInfo.version}: enabling key backups`);
+        await this.enableKeyBackup(backupInfo);
+      } else if (activeVersion !== backupInfo.version) {
+        this.logger.debug(`On backup version ${activeVersion} but found version ${backupInfo.version}: switching.`);
+        // This will remove any pending backup request, remove the backup key and reset the backup state of each room key we have.
+        await this.disableKeyBackup();
+        // Enabling will now trigger re-upload of all the keys
+        await this.enableKeyBackup(backupInfo);
       } else {
-        if (activeVersion === null) {
-          _this9.logger.debug("Found usable key backup v".concat(backupInfo.version, ": enabling key backups"));
-          yield _this9.enableKeyBackup(backupInfo);
-        } else if (activeVersion !== backupInfo.version) {
-          _this9.logger.debug("On backup version ".concat(activeVersion, " but found version ").concat(backupInfo.version, ": switching."));
-          // This will remove any pending backup request, remove the backup key and reset the backup state of each room key we have.
-          yield _this9.disableKeyBackup();
-          // Enabling will now trigger re-upload of all the keys
-          yield _this9.enableKeyBackup(backupInfo);
-        } else {
-          _this9.logger.debug("Backup version ".concat(backupInfo.version, " still current"));
-        }
+        this.logger.debug(`Backup version ${backupInfo.version} still current`);
       }
-      return {
-        backupInfo,
-        trustInfo
-      };
-    })();
-  }
-  enableKeyBackup(backupInfo) {
-    var _this0 = this;
-    return _asyncToGenerator(function* () {
-      // we know for certain it must be a Curve25519 key, because we have verified it and only Curve25519
-      // keys can be verified.
-      //
-      // we also checked it has a valid `version`.
-      yield _this0.olmMachine.enableBackupV1(backupInfo.auth_data.public_key, backupInfo.version);
-      _this0.activeBackupVersion = backupInfo.version;
-      _this0.emit(CryptoEvent.KeyBackupStatus, true);
-      _this0.backupKeysLoop();
-    })();
+    }
+    return {
+      backupInfo,
+      trustInfo
+    };
+  }
+  async enableKeyBackup(backupInfo) {
+    // we know for certain it must be a Curve25519 key, because we have verified it and only Curve25519
+    // keys can be verified.
+    //
+    // we also checked it has a valid `version`.
+    await this.olmMachine.enableBackupV1(backupInfo.auth_data.public_key, backupInfo.version);
+    this.activeBackupVersion = backupInfo.version;
+    this.emit(CryptoEvent.KeyBackupStatus, true);
+    this.backupKeysLoop();
   }
 
   /**
@@ -350,139 +324,128 @@ export class RustBackupManager extends TypedEventEmitter {
    * Doesn't try to check the backup server side. To be called when a new
    * megolm key is known locally.
    */
-  maybeUploadKey() {
-    var _this1 = this;
-    return _asyncToGenerator(function* () {
-      if (_this1.activeBackupVersion != null) {
-        _this1.backupKeysLoop();
-      }
-    })();
-  }
-  disableKeyBackup() {
-    var _this10 = this;
-    return _asyncToGenerator(function* () {
-      yield _this10.olmMachine.disableBackup();
-      _this10.activeBackupVersion = null;
-      _this10.emit(CryptoEvent.KeyBackupStatus, false);
-    })();
-  }
-  backupKeysLoop() {
-    var _arguments = arguments,
-      _this11 = this;
-    return _asyncToGenerator(function* () {
-      var maxDelay = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : 10000;
-      if (_this11.backupKeysLoopRunning) {
-        _this11.logger.debug("Backup loop already running");
-        return;
-      }
-      _this11.backupKeysLoopRunning = true;
-      _this11.logger.debug("Backup: Starting keys upload loop for backup version:".concat(_this11.activeBackupVersion, "."));
-
-      // wait between 0 and `maxDelay` seconds, to avoid backup
-      // requests from different clients hitting the server all at
-      // the same time when a new key is sent
-      var delay = Math.random() * maxDelay;
-      yield sleep(delay);
-      try {
-        // number of consecutive network failures for exponential backoff
-        var numFailures = 0;
-        // The number of keys left to back up. (Populated lazily: see more comments below.)
-        var remainingToUploadCount = null;
-        // To avoid computing the key when only a few keys were added (after a sync for example),
-        // we compute the count only when at least two iterations are needed.
-        var isFirstIteration = true;
-        while (!_this11.stopped) {
-          // Get a batch of room keys to upload
-          var request = undefined;
-          try {
-            request = yield logDuration(_this11.logger, "BackupRoomKeys: Get keys to backup from rust crypto-sdk", /*#__PURE__*/_asyncToGenerator(function* () {
-              return yield _this11.olmMachine.backupRoomKeys();
-            }));
-          } catch (err) {
-            _this11.logger.error("Backup: Failed to get keys to backup from rust crypto-sdk", err);
+  async maybeUploadKey() {
+    if (this.activeBackupVersion != null) {
+      this.backupKeysLoop();
+    }
+  }
+  async disableKeyBackup() {
+    await this.olmMachine.disableBackup();
+    this.activeBackupVersion = null;
+    this.emit(CryptoEvent.KeyBackupStatus, false);
+  }
+  async backupKeysLoop(maxDelay = 10000) {
+    if (this.backupKeysLoopRunning) {
+      this.logger.debug(`Backup loop already running`);
+      return;
+    }
+    this.backupKeysLoopRunning = true;
+    this.logger.debug(`Backup: Starting keys upload loop for backup version:${this.activeBackupVersion}.`);
+
+    // wait between 0 and `maxDelay` seconds, to avoid backup
+    // requests from different clients hitting the server all at
+    // the same time when a new key is sent
+    const delay = Math.random() * maxDelay;
+    await sleep(delay);
+    try {
+      // number of consecutive network failures for exponential backoff
+      let numFailures = 0;
+      // The number of keys left to back up. (Populated lazily: see more comments below.)
+      let remainingToUploadCount = null;
+      // To avoid computing the key when only a few keys were added (after a sync for example),
+      // we compute the count only when at least two iterations are needed.
+      let isFirstIteration = true;
+      while (!this.stopped) {
+        // Get a batch of room keys to upload
+        let request = undefined;
+        try {
+          request = await logDuration(this.logger, "BackupRoomKeys: Get keys to backup from rust crypto-sdk", async () => {
+            return await this.olmMachine.backupRoomKeys();
+          });
+        } catch (err) {
+          this.logger.error("Backup: Failed to get keys to backup from rust crypto-sdk", err);
+        }
+        if (!request || this.stopped || !this.activeBackupVersion) {
+          this.logger.debug(`Backup: Ending loop for version ${this.activeBackupVersion}.`);
+          if (!request) {
+            // nothing more to upload
+            this.emit(CryptoEvent.KeyBackupSessionsRemaining, 0);
           }
-          if (!request || _this11.stopped || !_this11.activeBackupVersion) {
-            _this11.logger.debug("Backup: Ending loop for version ".concat(_this11.activeBackupVersion, "."));
-            if (!request) {
-              // nothing more to upload
-              _this11.emit(CryptoEvent.KeyBackupSessionsRemaining, 0);
+          return;
+        }
+        try {
+          await this.outgoingRequestProcessor.makeOutgoingRequest(request);
+          numFailures = 0;
+          if (this.stopped) break;
+
+          // Key count performance (`olmMachine.roomKeyCounts()`) can be pretty bad on some configurations.
+          // In particular, we detected on some M1 macs that when the object store reaches a threshold, the count
+          // performance stops growing in O(n) and suddenly becomes very slow (40s, 60s or more).
+          // For reference, the performance drop occurs around 300-400k keys on the platforms where this issue is observed.
+          // Even on other configurations, the count can take several seconds.
+          // This will block other operations on the database, like sending messages.
+          //
+          // This is a workaround to avoid calling `olmMachine.roomKeyCounts()` too often, and only when necessary.
+          // We don't call it on the first loop because there could be only a few keys to upload, and we don't want to wait for the count.
+          if (!isFirstIteration && remainingToUploadCount === null) {
+            try {
+              const keyCount = await this.olmMachine.roomKeyCounts();
+              remainingToUploadCount = keyCount.total - keyCount.backedUp;
+            } catch (err) {
+              this.logger.error("Backup: Failed to get key counts from rust crypto-sdk", err);
             }
-            return;
           }
-          try {
-            yield _this11.outgoingRequestProcessor.makeOutgoingRequest(request);
-            numFailures = 0;
-            if (_this11.stopped) break;
-
-            // Key count performance (`olmMachine.roomKeyCounts()`) can be pretty bad on some configurations.
-            // In particular, we detected on some M1 macs that when the object store reaches a threshold, the count
-            // performance stops growing in O(n) and suddenly becomes very slow (40s, 60s or more).
-            // For reference, the performance drop occurs around 300-400k keys on the platforms where this issue is observed.
-            // Even on other configurations, the count can take several seconds.
-            // This will block other operations on the database, like sending messages.
-            //
-            // This is a workaround to avoid calling `olmMachine.roomKeyCounts()` too often, and only when necessary.
-            // We don't call it on the first loop because there could be only a few keys to upload, and we don't want to wait for the count.
-            if (!isFirstIteration && remainingToUploadCount === null) {
+          if (remainingToUploadCount !== null) {
+            this.emit(CryptoEvent.KeyBackupSessionsRemaining, remainingToUploadCount);
+            const keysCountInBatch = this.keysCountInBatch(request);
+            // `OlmMachine.roomKeyCounts` is called only once for the current backupKeysLoop. But new
+            // keys could be added during the current loop (after a sync for example).
+            // So the count can get out of sync with the real number of remaining keys to upload.
+            // Depending on the number of new keys imported and the time to complete the loop,
+            // this could result in multiple events being emitted with a remaining key count of 0.
+            remainingToUploadCount = Math.max(remainingToUploadCount - keysCountInBatch, 0);
+          }
+        } catch (err) {
+          numFailures++;
+          this.logger.error("Backup: Error processing backup request for rust crypto-sdk", err);
+          if (err instanceof MatrixError) {
+            const errCode = err.data.errcode;
+            if (errCode == "M_NOT_FOUND" || errCode == "M_WRONG_ROOM_KEYS_VERSION") {
+              this.logger.debug(`Backup: Failed to upload keys to current vesion: ${errCode}.`);
               try {
-                var keyCount = yield _this11.olmMachine.roomKeyCounts();
-                remainingToUploadCount = keyCount.total - keyCount.backedUp;
-              } catch (err) {
-                _this11.logger.error("Backup: Failed to get key counts from rust crypto-sdk", err);
+                await this.disableKeyBackup();
+              } catch (error) {
+                this.logger.error("Backup: An error occurred while disabling key backup:", error);
               }
-            }
-            if (remainingToUploadCount !== null) {
-              _this11.emit(CryptoEvent.KeyBackupSessionsRemaining, remainingToUploadCount);
-              var keysCountInBatch = _this11.keysCountInBatch(request);
-              // `OlmMachine.roomKeyCounts` is called only once for the current backupKeysLoop. But new
-              // keys could be added during the current loop (after a sync for example).
-              // So the count can get out of sync with the real number of remaining keys to upload.
-              // Depending on the number of new keys imported and the time to complete the loop,
-              // this could result in multiple events being emitted with a remaining key count of 0.
-              remainingToUploadCount = Math.max(remainingToUploadCount - keysCountInBatch, 0);
-            }
-          } catch (err) {
-            numFailures++;
-            _this11.logger.error("Backup: Error processing backup request for rust crypto-sdk", err);
-            if (err instanceof MatrixError) {
-              var errCode = err.data.errcode;
-              if (errCode == "M_NOT_FOUND" || errCode == "M_WRONG_ROOM_KEYS_VERSION") {
-                _this11.logger.debug("Backup: Failed to upload keys to current vesion: ".concat(errCode, "."));
-                try {
-                  yield _this11.disableKeyBackup();
-                } catch (error) {
-                  _this11.logger.error("Backup: An error occurred while disabling key backup:", error);
+              this.emit(CryptoEvent.KeyBackupFailed, err.data.errcode);
+              // There was an active backup and we are out of sync with the server
+              // force a check server side
+              this.backupKeysLoopRunning = false;
+              this.checkKeyBackupAndEnable(true);
+              return;
+            } else if (err.isRateLimitError()) {
+              // wait for that and then continue?
+              try {
+                const waitTime = err.getRetryAfterMs();
+                if (waitTime && waitTime > 0) {
+                  await sleep(waitTime);
+                  continue;
                 }
-                _this11.emit(CryptoEvent.KeyBackupFailed, err.data.errcode);
-                // There was an active backup and we are out of sync with the server
-                // force a check server side
-                _this11.backupKeysLoopRunning = false;
-                _this11.checkKeyBackupAndEnable(true);
-                return;
-              } else if (err.isRateLimitError()) {
-                // wait for that and then continue?
-                try {
-                  var waitTime = err.getRetryAfterMs();
-                  if (waitTime && waitTime > 0) {
-                    yield sleep(waitTime);
-                    continue;
-                  }
-                } catch (error) {
-                  _this11.logger.warn("Backup: An error occurred while retrieving a rate-limit retry delay", error);
-                } // else go to the normal backoff
-              }
+              } catch (error) {
+                this.logger.warn("Backup: An error occurred while retrieving a rate-limit retry delay", error);
+              } // else go to the normal backoff
             }
-
-            // Some other errors (mx, network, or CORS or invalid urls?) anyhow backoff
-            // exponential backoff if we have failures
-            yield sleep(1000 * Math.pow(2, Math.min(numFailures - 1, 4)));
           }
-          isFirstIteration = false;
+
+          // Some other errors (mx, network, or CORS or invalid urls?) anyhow backoff
+          // exponential backoff if we have failures
+          await sleep(1000 * Math.pow(2, Math.min(numFailures - 1, 4)));
         }
-      } finally {
-        _this11.backupKeysLoopRunning = false;
+        isFirstIteration = false;
       }
-    })();
+    } finally {
+      this.backupKeysLoopRunning = false;
+    }
   }
 
   /**
@@ -494,7 +457,7 @@ export class RustBackupManager extends TypedEventEmitter {
    * @returns The number of keys in the backup request.
    */
   keysCountInBatch(batch) {
-    var parsedBody = JSON.parse(batch.body);
+    const parsedBody = JSON.parse(batch.body);
     return countKeysInBackup(parsedBody);
   }
 
@@ -506,11 +469,8 @@ export class RustBackupManager extends TypedEventEmitter {
    * @param version - The version of the backup to get information about.
    * @returns Information object from API or null if there is no active backup.
    */
-  requestKeyBackupVersion(version) {
-    var _this12 = this;
-    return _asyncToGenerator(function* () {
-      return yield requestKeyBackupVersion(_this12.http, version);
-    })();
+  async requestKeyBackupVersion(version) {
+    return await requestKeyBackupVersion(this.http, version);
   }
 
   /**
@@ -523,31 +483,28 @@ export class RustBackupManager extends TypedEventEmitter {
    * existing identity.
    * @returns a KeyBackupCreationInfo - All information related to the backup.
    */
-  setupKeyBackup(signObject) {
-    var _this13 = this;
-    return _asyncToGenerator(function* () {
-      // Clean up any existing backup
-      yield _this13.deleteAllKeyBackupVersions();
-      var randomKey = RustSdkCryptoJs.BackupDecryptionKey.createRandomKey();
-      var pubKey = randomKey.megolmV1PublicKey;
-      var authData = {
-        public_key: pubKey.publicKeyBase64
-      };
-      yield signObject(authData);
-      var res = yield _this13.http.authedRequest(Method.Post, "/room_keys/version", undefined, {
-        algorithm: pubKey.algorithm,
-        auth_data: authData
-      }, {
-        prefix: ClientPrefix.V3
-      });
-      yield _this13.saveBackupDecryptionKey(randomKey, res.version);
-      return {
-        version: res.version,
-        algorithm: pubKey.algorithm,
-        authData: authData,
-        decryptionKey: randomKey
-      };
-    })();
+  async setupKeyBackup(signObject) {
+    // Clean up any existing backup
+    await this.deleteAllKeyBackupVersions();
+    const randomKey = RustSdkCryptoJs.BackupDecryptionKey.createRandomKey();
+    const pubKey = randomKey.megolmV1PublicKey;
+    const authData = {
+      public_key: pubKey.publicKeyBase64
+    };
+    await signObject(authData);
+    const res = await this.http.authedRequest(Method.Post, "/room_keys/version", undefined, {
+      algorithm: pubKey.algorithm,
+      auth_data: authData
+    }, {
+      prefix: ClientPrefix.V3
+    });
+    await this.saveBackupDecryptionKey(randomKey, res.version);
+    return {
+      version: res.version,
+      algorithm: pubKey.algorithm,
+      authData: authData,
+      decryptionKey: randomKey
+    };
   }
 
   /**
@@ -555,20 +512,15 @@ export class RustBackupManager extends TypedEventEmitter {
    *
    * Will call the API to delete active backup until there is no more present.
    */
-  deleteAllKeyBackupVersions() {
-    var _this14 = this;
-    return _asyncToGenerator(function* () {
-      var _yield$_this14$reques, _yield$_this14$reques2;
-      // there could be several backup versions. Delete all to be safe.
-      var current = (_yield$_this14$reques = (_yield$_this14$reques2 = yield _this14.requestKeyBackupVersion()) === null || _yield$_this14$reques2 === void 0 ? void 0 : _yield$_this14$reques2.version) !== null && _yield$_this14$reques !== void 0 ? _yield$_this14$reques : null;
-      while (current != null) {
-        var _yield$_this14$reques3, _yield$_this14$reques4;
-        yield _this14.deleteKeyBackupVersion(current);
-        current = (_yield$_this14$reques3 = (_yield$_this14$reques4 = yield _this14.requestKeyBackupVersion()) === null || _yield$_this14$reques4 === void 0 ? void 0 : _yield$_this14$reques4.version) !== null && _yield$_this14$reques3 !== void 0 ? _yield$_this14$reques3 : null;
-      }
+  async deleteAllKeyBackupVersions() {
+    // there could be several backup versions. Delete all to be safe.
+    let current = (await this.requestKeyBackupVersion())?.version ?? null;
+    while (current != null) {
+      await this.deleteKeyBackupVersion(current);
+      current = (await this.requestKeyBackupVersion())?.version ?? null;
+    }
 
-      // XXX: Should this also update Secret Storage and delete any existing keys?
-    })();
+    // XXX: Should this also update Secret Storage and delete any existing keys?
   }
 
   /**
@@ -576,22 +528,19 @@ export class RustBackupManager extends TypedEventEmitter {
    *
    * @param version - The backup version to delete.
    */
-  deleteKeyBackupVersion(version) {
-    var _this15 = this;
-    return _asyncToGenerator(function* () {
-      _this15.logger.debug("deleteKeyBackupVersion v:".concat(version));
-      var path = encodeUri("/room_keys/version/$version", {
-        $version: version
-      });
-      yield _this15.http.authedRequest(Method.Delete, path, undefined, undefined, {
-        prefix: ClientPrefix.V3
-      });
-      // If the backup we are deleting is the active one, we need to disable the key backup and to have the local properties reset
-      if (_this15.activeBackupVersion === version) {
-        _this15.serverBackupInfo = null;
-        yield _this15.disableKeyBackup();
-      }
-    })();
+  async deleteKeyBackupVersion(version) {
+    this.logger.debug(`deleteKeyBackupVersion v:${version}`);
+    const path = encodeUri("/room_keys/version/$version", {
+      $version: version
+    });
+    await this.http.authedRequest(Method.Delete, path, undefined, undefined, {
+      prefix: ClientPrefix.V3
+    });
+    // If the backup we are deleting is the active one, we need to disable the key backup and to have the local properties reset
+    if (this.activeBackupVersion === version) {
+      this.serverBackupInfo = null;
+      await this.disableKeyBackup();
+    }
   }
 
   /**
@@ -610,12 +559,9 @@ export class RustBackupManager extends TypedEventEmitter {
    * @param opts - Options for the restore.
    * @returns The total number of keys and the total imported.
    */
-  restoreKeyBackup(backupVersion, backupDecryptor, opts) {
-    var _this16 = this;
-    return _asyncToGenerator(function* () {
-      var keyBackup = yield _this16.downloadKeyBackup(backupVersion);
-      return _this16.importKeyBackup(keyBackup, backupVersion, backupDecryptor, opts);
-    })();
+  async restoreKeyBackup(backupVersion, backupDecryptor, opts) {
+    const keyBackup = await this.downloadKeyBackup(backupVersion);
+    return this.importKeyBackup(keyBackup, backupVersion, backupDecryptor, opts);
   }
 
   /**
@@ -623,26 +569,24 @@ export class RustBackupManager extends TypedEventEmitter {
    *
    * @param roomId - The room in question.
    */
-  downloadLatestRoomKeyBackup(roomId) {
-    var _this17 = this;
-    return _asyncToGenerator(function* () {
-      var _yield$_this17$olmMac = yield _this17.olmMachine.getBackupKeys(),
-        backupVersion = _yield$_this17$olmMac.backupVersion,
-        decryptionKey = _yield$_this17$olmMac.decryptionKey;
-      if (!backupVersion || !decryptionKey) {
-        _this17.logger.warn("downloadLatestRoomKeyBackup: Could not download backup (backupVersion=".concat(backupVersion, ", hasDecryptionKey=").concat(!!decryptionKey, ")"));
-        return;
-      }
-      var sessions = yield _this17.downloadRoomKeyBackup(backupVersion, roomId);
-      var backupDecryptor = _this17.createBackupDecryptor(decryptionKey);
-      _this17.importKeyBackup({
-        rooms: {
-          [roomId]: {
-            sessions
-          }
+  async downloadLatestRoomKeyBackup(roomId) {
+    const {
+      backupVersion,
+      decryptionKey
+    } = await this.olmMachine.getBackupKeys();
+    if (!backupVersion || !decryptionKey) {
+      this.logger.warn(`downloadLatestRoomKeyBackup: Could not download backup (backupVersion=${backupVersion}, hasDecryptionKey=${!!decryptionKey})`);
+      return;
+    }
+    const sessions = await this.downloadRoomKeyBackup(backupVersion, roomId);
+    const backupDecryptor = this.createBackupDecryptor(decryptionKey);
+    this.importKeyBackup({
+      rooms: {
+        [roomId]: {
+          sessions
         }
-      }, backupVersion, backupDecryptor);
-    })();
+      }
+    }, backupVersion, backupDecryptor);
   }
 
   /**
@@ -667,7 +611,7 @@ export class RustBackupManager extends TypedEventEmitter {
    * @returns The key backup response.
    */
   downloadRoomKeyBackup(backupVersion, roomId) {
-    var path = encodeUri("/room_keys/keys/$roomId", {
+    const path = encodeUri("/room_keys/keys/$roomId", {
       $roomId: roomId
     });
     return this.http.authedRequest(Method.Get, path, {
@@ -690,112 +634,93 @@ export class RustBackupManager extends TypedEventEmitter {
    *
    * @private
    */
-  importKeyBackup(keyBackup, backupVersion, backupDecryptor, opts) {
-    var _this18 = this;
-    return _asyncToGenerator(function* () {
-      var _opts$progressCallbac3;
-      // We have a full backup here, it can get quite big, so we need to decrypt and import it in chunks.
-
-      var CHUNK_SIZE = 200;
-      // Get the total count as a first pass
-      var totalKeyCount = countKeysInBackup(keyBackup);
-      var totalImported = 0;
-      var totalFailures = 0;
-      opts === null || opts === void 0 || (_opts$progressCallbac3 = opts.progressCallback) === null || _opts$progressCallbac3 === void 0 || _opts$progressCallbac3.call(opts, {
+  async importKeyBackup(keyBackup, backupVersion, backupDecryptor, opts) {
+    // We have a full backup here, it can get quite big, so we need to decrypt and import it in chunks.
+
+    const CHUNK_SIZE = 200;
+    // Get the total count as a first pass
+    const totalKeyCount = countKeysInBackup(keyBackup);
+    let totalImported = 0;
+    let totalFailures = 0;
+    opts?.progressCallback?.({
+      total: totalKeyCount,
+      successes: totalImported,
+      stage: ImportRoomKeyStage.LoadKeys,
+      failures: totalFailures
+    });
+
+    /**
+     * This method is called when we have enough chunks to decrypt.
+     * It will decrypt the chunks and try to import the room keys.
+     * @param roomChunks
+     */
+    const handleChunkCallback = async roomChunks => {
+      const currentChunk = [];
+      for (const roomId of roomChunks.keys()) {
+        // Decrypt the sessions for the given room
+        const decryptedSessions = await backupDecryptor.decryptSessions(roomChunks.get(roomId));
+        // Add the decrypted sessions to the current chunk
+        decryptedSessions.forEach(session => {
+          // We set the room_id for each session
+          session.room_id = roomId;
+          currentChunk.push(session);
+        });
+      }
+
+      // We have a chunk of decrypted keys: import them
+      try {
+        await this.importBackedUpRoomKeys(currentChunk, backupVersion);
+        totalImported += currentChunk.length;
+      } catch (e) {
+        totalFailures += currentChunk.length;
+        // We failed to import some keys, but we should still try to import the rest?
+        // Log the error and continue
+        this.logger.error("Error importing keys from backup", e);
+      }
+      opts?.progressCallback?.({
         total: totalKeyCount,
         successes: totalImported,
         stage: ImportRoomKeyStage.LoadKeys,
         failures: totalFailures
       });
-
-      /**
-       * This method is called when we have enough chunks to decrypt.
-       * It will decrypt the chunks and try to import the room keys.
-       * @param roomChunks
-       */
-      var handleChunkCallback = /*#__PURE__*/function () {
-        var _ref2 = _asyncToGenerator(function* (roomChunks) {
-          var _opts$progressCallbac4;
-          var currentChunk = [];
-          var _loop = function* _loop(roomId) {
-            // Decrypt the sessions for the given room
-            var decryptedSessions = yield backupDecryptor.decryptSessions(roomChunks.get(roomId));
-            // Add the decrypted sessions to the current chunk
-            decryptedSessions.forEach(session => {
-              // We set the room_id for each session
-              session.room_id = roomId;
-              currentChunk.push(session);
-            });
-          };
-          for (var roomId of roomChunks.keys()) {
-            yield* _loop(roomId);
-          }
-
-          // We have a chunk of decrypted keys: import them
-          try {
-            yield _this18.importBackedUpRoomKeys(currentChunk, backupVersion);
-            totalImported += currentChunk.length;
-          } catch (e) {
-            totalFailures += currentChunk.length;
-            // We failed to import some keys, but we should still try to import the rest?
-            // Log the error and continue
-            _this18.logger.error("Error importing keys from backup", e);
-          }
-          opts === null || opts === void 0 || (_opts$progressCallbac4 = opts.progressCallback) === null || _opts$progressCallbac4 === void 0 || _opts$progressCallbac4.call(opts, {
-            total: totalKeyCount,
-            successes: totalImported,
-            stage: ImportRoomKeyStage.LoadKeys,
-            failures: totalFailures
-          });
-        });
-        return function handleChunkCallback(_x) {
-          return _ref2.apply(this, arguments);
-        };
-      }();
-      var groupChunkCount = 0;
-      var chunkGroupByRoom = new Map();
-
-      // Iterate over the rooms and sessions to group them in chunks
-      // And we call the handleChunkCallback when we have enough chunks to decrypt
-      for (var _ref5 of Object.entries(keyBackup.rooms)) {
-        var _ref4 = _slicedToArray(_ref5, 2);
-        var roomId = _ref4[0];
-        var roomData = _ref4[1];
-        // If there are no sessions for the room, skip it
-        if (!roomData.sessions) continue;
-
-        // Initialize a new chunk group for the current room
-        chunkGroupByRoom.set(roomId, {});
-        for (var _ref8 of Object.entries(roomData.sessions)) {
-          var _ref7 = _slicedToArray(_ref8, 2);
-          var sessionId = _ref7[0];
-          var session = _ref7[1];
-          // We set previously the chunk group for the current room, so we can safely get it
-          var sessionsForRoom = chunkGroupByRoom.get(roomId);
-          sessionsForRoom[sessionId] = session;
-          groupChunkCount += 1;
-          // If we have enough chunks to decrypt, call the block callback
-          if (groupChunkCount >= CHUNK_SIZE) {
-            // We have enough chunks to decrypt
-            yield handleChunkCallback(chunkGroupByRoom);
-            // Reset the chunk group
-            chunkGroupByRoom = new Map();
-            // There might be remaining keys for that room, so add back an entry for the current room.
-            chunkGroupByRoom.set(roomId, {});
-            groupChunkCount = 0;
-          }
+    };
+    let groupChunkCount = 0;
+    let chunkGroupByRoom = new Map();
+
+    // Iterate over the rooms and sessions to group them in chunks
+    // And we call the handleChunkCallback when we have enough chunks to decrypt
+    for (const [roomId, roomData] of Object.entries(keyBackup.rooms)) {
+      // If there are no sessions for the room, skip it
+      if (!roomData.sessions) continue;
+
+      // Initialize a new chunk group for the current room
+      chunkGroupByRoom.set(roomId, {});
+      for (const [sessionId, session] of Object.entries(roomData.sessions)) {
+        // We set previously the chunk group for the current room, so we can safely get it
+        const sessionsForRoom = chunkGroupByRoom.get(roomId);
+        sessionsForRoom[sessionId] = session;
+        groupChunkCount += 1;
+        // If we have enough chunks to decrypt, call the block callback
+        if (groupChunkCount >= CHUNK_SIZE) {
+          // We have enough chunks to decrypt
+          await handleChunkCallback(chunkGroupByRoom);
+          // Reset the chunk group
+          chunkGroupByRoom = new Map();
+          // There might be remaining keys for that room, so add back an entry for the current room.
+          chunkGroupByRoom.set(roomId, {});
+          groupChunkCount = 0;
         }
       }
+    }
 
-      // Handle remaining chunk if needed
-      if (groupChunkCount > 0) {
-        yield handleChunkCallback(chunkGroupByRoom);
-      }
-      return {
-        total: totalKeyCount,
-        imported: totalImported
-      };
-    })();
+    // Handle remaining chunk if needed
+    if (groupChunkCount > 0) {
+      await handleChunkCallback(chunkGroupByRoom);
+    }
+    return {
+      total: totalKeyCount,
+      imported: totalImported
+    };
   }
 
   /**
@@ -806,12 +731,11 @@ export class RustBackupManager extends TypedEventEmitter {
    * @returns `true` if the private key can decrypt the backup, `false` otherwise.
    */
   backupInfoMatchesBackupDecryptionKey(info, backupDecryptionKey) {
-    var _info$auth_data;
     if (info.algorithm !== "m.megolm_backup.v1.curve25519-aes-sha2") {
       this.logger.warn("backupMatchesPrivateKey: Unsupported backup algorithm", info.algorithm);
       return false;
     }
-    return ((_info$auth_data = info.auth_data) === null || _info$auth_data === void 0 ? void 0 : _info$auth_data.public_key) === backupDecryptionKey.megolmV1PublicKey.publicKeyBase64;
+    return info.auth_data?.public_key === backupDecryptionKey.megolmV1PublicKey.publicKeyBase64;
   }
 }
 /**
@@ -819,6 +743,8 @@ export class RustBackupManager extends TypedEventEmitter {
  */
 export class RustBackupDecryptor {
   constructor(logger, decryptionKey) {
+    _defineProperty(this, "decryptionKey", void 0);
+    _defineProperty(this, "sourceTrusted", void 0);
     this.logger = logger;
     this.decryptionKey = decryptionKey;
     this.sourceTrusted = false;
@@ -827,24 +753,18 @@ export class RustBackupDecryptor {
   /**
    * Implements {@link BackupDecryptor#decryptSessions}
    */
-  decryptSessions(ciphertexts) {
-    var _this19 = this;
-    return _asyncToGenerator(function* () {
-      var keys = [];
-      for (var _ref1 of Object.entries(ciphertexts)) {
-        var _ref0 = _slicedToArray(_ref1, 2);
-        var sessionId = _ref0[0];
-        var sessionData = _ref0[1];
-        try {
-          var decrypted = JSON.parse(_this19.decryptionKey.decryptV1(sessionData.session_data.ephemeral, sessionData.session_data.mac, sessionData.session_data.ciphertext));
-          decrypted.session_id = sessionId;
-          keys.push(decrypted);
-        } catch (e) {
-          _this19.logger.debug("Failed to decrypt megolm session from backup", e, sessionData);
-        }
+  async decryptSessions(ciphertexts) {
+    const keys = [];
+    for (const [sessionId, sessionData] of Object.entries(ciphertexts)) {
+      try {
+        const decrypted = JSON.parse(this.decryptionKey.decryptV1(sessionData.session_data.ephemeral, sessionData.session_data.mac, sessionData.session_data.ciphertext));
+        decrypted.session_id = sessionId;
+        keys.push(decrypted);
+      } catch (e) {
+        this.logger.debug("Failed to decrypt megolm session from backup", e, sessionData);
       }
-      return keys;
-    })();
+    }
+    return keys;
   }
 
   /**
@@ -868,8 +788,21 @@ export class RustBackupDecryptor {
  * @param version - the specific version of the backup info to fetch
  * @returns The key backup info or null if there is no backup.
  */
-export function requestKeyBackupVersion(_x2, _x3) {
-  return _requestKeyBackupVersion.apply(this, arguments);
+export async function requestKeyBackupVersion(http, version) {
+  try {
+    const path = version ? encodeUri("/room_keys/version/$version", {
+      $version: version
+    }) : "/room_keys/version";
+    return await http.authedRequest(Method.Get, path, undefined, undefined, {
+      prefix: ClientPrefix.V3
+    });
+  } catch (e) {
+    if (e.errcode === "M_NOT_FOUND") {
+      return null;
+    } else {
+      throw e;
+    }
+  }
 }
 
 /**
@@ -879,27 +812,8 @@ export function requestKeyBackupVersion(_x2, _x3) {
  * @param keyBackupInfo - The key backup info to check against.
  * @returns `true` if the decryption key matches the key backup info, `false` otherwise.
  */
-function _requestKeyBackupVersion() {
-  _requestKeyBackupVersion = _asyncToGenerator(function* (http, version) {
-    try {
-      var path = version ? encodeUri("/room_keys/version/$version", {
-        $version: version
-      }) : "/room_keys/version";
-      return yield http.authedRequest(Method.Get, path, undefined, undefined, {
-        prefix: ClientPrefix.V3
-      });
-    } catch (e) {
-      if (e.errcode === "M_NOT_FOUND") {
-        return null;
-      } else {
-        throw e;
-      }
-    }
-  });
-  return _requestKeyBackupVersion.apply(this, arguments);
-}
 export function decryptionKeyMatchesKeyBackupInfo(decryptionKey, keyBackupInfo) {
-  var authData = keyBackupInfo.auth_data;
+  const authData = keyBackupInfo.auth_data;
   return authData.public_key === decryptionKey.megolmV1PublicKey.publicKeyBase64;
 }
 
@@ -909,9 +823,10 @@ export function decryptionKeyMatchesKeyBackupInfo(decryptionKey, keyBackupInfo)
  * @returns The total number of keys in the backup.
  */
 function countKeysInBackup(keyBackup) {
-  var count = 0;
-  for (var _ref11 of Object.values(keyBackup.rooms)) {
-    var sessions = _ref11.sessions;
+  let count = 0;
+  for (const {
+    sessions
+  } of Object.values(keyBackup.rooms)) {
     count += Object.keys(sessions).length;
   }
   return count;