matrix-js-sdk 41.1.0 → 41.2.0

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

@@ -49,6 +49,9 @@ 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];
+/** 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
+
 /**
  * An implementation of {@link CryptoBackend} using the Rust matrix-sdk-crypto.
  *
@@ -86,8 +89,6 @@ export class RustCrypto extends TypedEventEmitter {
     _defineProperty(this, "stopped", false);
     /** mapping of roomId → encryptor class */
     _defineProperty(this, "roomEncryptors", {});
-    /** mapping of room ID -> inviter ID for rooms pending MSC4268 key bundles */
-    _defineProperty(this, "roomsPendingKeyBundles", new Map());
     _defineProperty(this, "eventDecryptor", void 0);
     _defineProperty(this, "keyClaimManager", void 0);
     _defineProperty(this, "outgoingRequestProcessor", void 0);
@@ -256,20 +257,26 @@ export class RustCrypto extends TypedEventEmitter {
       var encryptedBundle;
       try {
         var bundleUrl = new URL(url);
-        encryptedBundle = yield _this5.http.authedRequest(Method.Get, bundleUrl.pathname + bundleUrl.search, {}, undefined, {
+        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;
       }
-      logger.info("Received blob of length ".concat(encryptedBundle.size));
       try {
-        yield _this5.olmMachine.receiveRoomKeyBundle(bundleData, new Uint8Array(yield encryptedBundle.arrayBuffer()));
+        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;
     })();
@@ -279,7 +286,10 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoBackend.markRoomAsPendingKeyBundle}.
    */
   markRoomAsPendingKeyBundle(roomId, inviter) {
-    this.roomsPendingKeyBundles.set(roomId, inviter);
+    var _this6 = this;
+    return _asyncToGenerator(function* () {
+      yield _this6.olmMachine.storeRoomPendingKeyBundle(new RustSdkCryptoJs.RoomId(roomId), new RustSdkCryptoJs.UserId(inviter));
+    })();
   }
   /**
    * Implementation of {@link CryptoApi#getVersion}.
@@ -300,9 +310,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#isEncryptionEnabledInRoom}.
    */
   isEncryptionEnabledInRoom(roomId) {
-    var _this6 = this;
+    var _this7 = this;
     return _asyncToGenerator(function* () {
-      var roomSettings = yield _this6.olmMachine.getRoomSettings(new RustSdkCryptoJs.RoomId(roomId));
+      var roomSettings = yield _this7.olmMachine.getRoomSettings(new RustSdkCryptoJs.RoomId(roomId));
       return Boolean(roomSettings === null || roomSettings === void 0 ? void 0 : roomSettings.algorithm);
     })();
   }
@@ -311,9 +321,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#isStateEncryptionEnabledInRoom}.
    */
   isStateEncryptionEnabledInRoom(roomId) {
-    var _this7 = this;
+    var _this8 = this;
     return _asyncToGenerator(function* () {
-      var roomSettings = yield _this7.olmMachine.getRoomSettings(new RustSdkCryptoJs.RoomId(roomId));
+      var roomSettings = yield _this8.olmMachine.getRoomSettings(new RustSdkCryptoJs.RoomId(roomId));
       return Boolean(roomSettings === null || roomSettings === void 0 ? void 0 : roomSettings.encryptStateEvents);
     })();
   }
@@ -322,9 +332,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#getOwnDeviceKeys}.
    */
   getOwnDeviceKeys() {
-    var _this8 = this;
+    var _this9 = this;
     return _asyncToGenerator(function* () {
-      var keys = _this8.olmMachine.identityKeys;
+      var keys = _this9.olmMachine.identityKeys;
       return {
         ed25519: keys.ed25519.toBase64(),
         curve25519: keys.curve25519.toBase64()
@@ -342,28 +352,28 @@ export class RustCrypto extends TypedEventEmitter {
     return (_this$roomEncryptors$ = this.roomEncryptors[roomId]) === null || _this$roomEncryptors$ === void 0 ? void 0 : _this$roomEncryptors$.forceDiscardSession();
   }
   exportRoomKeys() {
-    var _this9 = this;
+    var _this0 = this;
     return _asyncToGenerator(function* () {
-      var raw = yield _this9.olmMachine.exportRoomKeys(() => true);
+      var raw = yield _this0.olmMachine.exportRoomKeys(() => true);
       return JSON.parse(raw);
     })();
   }
   exportRoomKeysAsJson() {
-    var _this0 = this;
+    var _this1 = this;
     return _asyncToGenerator(function* () {
-      return yield _this0.olmMachine.exportRoomKeys(() => true);
+      return yield _this1.olmMachine.exportRoomKeys(() => true);
     })();
   }
   importRoomKeys(keys, opts) {
-    var _this1 = this;
+    var _this10 = this;
     return _asyncToGenerator(function* () {
-      return yield _this1.backupManager.importRoomKeys(keys, opts);
+      return yield _this10.backupManager.importRoomKeys(keys, opts);
     })();
   }
   importRoomKeysAsJson(keys, opts) {
-    var _this10 = this;
+    var _this11 = this;
     return _asyncToGenerator(function* () {
-      return yield _this10.backupManager.importRoomKeysAsJson(keys, opts);
+      return yield _this11.backupManager.importRoomKeysAsJson(keys, opts);
     })();
   }
 
@@ -372,12 +382,12 @@ export class RustCrypto extends TypedEventEmitter {
    */
   userHasCrossSigningKeys() {
     var _arguments = arguments,
-      _this11 = this;
+      _this12 = this;
     return _asyncToGenerator(function* () {
-      var userId = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : _this11.userId;
+      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 _this11.olmMachine.trackedUsers();
+      var rustTrackedUsers = yield _this12.olmMachine.trackedUsers();
       var rustTrackedUser;
       for (var u of rustTrackedUsers) {
         if (userId === u.toString()) {
@@ -386,22 +396,22 @@ export class RustCrypto extends TypedEventEmitter {
         }
       }
       if (rustTrackedUser !== undefined) {
-        if (userId === _this11.userId) {
+        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 = _this11.olmMachine.queryKeysForUsers(
+          var request = _this12.olmMachine.queryKeysForUsers(
           // clone as rust layer will take ownership and it's reused later
           [rustTrackedUser.clone()]);
-          yield _this11.outgoingRequestProcessor.makeOutgoingRequest(request);
+          yield _this12.outgoingRequestProcessor.makeOutgoingRequest(request);
         }
-        var userIdentity = yield _this11.olmMachine.getIdentity(rustTrackedUser);
+        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 _this11.downloadDeviceList(new Set([userId]));
+        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
@@ -428,11 +438,11 @@ export class RustCrypto extends TypedEventEmitter {
    */
   getUserDeviceInfo(userIds) {
     var _arguments2 = arguments,
-      _this12 = this;
+      _this13 = this;
     return _asyncToGenerator(function* () {
       var downloadUncached = _arguments2.length > 1 && _arguments2[1] !== undefined ? _arguments2[1] : false;
       var deviceMapByUserId = new Map();
-      var rustTrackedUsers = yield _this12.getOlmMachineOrThrow().trackedUsers();
+      var rustTrackedUsers = yield _this13.getOlmMachineOrThrow().trackedUsers();
 
       // Convert RustSdkCryptoJs.UserId to a `Set<string>`
       var trackedUsers = new Set();
@@ -445,7 +455,7 @@ export class RustCrypto extends TypedEventEmitter {
         // (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 _this12.getUserDevices(_userId));
+          deviceMapByUserId.set(_userId, yield _this13.getUserDevices(_userId));
         } else {
           untrackedUsers.add(_userId);
         }
@@ -454,7 +464,7 @@ export class RustCrypto extends TypedEventEmitter {
       // 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 _this12.downloadDeviceList(untrackedUsers);
+        var queryResult = yield _this13.downloadDeviceList(untrackedUsers);
         Object.entries(queryResult.device_keys).forEach(_ref => {
           var [userId, deviceKeys] = _ref;
           return deviceMapByUserId.set(userId, deviceKeysToDeviceMap(deviceKeys));
@@ -469,7 +479,7 @@ export class RustCrypto extends TypedEventEmitter {
    * @param userId - Rust SDK UserId
    */
   getUserDevices(userId) {
-    var _this13 = this;
+    var _this14 = this;
     return _asyncToGenerator(function* () {
       var rustUserId = new RustSdkCryptoJs.UserId(userId);
 
@@ -487,7 +497,7 @@ export class RustCrypto extends TypedEventEmitter {
       // 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 _this13.olmMachine.getUserDevices(rustUserId, 1);
+      var userDevices = yield _this14.olmMachine.getUserDevices(rustUserId, 1);
       try {
         var deviceArray = userDevices.devices();
         try {
@@ -506,13 +516,13 @@ export class RustCrypto extends TypedEventEmitter {
    * @param untrackedUsers - download keys of these users
    */
   downloadDeviceList(untrackedUsers) {
-    var _this14 = this;
+    var _this15 = this;
     return _asyncToGenerator(function* () {
       var queryBody = {
         device_keys: {}
       };
       untrackedUsers.forEach(user => queryBody.device_keys[user] = []);
-      return yield _this14.http.authedRequest(Method.Post, "/_matrix/client/v3/keys/query", undefined, queryBody, {
+      return yield _this15.http.authedRequest(Method.Post, "/_matrix/client/v3/keys/query", undefined, queryBody, {
         prefix: ""
       });
     })();
@@ -541,10 +551,10 @@ export class RustCrypto extends TypedEventEmitter {
    */
   setDeviceVerified(userId, deviceId) {
     var _arguments3 = arguments,
-      _this15 = this;
+      _this16 = this;
     return _asyncToGenerator(function* () {
       var verified = _arguments3.length > 2 && _arguments3[2] !== undefined ? _arguments3[2] : true;
-      var device = yield _this15.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
+      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));
       }
@@ -562,15 +572,15 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#crossSignDevice}.
    */
   crossSignDevice(deviceId) {
-    var _this16 = this;
+    var _this17 = this;
     return _asyncToGenerator(function* () {
-      var device = yield _this16.olmMachine.getDevice(new RustSdkCryptoJs.UserId(_this16.userId), new RustSdkCryptoJs.DeviceId(deviceId));
+      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 _this16.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
+        yield _this17.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
       } finally {
         device.free();
       }
@@ -581,16 +591,16 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#getDeviceVerificationStatus}.
    */
   getDeviceVerificationStatus(userId, deviceId) {
-    var _this17 = this;
+    var _this18 = this;
     return _asyncToGenerator(function* () {
-      var device = yield _this17.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
+      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: _this17._trustCrossSignedDevices
+          trustCrossSignedDevices: _this18._trustCrossSignedDevices
         });
       } finally {
         device.free();
@@ -602,9 +612,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#getUserVerificationStatus}.
    */
   getUserVerificationStatus(userId) {
-    var _this18 = this;
+    var _this19 = this;
     return _asyncToGenerator(function* () {
-      var userIdentity = yield _this18.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
+      var userIdentity = yield _this19.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
       if (userIdentity === undefined) {
         return new UserVerificationStatus(false, false, false);
       }
@@ -620,9 +630,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#pinCurrentUserIdentity}.
    */
   pinCurrentUserIdentity(userId) {
-    var _this19 = this;
+    var _this20 = this;
     return _asyncToGenerator(function* () {
-      var userIdentity = yield _this19.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
+      var userIdentity = yield _this20.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
       if (userIdentity === undefined) {
         throw new Error("Cannot pin identity of unknown user");
       }
@@ -637,9 +647,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#withdrawVerificationRequirement}.
    */
   withdrawVerificationRequirement(userId) {
-    var _this20 = this;
+    var _this21 = this;
     return _asyncToGenerator(function* () {
-      var userIdentity = yield _this20.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
+      var userIdentity = yield _this21.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(userId));
       if (userIdentity === undefined) {
         throw new Error("Cannot withdraw verification of unknown user");
       }
@@ -651,14 +661,14 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#isCrossSigningReady}
    */
   isCrossSigningReady() {
-    var _this21 = this;
+    var _this22 = this;
     return _asyncToGenerator(function* () {
       var {
         privateKeysInSecretStorage,
         privateKeysCachedLocally
-      } = yield _this21.getCrossSigningStatus();
+      } = yield _this22.getCrossSigningStatus();
       var hasKeysInCache = Boolean(privateKeysCachedLocally.masterKey) && Boolean(privateKeysCachedLocally.selfSigningKey) && Boolean(privateKeysCachedLocally.userSigningKey);
-      var identity = yield _this21.getOwnIdentity();
+      var identity = yield _this22.getOwnIdentity();
 
       // Cross-signing is ready if the public identity is trusted, and the private keys
       // are either cached, or accessible via secret-storage.
@@ -671,16 +681,16 @@ export class RustCrypto extends TypedEventEmitter {
    */
   getCrossSigningKeyId() {
     var _arguments4 = arguments,
-      _this22 = this;
+      _this23 = this;
     return _asyncToGenerator(function* () {
       var type = _arguments4.length > 0 && _arguments4[0] !== undefined ? _arguments4[0] : CrossSigningKey.Master;
-      var userIdentity = yield _this22.olmMachine.getIdentity(new RustSdkCryptoJs.UserId(_this22.userId));
+      var userIdentity = yield _this23.getOwnIdentity();
       if (!userIdentity) {
         // The public keys are not available on this device
         return null;
       }
       try {
-        var crossSigningStatus = yield _this22.olmMachine.crossSigningStatus();
+        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
@@ -720,9 +730,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#bootstrapCrossSigning}
    */
   bootstrapCrossSigning(opts) {
-    var _this23 = this;
+    var _this24 = this;
     return _asyncToGenerator(function* () {
-      yield _this23.crossSigningIdentity.bootstrapCrossSigning(opts);
+      yield _this24.crossSigningIdentity.bootstrapCrossSigning(opts);
     })();
   }
 
@@ -730,9 +740,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#isSecretStorageReady}
    */
   isSecretStorageReady() {
-    var _this24 = this;
+    var _this25 = this;
     return _asyncToGenerator(function* () {
-      return (yield _this24.getSecretStorageStatus()).ready;
+      return (yield _this25.getSecretStorageStatus()).ready;
     })();
   }
 
@@ -740,17 +750,17 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#getSecretStorageStatus}
    */
   getSecretStorageStatus() {
-    var _this25 = this;
+    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"];
 
       // If key backup is active, we also need to check that the backup decryption key is stored
-      var keyBackupEnabled = (yield _this25.backupManager.getActiveBackupVersion()) != null;
+      var keyBackupEnabled = (yield _this26.backupManager.getActiveBackupVersion()) != null;
       if (keyBackupEnabled) {
         secretsToCheck.push("m.megolm_backup.v1");
       }
-      var defaultKeyId = yield _this25.secretStorage.getDefaultKeyId();
+      var defaultKeyId = yield _this26.secretStorage.getDefaultKeyId();
       var result = {
         // Assume we have all secrets until proven otherwise
         ready: true,
@@ -759,7 +769,7 @@ export class RustCrypto extends TypedEventEmitter {
       };
       for (var secretName of secretsToCheck) {
         // Check which keys this particular secret is encrypted with
-        var record = (yield _this25.secretStorage.isStored(secretName)) || {};
+        var record = (yield _this26.secretStorage.isStored(secretName)) || {};
 
         // If it's encrypted with the right key, it is valid
         var secretStored = !!defaultKeyId && defaultKeyId in record;
@@ -775,7 +785,7 @@ export class RustCrypto extends TypedEventEmitter {
    */
   bootstrapSecretStorage() {
     var _arguments5 = arguments,
-      _this26 = this;
+      _this27 = this;
     return _asyncToGenerator(function* () {
       var {
         createSecretStorageKey,
@@ -784,38 +794,38 @@ export class RustCrypto extends TypedEventEmitter {
       } = _arguments5.length > 0 && _arguments5[0] !== undefined ? _arguments5[0] : {};
       // 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 _this26.secretStorageHasAESKey());
+      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
-        _this26.logger.info("bootstrapSecretStorage: creating new secret storage key");
+        _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 _this26.addSecretStorageKeyToSecretStorage(recoveryKey);
+        yield _this27.addSecretStorageKeyToSecretStorage(recoveryKey);
       }
-      var crossSigningPrivateKeys = yield _this26.olmMachine.exportCrossSigningKeys();
+      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(_this26.secretStorage)))) {
-        _this26.logger.info("bootstrapSecretStorage: cross-signing keys not yet exported; doing so now.");
-        yield _this26.secretStorage.store("m.cross_signing.master", crossSigningPrivateKeys.masterKey);
-        yield _this26.secretStorage.store("m.cross_signing.user_signing", crossSigningPrivateKeys.userSigningKey);
-        yield _this26.secretStorage.store("m.cross_signing.self_signing", crossSigningPrivateKeys.self_signing_key);
+      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);
       }
 
       // 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 _this26.saveBackupKeyToStorage();
+        yield _this27.saveBackupKeyToStorage();
       } else {
-        yield _this26.resetKeyBackup();
+        yield _this27.resetKeyBackup();
       }
     })();
   }
@@ -825,24 +835,24 @@ export class RustCrypto extends TypedEventEmitter {
    * save it to secret storage.
    */
   saveBackupKeyToStorage() {
-    var _this27 = this;
+    var _this28 = this;
     return _asyncToGenerator(function* () {
-      var keyBackupInfo = yield _this27.backupManager.getServerBackupInfo();
+      var keyBackupInfo = yield _this28.backupManager.getServerBackupInfo();
       if (!keyBackupInfo || !keyBackupInfo.version) {
-        _this27.logger.info("Not saving backup key to secret storage: no backup info");
+        _this28.logger.info("Not saving backup key to secret storage: no backup info");
         return;
       }
-      var backupKeys = yield _this27.olmMachine.getBackupKeys();
+      var backupKeys = yield _this28.olmMachine.getBackupKeys();
       if (!backupKeys.decryptionKey) {
-        _this27.logger.info("Not saving backup key to secret storage: no backup key");
+        _this28.logger.info("Not saving backup key to secret storage: no backup key");
         return;
       }
       if (!decryptionKeyMatchesKeyBackupInfo(backupKeys.decryptionKey, keyBackupInfo)) {
-        _this27.logger.info("Not saving backup key to secret storage: decryption key does not match backup info");
+        _this28.logger.info("Not saving backup key to secret storage: decryption key does not match backup info");
         return;
       }
       var backupKeyBase64 = backupKeys.decryptionKey.toBase64();
-      yield _this27.secretStorage.store("m.megolm_backup.v1", backupKeyBase64);
+      yield _this28.secretStorage.store("m.megolm_backup.v1", backupKeyBase64);
     })();
   }
 
@@ -855,16 +865,16 @@ export class RustCrypto extends TypedEventEmitter {
    * @param secretStorageKey - The secret storage key to add in the secret storage.
    */
   addSecretStorageKeyToSecretStorage(secretStorageKey) {
-    var _this28 = this;
+    var _this29 = this;
     return _asyncToGenerator(function* () {
-      var _secretStorageKey$key, _secretStorageKey$key2, _this28$cryptoCallbac, _this28$cryptoCallbac2;
-      var secretStorageKeyObject = yield _this28.secretStorage.addKey(SECRET_STORAGE_ALGORITHM_V1_AES, {
+      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 _this28.secretStorage.setDefaultKeyId(secretStorageKeyObject.keyId);
-      (_this28$cryptoCallbac = (_this28$cryptoCallbac2 = _this28.cryptoCallbacks).cacheSecretStorageKey) === null || _this28$cryptoCallbac === void 0 || _this28$cryptoCallbac.call(_this28$cryptoCallbac2, secretStorageKeyObject.keyId, secretStorageKeyObject.keyInfo, 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);
     })();
   }
 
@@ -874,10 +884,10 @@ export class RustCrypto extends TypedEventEmitter {
    * @returns True if an AES key is in the secret storage
    */
   secretStorageHasAESKey() {
-    var _this29 = this;
+    var _this30 = this;
     return _asyncToGenerator(function* () {
       // See if we already have an AES secret-storage key.
-      var secretStorageKeyTuple = yield _this29.secretStorage.getKey();
+      var secretStorageKeyTuple = yield _this30.secretStorage.getKey();
       if (!secretStorageKeyTuple) return false;
       var [, keyInfo] = secretStorageKeyTuple;
 
@@ -890,13 +900,13 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#getCrossSigningStatus}
    */
   getCrossSigningStatus() {
-    var _this30 = this;
+    var _this31 = this;
     return _asyncToGenerator(function* () {
-      var userIdentity = yield _this30.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(_this30.userId));
+      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(_this30.secretStorage);
-      var crossSigningStatus = yield _this30.getOlmMachineOrThrow().crossSigningStatus();
+      var privateKeysInSecretStorage = yield secretStorageContainsCrossSigningKeys(_this31.secretStorage);
+      var crossSigningStatus = yield _this31.getOlmMachineOrThrow().crossSigningStatus();
       return {
         publicKeysOnDevice,
         privateKeysInSecretStorage,
@@ -913,19 +923,19 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#createRecoveryKeyFromPassphrase}
    */
   createRecoveryKeyFromPassphrase(password) {
-    var _this31 = this;
+    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, _this31.RECOVERY_KEY_DERIVATION_ITERATIONS);
+        var recoveryKey = yield deriveRecoveryKeyFromPassphrase(password, salt, _this32.RECOVERY_KEY_DERIVATION_ITERATIONS);
         return {
           keyInfo: {
             passphrase: {
               algorithm: "m.pbkdf2",
-              iterations: _this31.RECOVERY_KEY_DERIVATION_ITERATIONS,
+              iterations: _this32.RECOVERY_KEY_DERIVATION_ITERATIONS,
               salt
             }
           },
@@ -948,9 +958,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#getEncryptionInfoForEvent}.
    */
   getEncryptionInfoForEvent(event) {
-    var _this32 = this;
+    var _this33 = this;
     return _asyncToGenerator(function* () {
-      return _this32.eventDecryptor.getEncryptionInfoForEvent(event);
+      return _this33.eventDecryptor.getEncryptionInfoForEvent(event);
     })();
   }
 
@@ -997,13 +1007,13 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#requestVerificationDM}
    */
   requestVerificationDM(userId, roomId) {
-    var _this33 = this;
+    var _this34 = this;
     return _asyncToGenerator(function* () {
-      var userIdentity = yield _this33.olmMachine.getIdentity(new RustSdkCryptoJs.UserId(userId));
+      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 = _this33._supportedVerificationMethods.map(method => verificationMethodIdentifierToMethod(method));
+        var methods = _this34._supportedVerificationMethods.map(method => verificationMethodIdentifierToMethod(method));
         // Get the request content to send to the DM room
         var verCont = yield userIdentity.verificationRequestContent(methods);
 
@@ -1013,11 +1023,11 @@ export class RustCrypto extends TypedEventEmitter {
         var verificationEventContent = JSON.stringify(verContObj);
 
         // Send the request content to send to the DM room
-        var eventId = yield _this33.sendVerificationRequestContent(roomId, verificationEventContent);
+        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 _this33.makeVerificationRequest(request);
+        return _this34.makeVerificationRequest(request);
       } finally {
         userIdentity.free();
       }
@@ -1036,13 +1046,13 @@ export class RustCrypto extends TypedEventEmitter {
    * @returns the event id
    */
   sendVerificationRequestContent(roomId, verificationEventContent) {
-    var _this34 = this;
+    var _this35 = this;
     return _asyncToGenerator(function* () {
       var txId = secureRandomString(32);
       // Send the verification request content to the DM room
       var {
         event_id: eventId
-      } = yield _this34.http.authedRequest(Method.Put, "/_matrix/client/v3/rooms/".concat(encodeURIComponent(roomId), "/send/m.room.message/").concat(encodeURIComponent(txId)), undefined, verificationEventContent, {
+      } = yield _this35.http.authedRequest(Method.Put, "/_matrix/client/v3/rooms/".concat(encodeURIComponent(roomId), "/send/m.room.message/").concat(encodeURIComponent(txId)), undefined, verificationEventContent, {
         prefix: ""
       });
       return eventId;
@@ -1068,16 +1078,16 @@ export class RustCrypto extends TypedEventEmitter {
    * @returns a VerificationRequest when the request has been sent to the other party.
    */
   requestOwnUserVerification() {
-    var _this35 = this;
+    var _this36 = this;
     return _asyncToGenerator(function* () {
-      var userIdentity = yield _this35.olmMachine.getIdentity(new RustSdkCryptoJs.UserId(_this35.userId));
+      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 [request, outgoingRequest] = yield userIdentity.requestVerification(_this35._supportedVerificationMethods.map(verificationMethodIdentifierToMethod));
-        yield _this35.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
-        return _this35.makeVerificationRequest(request);
+        var [request, outgoingRequest] = yield userIdentity.requestVerification(_this36._supportedVerificationMethods.map(verificationMethodIdentifierToMethod));
+        yield _this36.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
+        return _this36.makeVerificationRequest(request);
       } finally {
         userIdentity.free();
       }
@@ -1097,16 +1107,16 @@ export class RustCrypto extends TypedEventEmitter {
    * @returns a VerificationRequest when the request has been sent to the other party.
    */
   requestDeviceVerification(userId, deviceId) {
-    var _this36 = this;
+    var _this37 = this;
     return _asyncToGenerator(function* () {
-      var device = yield _this36.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(deviceId));
+      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 [request, outgoingRequest] = device.requestVerification(_this36._supportedVerificationMethods.map(verificationMethodIdentifierToMethod));
-        yield _this36.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
-        return _this36.makeVerificationRequest(request);
+        var [request, outgoingRequest] = device.requestVerification(_this37._supportedVerificationMethods.map(verificationMethodIdentifierToMethod));
+        yield _this37.outgoingRequestProcessor.makeOutgoingRequest(outgoingRequest);
+        return _this37.makeVerificationRequest(request);
       } finally {
         device.free();
       }
@@ -1121,9 +1131,9 @@ export class RustCrypto extends TypedEventEmitter {
    * @returns the key, if any, or null
    */
   getSessionBackupPrivateKey() {
-    var _this37 = this;
+    var _this38 = this;
     return _asyncToGenerator(function* () {
-      var backupKeys = yield _this37.olmMachine.getBackupKeys();
+      var backupKeys = yield _this38.olmMachine.getBackupKeys();
       if (!backupKeys.decryptionKey) return null;
       return decodeBase64(backupKeys.decryptionKey.toBase64());
     })();
@@ -1138,13 +1148,13 @@ export class RustCrypto extends TypedEventEmitter {
    * @param version - the backup version for this key.
    */
   storeSessionBackupPrivateKey(key, version) {
-    var _this38 = this;
+    var _this39 = this;
     return _asyncToGenerator(function* () {
       var base64Key = encodeBase64(key);
       if (!version) {
         throw new Error("storeSessionBackupPrivateKey: version is required");
       }
-      yield _this38.backupManager.saveBackupDecryptionKey(RustSdkCryptoJs.BackupDecryptionKey.fromBase64(base64Key), version);
+      yield _this39.backupManager.saveBackupDecryptionKey(RustSdkCryptoJs.BackupDecryptionKey.fromBase64(base64Key), version);
     })();
   }
 
@@ -1152,13 +1162,13 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#loadSessionBackupPrivateKeyFromSecretStorage}.
    */
   loadSessionBackupPrivateKeyFromSecretStorage() {
-    var _this39 = this;
+    var _this40 = this;
     return _asyncToGenerator(function* () {
-      var backupKey = yield _this39.secretStorage.get("m.megolm_backup.v1");
+      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 _this39.backupManager.getServerBackupInfo();
+      var keyBackupInfo = yield _this40.backupManager.getServerBackupInfo();
       if (!keyBackupInfo || !keyBackupInfo.version) {
         throw new Error("loadSessionBackupPrivateKeyFromSecretStorage: unable to get backup version");
       }
@@ -1166,7 +1176,7 @@ export class RustCrypto extends TypedEventEmitter {
       if (!decryptionKeyMatchesKeyBackupInfo(backupDecryptionKey, keyBackupInfo)) {
         throw new DecryptionKeyDoesNotMatchError("loadSessionBackupPrivateKeyFromSecretStorage: decryption key does not match backup info");
       }
-      yield _this39.backupManager.saveBackupDecryptionKey(backupDecryptionKey, keyBackupInfo.version);
+      yield _this40.backupManager.saveBackupDecryptionKey(backupDecryptionKey, keyBackupInfo.version);
     })();
   }
 
@@ -1176,9 +1186,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#getActiveSessionBackupVersion}.
    */
   getActiveSessionBackupVersion() {
-    var _this40 = this;
+    var _this41 = this;
     return _asyncToGenerator(function* () {
-      return yield _this40.backupManager.getActiveBackupVersion();
+      return yield _this41.backupManager.getActiveBackupVersion();
     })();
   }
 
@@ -1186,9 +1196,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#getKeyBackupInfo}.
    */
   getKeyBackupInfo() {
-    var _this41 = this;
+    var _this42 = this;
     return _asyncToGenerator(function* () {
-      return (yield _this41.backupManager.getServerBackupInfo()) || null;
+      return (yield _this42.backupManager.getServerBackupInfo()) || null;
     })();
   }
 
@@ -1198,9 +1208,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#isKeyBackupTrusted}.
    */
   isKeyBackupTrusted(info) {
-    var _this42 = this;
+    var _this43 = this;
     return _asyncToGenerator(function* () {
-      return yield _this42.backupManager.isKeyBackupTrusted(info);
+      return yield _this43.backupManager.isKeyBackupTrusted(info);
     })();
   }
 
@@ -1210,9 +1220,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#checkKeyBackupAndEnable}.
    */
   checkKeyBackupAndEnable() {
-    var _this43 = this;
+    var _this44 = this;
     return _asyncToGenerator(function* () {
-      return yield _this43.backupManager.checkKeyBackupAndEnable(true);
+      return yield _this44.backupManager.checkKeyBackupAndEnable(true);
     })();
   }
 
@@ -1220,9 +1230,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#deleteKeyBackupVersion}.
    */
   deleteKeyBackupVersion(version) {
-    var _this44 = this;
+    var _this45 = this;
     return _asyncToGenerator(function* () {
-      yield _this44.backupManager.deleteKeyBackupVersion(version);
+      yield _this45.backupManager.deleteKeyBackupVersion(version);
     })();
   }
 
@@ -1230,18 +1240,18 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#resetKeyBackup}.
    */
   resetKeyBackup() {
-    var _this45 = this;
+    var _this46 = this;
     return _asyncToGenerator(function* () {
-      var backupInfo = yield _this45.backupManager.setupKeyBackup(o => _this45.signObject(o));
+      var backupInfo = yield _this46.backupManager.setupKeyBackup(o => _this46.signObject(o));
 
       // we want to store the private key in 4S
       // need to check if 4S is set up?
-      if (yield _this45.secretStorageHasAESKey()) {
-        yield _this45.secretStorage.store("m.megolm_backup.v1", backupInfo.decryptionKey.toBase64());
+      if (yield _this46.secretStorageHasAESKey()) {
+        yield _this46.secretStorage.store("m.megolm_backup.v1", backupInfo.decryptionKey.toBase64());
       }
 
       // we can check and start async
-      _this45.checkKeyBackupAndEnable();
+      _this46.checkKeyBackupAndEnable();
     })();
   }
 
@@ -1249,19 +1259,19 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#disableKeyStorage}.
    */
   disableKeyStorage() {
-    var _this46 = this;
+    var _this47 = this;
     return _asyncToGenerator(function* () {
       // Get the key backup version we're using
-      var info = yield _this46.getKeyBackupInfo();
+      var info = yield _this47.getKeyBackupInfo();
       if (info !== null && info !== void 0 && info.version) {
-        yield _this46.deleteKeyBackupVersion(info.version);
+        yield _this47.deleteKeyBackupVersion(info.version);
       } else {
-        _this46.logger.error("Can't delete key backup version: no version available");
+        _this47.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 _this46.deleteSecretStorage();
-      yield _this46.dehydratedDeviceManager.delete();
+      yield _this47.deleteSecretStorage();
+      yield _this47.dehydratedDeviceManager.delete();
     })();
   }
 
@@ -1274,17 +1284,17 @@ export class RustCrypto extends TypedEventEmitter {
    * @param obj - The object to sign
    */
   signObject(obj) {
-    var _this47 = this;
+    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(_this47.userId) || {};
+      var userSignatures = sigs.get(_this48.userId) || {};
       var canonalizedJson = anotherjson.stringify(obj);
-      var signatures = yield _this47.olmMachine.sign(canonalizedJson);
+      var signatures = yield _this48.olmMachine.sign(canonalizedJson);
       var map = JSON.parse(signatures.asJSON());
-      sigs.set(_this47.userId, _objectSpread(_objectSpread({}, userSignatures), map[_this47.userId]));
+      sigs.set(_this48.userId, _objectSpread(_objectSpread({}, userSignatures), map[_this48.userId]));
       if (unsigned !== undefined) obj.unsigned = unsigned;
       obj.signatures = Object.fromEntries(sigs.entries());
     })();
@@ -1294,17 +1304,17 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#restoreKeyBackupWithPassphrase}.
    */
   restoreKeyBackupWithPassphrase(passphrase, opts) {
-    var _this48 = this;
+    var _this49 = this;
     return _asyncToGenerator(function* () {
-      var backupInfo = yield _this48.backupManager.getServerBackupInfo();
+      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);
 
       // Cache the key
-      yield _this48.storeSessionBackupPrivateKey(privateKey, backupInfo.version);
-      return _this48.restoreKeyBackup(opts);
+      yield _this49.storeSessionBackupPrivateKey(privateKey, backupInfo.version);
+      return _this49.restoreKeyBackup(opts);
     })();
   }
 
@@ -1312,25 +1322,25 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#restoreKeyBackup}.
    */
   restoreKeyBackup(opts) {
-    var _this49 = this;
+    var _this50 = this;
     return _asyncToGenerator(function* () {
       // Get the decryption key from the crypto store
-      var backupKeys = yield _this49.olmMachine.getBackupKeys();
+      var backupKeys = yield _this50.olmMachine.getBackupKeys();
       var {
         decryptionKey,
         backupVersion
       } = backupKeys;
       if (!decryptionKey || !backupVersion) throw new Error("No decryption key found in crypto store");
       var decodedDecryptionKey = decodeBase64(decryptionKey.toBase64());
-      var backupInfo = yield _this49.backupManager.requestKeyBackupVersion(backupVersion);
+      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 _this49.getBackupDecryptor(backupInfo, decodedDecryptionKey);
+      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 _this49.backupManager.restoreKeyBackup(backupVersion, backupDecryptor, opts);
+        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();
@@ -1342,9 +1352,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#isDehydrationSupported}.
    */
   isDehydrationSupported() {
-    var _this50 = this;
+    var _this51 = this;
     return _asyncToGenerator(function* () {
-      return yield _this50.dehydratedDeviceManager.isSupported();
+      return yield _this51.dehydratedDeviceManager.isSupported();
     })();
   }
 
@@ -1353,13 +1363,13 @@ export class RustCrypto extends TypedEventEmitter {
    */
   startDehydration() {
     var _arguments6 = arguments,
-      _this51 = this;
+      _this52 = this;
     return _asyncToGenerator(function* () {
       var opts = _arguments6.length > 0 && _arguments6[0] !== undefined ? _arguments6[0] : {};
-      if (!(yield _this51.isCrossSigningReady()) || !(yield _this51.isSecretStorageReady())) {
+      if (!(yield _this52.isCrossSigningReady()) || !(yield _this52.isSecretStorageReady())) {
         throw new Error("Device dehydration requires cross-signing and secret storage to be set up");
       }
-      return yield _this51.dehydratedDeviceManager.start(opts || {});
+      return yield _this52.dehydratedDeviceManager.start(opts || {});
     })();
   }
 
@@ -1367,10 +1377,10 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#importSecretsBundle}.
    */
   importSecretsBundle(secrets) {
-    var _this52 = this;
+    var _this53 = this;
     return _asyncToGenerator(function* () {
       var secretsBundle = RustSdkCryptoJs.SecretsBundle.from_json(secrets);
-      yield _this52.getOlmMachineOrThrow().importSecretsBundle(secretsBundle); // this method frees the SecretsBundle
+      yield _this53.getOlmMachineOrThrow().importSecretsBundle(secretsBundle); // this method frees the SecretsBundle
     })();
   }
 
@@ -1378,9 +1388,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#exportSecretsBundle}.
    */
   exportSecretsBundle() {
-    var _this53 = this;
+    var _this54 = this;
     return _asyncToGenerator(function* () {
-      var secretsBundle = yield _this53.getOlmMachineOrThrow().exportSecretsBundle();
+      var secretsBundle = yield _this54.getOlmMachineOrThrow().exportSecretsBundle();
       var secrets = secretsBundle.to_json();
       secretsBundle.free();
       return secrets;
@@ -1391,9 +1401,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#encryptToDeviceMessages}.
    */
   encryptToDeviceMessages(eventType, devices, payload) {
-    var _this54 = this;
+    var _this55 = this;
     return _asyncToGenerator(function* () {
-      var logger = new LogSpan(_this54.logger, "encryptToDeviceMessages");
+      var logger = new LogSpan(_this55.logger, "encryptToDeviceMessages");
       var uniqueUsers = new Set(devices.map(_ref2 => {
         var {
           userId
@@ -1404,7 +1414,7 @@ export class RustCrypto extends TypedEventEmitter {
       // 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 _this54.keyClaimManager.ensureSessionsForUsers(logger, Array.from(uniqueUsers).map(userId => new RustSdkCryptoJs.UserId(userId)));
+      yield _this55.keyClaimManager.ensureSessionsForUsers(logger, Array.from(uniqueUsers).map(userId => new RustSdkCryptoJs.UserId(userId)));
       var batch = {
         batch: [],
         eventType: EventType.RoomMessageEncrypted
@@ -1415,7 +1425,7 @@ export class RustCrypto extends TypedEventEmitter {
             userId,
             deviceId
           } = _ref3;
-          var device = yield _this54.olmMachine.getDevice(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.DeviceId(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({
@@ -1424,7 +1434,7 @@ export class RustCrypto extends TypedEventEmitter {
               payload: encryptedPayload
             });
           } else {
-            _this54.logger.warn("encryptToDeviceMessages: unknown device ".concat(userId, ":").concat(deviceId));
+            _this55.logger.warn("encryptToDeviceMessages: unknown device ".concat(userId, ":").concat(deviceId));
           }
         });
         return function (_x) {
@@ -1439,27 +1449,27 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#resetEncryption}.
    */
   resetEncryption(authUploadDeviceSigningKeys) {
-    var _this55 = this;
+    var _this56 = this;
     return _asyncToGenerator(function* () {
-      _this55.logger.debug("resetEncryption: resetting encryption");
+      _this56.logger.debug("resetEncryption: resetting encryption");
 
       // Delete the dehydrated device, since any existing one will be signed
       // by the wrong cross-signing key
-      _this55.dehydratedDeviceManager.delete();
+      _this56.dehydratedDeviceManager.delete();
 
       // Disable backup, and delete all the backups from the server
-      yield _this55.backupManager.deleteAllKeyBackupVersions();
-      yield _this55.deleteSecretStorage();
+      yield _this56.backupManager.deleteAllKeyBackupVersions();
+      yield _this56.deleteSecretStorage();
 
       // Reset the cross-signing keys
-      yield _this55.crossSigningIdentity.bootstrapCrossSigning({
+      yield _this56.crossSigningIdentity.bootstrapCrossSigning({
         setupNewCrossSigning: true,
         authUploadDeviceSigningKeys
       });
 
       // Create a new key backup
-      yield _this55.resetKeyBackup();
-      _this55.logger.debug("resetEncryption: ended");
+      yield _this56.resetKeyBackup();
+      _this56.logger.debug("resetEncryption: ended");
     })();
   }
 
@@ -1468,19 +1478,19 @@ export class RustCrypto extends TypedEventEmitter {
    * from the user's account data
    */
   deleteSecretStorage() {
-    var _this56 = this;
+    var _this57 = this;
     return _asyncToGenerator(function* () {
       // Remove the stored secrets in the secret storage
-      yield _this56.secretStorage.store("m.cross_signing.master", null);
-      yield _this56.secretStorage.store("m.cross_signing.self_signing", null);
-      yield _this56.secretStorage.store("m.cross_signing.user_signing", null);
-      yield _this56.secretStorage.store("m.megolm_backup.v1", null);
+      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);
 
       // Remove the recovery key
-      var defaultKeyId = yield _this56.secretStorage.getDefaultKeyId();
-      if (defaultKeyId) yield _this56.secretStorage.store("m.secret_storage.key.".concat(defaultKeyId), null);
+      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 _this56.secretStorage.setDefaultKeyId(null);
+      yield _this57.secretStorage.setDefaultKeyId(null);
     })();
   }
 
@@ -1488,12 +1498,12 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#shareRoomHistoryWithUser}.
    */
   shareRoomHistoryWithUser(roomId, userId) {
-    var _this57 = this;
+    var _this58 = this;
     return _asyncToGenerator(function* () {
-      var logger = new LogSpan(_this57.logger, "shareRoomHistoryWithUser(".concat(roomId, ", ").concat(userId, ")"));
+      var logger = new LogSpan(_this58.logger, "shareRoomHistoryWithUser(".concat(roomId, ", ").concat(userId, ")"));
 
       // 0. We can only share room history if our user has set up cross-signing.
-      var identity = yield _this57.getOwnIdentity();
+      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;
@@ -1501,33 +1511,33 @@ export class RustCrypto extends TypedEventEmitter {
       logger.info("Sharing message history");
 
       // 1. Download keys from backup.
-      if (!(yield _this57.getOlmMachineOrThrow().hasDownloadedAllRoomKeys(new RustSdkCryptoJs.RoomId(roomId)))) {
-        yield _this57.backupManager.downloadLatestRoomKeyBackup(roomId);
-        yield _this57.getOlmMachineOrThrow().setHasDownloadedAllRoomKeys(new RustSdkCryptoJs.RoomId(roomId));
+      if (!(yield _this58.getOlmMachineOrThrow().hasDownloadedAllRoomKeys(new RustSdkCryptoJs.RoomId(roomId)))) {
+        yield _this58.backupManager.downloadLatestRoomKeyBackup(roomId);
+        yield _this58.getOlmMachineOrThrow().setHasDownloadedAllRoomKeys(new RustSdkCryptoJs.RoomId(roomId));
       }
 
       // 2. Construct the key bundle
-      var bundle = yield _this57.getOlmMachineOrThrow().buildRoomKeyBundle(new RustSdkCryptoJs.RoomId(roomId));
+      var bundle = yield _this58.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 _this57.http.uploadContent(bundle.encryptedData);
+      var uploadResponse = yield _this58.http.uploadContent(bundle.encryptedData);
       logger.info("Uploaded encrypted key blob: ".concat(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 = _this57.getOlmMachineOrThrow().queryKeysForUsers([new RustSdkCryptoJs.UserId(userId)]);
-      yield _this57.outgoingRequestProcessor.makeOutgoingRequest(req);
+      var req = _this58.getOlmMachineOrThrow().queryKeysForUsers([new RustSdkCryptoJs.UserId(userId)]);
+      yield _this58.outgoingRequestProcessor.makeOutgoingRequest(req);
 
       // 5. Establish Olm sessions with all of the recipient's devices.
-      yield _this57.keyClaimManager.ensureSessionsForUsers(logger, [new RustSdkCryptoJs.UserId(userId)]);
+      yield _this58.keyClaimManager.ensureSessionsForUsers(logger, [new RustSdkCryptoJs.UserId(userId)]);
 
       // 6. Send to-device messages to the recipient to share the keys.
-      var requests = yield _this57.getOlmMachineOrThrow().shareRoomKeyBundleData(new RustSdkCryptoJs.UserId(userId), new RustSdkCryptoJs.RoomId(roomId), uploadResponse.content_uri, bundle.mediaEncryptionInfo, RustSdkCryptoJs.CollectStrategy.identityBasedStrategy());
+      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 _this57.outgoingRequestProcessor.makeOutgoingRequest(_req);
+        yield _this58.outgoingRequestProcessor.makeOutgoingRequest(_req);
       }
     })();
   }
@@ -1547,7 +1557,7 @@ export class RustCrypto extends TypedEventEmitter {
    * @returns A list of processed to-device messages.
    */
   receiveSyncChanges(_ref5) {
-    var _this58 = this;
+    var _this59 = this;
     return _asyncToGenerator(function* () {
       var {
         events,
@@ -1555,7 +1565,7 @@ export class RustCrypto extends TypedEventEmitter {
         unusedFallbackKeys,
         devices = new RustSdkCryptoJs.DeviceLists()
       } = _ref5;
-      return yield _this58.olmMachine.receiveSyncChanges(events ? JSON.stringify(events) : "[]", devices, oneTimeKeysCounts, unusedFallbackKeys);
+      return yield _this59.olmMachine.receiveSyncChanges(events ? JSON.stringify(events) : "[]", devices, oneTimeKeysCounts, unusedFallbackKeys);
     })();
   }
 
@@ -1565,11 +1575,11 @@ export class RustCrypto extends TypedEventEmitter {
    * @returns A list of preprocessed to-device messages.
    */
   preprocessToDeviceMessages(events) {
-    var _this59 = this;
+    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 _this59.receiveSyncChanges({
+      var processed = yield _this60.receiveSyncChanges({
         events
       });
       var received = [];
@@ -1581,7 +1591,7 @@ export class RustCrypto extends TypedEventEmitter {
           var sender = parsedMessage.sender;
           var transactionId = parsedMessage.content.transaction_id;
           if (transactionId && sender) {
-            _this59.onIncomingKeyVerificationRequest(sender, transactionId);
+            _this60.onIncomingKeyVerificationRequest(sender, transactionId);
           }
         }
         switch (message.type) {
@@ -1599,23 +1609,28 @@ export class RustCrypto extends TypedEventEmitter {
                 }
               });
 
-              // If we have received a room key bundle message, and have previously marked the room
-              // IDs it references as pending key bundles, tell the Rust SDK to try and accept it,
-              // just in case it was received after invite.
+              // 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) && _this59.roomsPendingKeyBundles.has(parsedMessage.content.room_id)) {
-                // No `await`-ing here, as this is called from inside the `/sync` loop.
-                _this59.maybeAcceptKeyBundle(parsedMessage.content.room_id, _this59.roomsPendingKeyBundles.get(parsedMessage.content.room_id)).then(success => {
-                  if (success) {
-                    _this59.roomsPendingKeyBundles.delete(parsedMessage.content.room_id);
-                  }
-                }, err => {
-                  _this59.logger.error("Error attempting to download key bundle for room ".concat(parsedMessage.content.room_id));
-                  _this59.logger.error(err);
-                });
+              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);
+                  });
+                }
               }
               break;
             }
@@ -1648,12 +1663,12 @@ export class RustCrypto extends TypedEventEmitter {
    * @param unusedFallbackKeys - the received unused fallback keys
    */
   processKeyCounts(oneTimeKeysCounts, unusedFallbackKeys) {
-    var _this60 = this;
+    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 _this60.receiveSyncChanges({
+        yield _this61.receiveSyncChanges({
           oneTimeKeysCounts: mapOneTimeKeysCount,
           unusedFallbackKeys: setUnusedFallbackKeys
         });
@@ -1667,11 +1682,11 @@ export class RustCrypto extends TypedEventEmitter {
    * @param deviceLists - device_lists field from /sync
    */
   processDeviceLists(deviceLists) {
-    var _this61 = this;
+    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 _this61.receiveSyncChanges({
+      yield _this62.receiveSyncChanges({
         devices
       });
     })();
@@ -1683,7 +1698,7 @@ export class RustCrypto extends TypedEventEmitter {
    * @param event - encryption event to be processed
    */
   onCryptoEvent(room, event) {
-    var _this62 = this;
+    var _this63 = this;
     return _asyncToGenerator(function* () {
       var config = event.getContent();
       var settings = new RustSdkCryptoJs.RoomSettings();
@@ -1691,29 +1706,29 @@ export class RustCrypto extends TypedEventEmitter {
         settings.algorithm = RustSdkCryptoJs.EncryptionAlgorithm.MegolmV1AesSha2;
       } else {
         // Among other situations, this happens if the crypto state event is redacted.
-        _this62.logger.warn("Room ".concat(room.roomId, ": ignoring crypto event with invalid algorithm ").concat(config.algorithm));
+        _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"] && _this62.enableEncryptedStateEvents) {
-        _this62.logger.info("crypto Enabling state event encryption...");
+      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 _this62.olmMachine.setRoomSettings(new RustSdkCryptoJs.RoomId(room.roomId), settings);
+        yield _this63.olmMachine.setRoomSettings(new RustSdkCryptoJs.RoomId(room.roomId), settings);
       } catch (e) {
-        _this62.logger.warn("Room ".concat(room.roomId, ": ignoring crypto event which caused error: ").concat(e));
+        _this63.logger.warn("Room ".concat(room.roomId, ": ignoring crypto event which caused error: ").concat(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 = _this62.roomEncryptors[room.roomId];
+      var existingEncryptor = _this63.roomEncryptors[room.roomId];
       if (existingEncryptor) {
         existingEncryptor.onCryptoEvent(config);
       } else {
-        _this62.roomEncryptors[room.roomId] = new RoomEncryptor(_this62.logger.getChild("[".concat(room.roomId, " encryption]")), _this62.olmMachine, _this62.keyClaimManager, _this62.outgoingRequestsManager, room, config);
+        _this63.roomEncryptors[room.roomId] = new RoomEncryptor(_this63.logger.getChild("[".concat(room.roomId, " encryption]")), _this63.olmMachine, _this63.keyClaimManager, _this63.outgoingRequestsManager, room, config);
       }
     })();
   }
@@ -1735,9 +1750,9 @@ export class RustCrypto extends TypedEventEmitter {
    * Implementation of {@link CryptoApi#markAllTrackedUsersAsDirty}.
    */
   markAllTrackedUsersAsDirty() {
-    var _this63 = this;
+    var _this64 = this;
     return _asyncToGenerator(function* () {
-      yield _this63.olmMachine.markAllTrackedUsersAsDirty();
+      yield _this64.olmMachine.markAllTrackedUsersAsDirty();
     })();
   }
 
@@ -1777,7 +1792,16 @@ export class RustCrypto extends TypedEventEmitter {
    * @param oldMembership - The previous membership state. Null if it's a new member.
    */
   onRoomMembership(event, member, oldMembership) {
-    var enc = this.roomEncryptors[event.getRoomId()];
+    var 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));
+      });
+    }
+    var enc = this.roomEncryptors[roomId];
     if (!enc) {
       // not encrypting in this room
       return;
@@ -1794,16 +1818,16 @@ export class RustCrypto extends TypedEventEmitter {
    * @param keys - details of the updated keys
    */
   onRoomKeysUpdated(keys) {
-    var _this64 = this;
+    var _this65 = this;
     return _asyncToGenerator(function* () {
       for (var key of keys) {
-        _this64.onRoomKeyUpdated(key);
+        _this65.onRoomKeyUpdated(key);
       }
-      _this64.backupManager.maybeUploadKey();
+      _this65.backupManager.maybeUploadKey();
     })();
   }
   onRoomKeyUpdated(key) {
-    var _this65 = this;
+    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);
@@ -1817,10 +1841,10 @@ export class RustCrypto extends TypedEventEmitter {
     // 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(_this65, {
+      ev.attemptDecryption(_this66, {
         isRetry: true
       }).catch(_e => {
-        _this65.logger.info("Still unable to decrypt event ".concat(ev.getId(), " after receiving key"));
+        _this66.logger.info("Still unable to decrypt event ".concat(ev.getId(), " after receiving key"));
       });
     };
     for (var ev of pendingList) {
@@ -1837,17 +1861,17 @@ export class RustCrypto extends TypedEventEmitter {
    * @param withheld - Details of the withheld sessions.
    */
   onRoomKeysWithheld(withheld) {
-    var _this66 = this;
+    var _this67 = this;
     return _asyncToGenerator(function* () {
       for (var session of withheld) {
-        _this66.logger.debug("Got withheld message for session ".concat(session.sessionId, " in ").concat(session.roomId.toString()));
-        var pendingList = _this66.eventDecryptor.getEventsPendingRoomKey(session.roomId.toString(), session.sessionId);
+        _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.
-        _this66.logger.debug("Retrying decryption on events:", pendingList.map(e => "".concat(e.getId())));
+        _this67.logger.debug("Retrying decryption on events:", pendingList.map(e => "".concat(e.getId())));
         for (var ev of pendingList) {
-          ev.attemptDecryption(_this66, {
+          ev.attemptDecryption(_this67, {
             isRetry: true
           }).catch(_e => {
             // It's somewhat expected that we still can't decrypt here.
@@ -1866,16 +1890,16 @@ export class RustCrypto extends TypedEventEmitter {
    * @param userId - the user with the updated identity
    */
   onUserIdentityUpdated(userId) {
-    var _this67 = this;
+    var _this68 = this;
     return _asyncToGenerator(function* () {
-      var newVerification = yield _this67.getUserVerificationStatus(userId.toString());
-      _this67.emit(CryptoEvent.UserTrustStatusChanged, userId.toString(), newVerification);
+      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() === _this67.userId) {
-        _this67.emit(CryptoEvent.KeysChanged, {});
-        yield _this67.checkKeyBackupAndEnable();
+      if (userId.toString() === _this68.userId) {
+        _this68.emit(CryptoEvent.KeysChanged, {});
+        yield _this68.checkKeyBackupAndEnable();
       }
     })();
   }
@@ -1891,10 +1915,10 @@ export class RustCrypto extends TypedEventEmitter {
    * @param userIds - an array of user IDs of users whose devices have updated.
    */
   onDevicesUpdated(userIds) {
-    var _this68 = this;
+    var _this69 = this;
     return _asyncToGenerator(function* () {
-      _this68.emit(CryptoEvent.WillUpdateDevices, userIds, false);
-      _this68.emit(CryptoEvent.DevicesUpdated, userIds, false);
+      _this69.emit(CryptoEvent.WillUpdateDevices, userIds, false);
+      _this69.emit(CryptoEvent.DevicesUpdated, userIds, false);
     })();
   }
 
@@ -1911,11 +1935,11 @@ export class RustCrypto extends TypedEventEmitter {
    * @param value - the secret value
    */
   handleSecretReceived(name, value) {
-    var _this69 = this;
+    var _this70 = this;
     return _asyncToGenerator(function* () {
-      _this69.logger.debug("onReceiveSecret: Received secret ".concat(name));
+      _this70.logger.debug("onReceiveSecret: Received secret ".concat(name));
       if (name === "m.megolm_backup.v1") {
-        return yield _this69.backupManager.handleBackupSecretReceived(value);
+        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?
@@ -1933,11 +1957,11 @@ export class RustCrypto extends TypedEventEmitter {
    * @param name - The name of the secret received.
    */
   checkSecrets(name) {
-    var _this70 = this;
+    var _this71 = this;
     return _asyncToGenerator(function* () {
-      var pendingValues = yield _this70.olmMachine.getSecretsFromInbox(name);
+      var pendingValues = yield _this71.olmMachine.getSecretsFromInbox(name);
       for (var value of pendingValues) {
-        if (yield _this70.handleSecretReceived(name, value)) {
+        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;
@@ -1945,7 +1969,7 @@ export class RustCrypto extends TypedEventEmitter {
       }
 
       // Important to call this after handling the secrets as good hygiene.
-      yield _this70.olmMachine.deleteSecretsFromInbox(name);
+      yield _this71.olmMachine.deleteSecretsFromInbox(name);
     })();
   }
 
@@ -1956,7 +1980,7 @@ export class RustCrypto extends TypedEventEmitter {
    * @param event - live event
    */
   onLiveEventFromSync(event) {
-    var _this71 = this;
+    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}
@@ -1965,7 +1989,7 @@ export class RustCrypto extends TypedEventEmitter {
         var _ref6 = _asyncToGenerator(function* (evt) {
           // Process only verification event
           if (isVerificationEvent(event)) {
-            yield _this71.onKeyVerificationEvent(evt);
+            yield _this72.onKeyVerificationEvent(evt);
           }
         });
         return function processEvent(_x2) {
@@ -1999,7 +2023,7 @@ export class RustCrypto extends TypedEventEmitter {
    * @param event - a key validation request event.
    */
   onKeyVerificationEvent(event) {
-    var _this72 = this;
+    var _this73 = this;
     return _asyncToGenerator(function* () {
       var roomId = event.getRoomId();
       var senderId = event.getSender();
@@ -2009,7 +2033,7 @@ export class RustCrypto extends TypedEventEmitter {
       if (!senderId) {
         throw new Error("missing sender in the event");
       }
-      _this72.logger.debug("Incoming verification event ".concat(event.getId(), " type ").concat(event.getType(), " from ").concat(event.getSender()));
+      _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
@@ -2017,10 +2041,10 @@ export class RustCrypto extends TypedEventEmitter {
         // 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 = _this72.getOlmMachineOrThrow().queryKeysForUsers([new RustSdkCryptoJs.UserId(senderId)]);
-        yield _this72.outgoingRequestProcessor.makeOutgoingRequest(req);
+        var req = _this73.getOlmMachineOrThrow().queryKeysForUsers([new RustSdkCryptoJs.UserId(senderId)]);
+        yield _this73.outgoingRequestProcessor.makeOutgoingRequest(req);
       }
-      yield _this72.getOlmMachineOrThrow().receiveVerificationEvent(JSON.stringify({
+      yield _this73.getOlmMachineOrThrow().receiveVerificationEvent(JSON.stringify({
         event_id: event.getId(),
         type: event.getType(),
         sender: senderId,
@@ -2029,12 +2053,12 @@ export class RustCrypto extends TypedEventEmitter {
         origin_server_ts: event.getTs()
       }), new RustSdkCryptoJs.RoomId(roomId));
       if (isRoomVerificationRequest) {
-        _this72.onIncomingKeyVerificationRequest(senderId, event.getId());
+        _this73.onIncomingKeyVerificationRequest(senderId, event.getId());
       }
 
       // that may have caused us to queue up outgoing requests, so make sure we send them.
-      _this72.outgoingRequestsManager.doProcessOutgoingRequests().catch(e => {
-        _this72.logger.warn("onKeyVerificationRequest: Error processing outgoing requests", e);
+      _this73.outgoingRequestsManager.doProcessOutgoingRequests().catch(e => {
+        _this73.logger.warn("onKeyVerificationRequest: Error processing outgoing requests", e);
       });
     })();
   }
@@ -2046,9 +2070,10 @@ export class RustCrypto extends TypedEventEmitter {
    * Used during migration from legacy js-crypto to update local trust if needed.
    */
   getOwnIdentity() {
-    var _this73 = this;
+    var _this74 = this;
     return _asyncToGenerator(function* () {
-      return yield _this73.olmMachine.getIdentity(new RustSdkCryptoJs.UserId(_this73.userId));
+      var identity = yield _this74.getOlmMachineOrThrow().getIdentity(new RustSdkCryptoJs.UserId(_this74.userId));
+      return identity;
     })();
   }
 }
@@ -2065,13 +2090,13 @@ class EventDecryptor {
     _defineProperty(this, "eventsPendingKey", new MapWithDefault(() => new MapWithDefault(() => new Set())));
   }
   attemptEventDecryption(event, isolationMode) {
-    var _this74 = this;
+    var _this75 = 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)
-      _this74.addEventToPendingList(event);
+      _this75.addEventToPendingList(event);
       var trustRequirement;
       switch (isolationMode.kind) {
         case DeviceIsolationModeKind.AllDevicesIsolationMode:
@@ -2083,11 +2108,11 @@ class EventDecryptor {
       }
       try {
         var _res$forwarder;
-        var res = yield _this74.olmMachine.decryptRoomEvent(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()), new RustSdkCryptoJs.DecryptionSettings(trustRequirement));
+        var res = yield _this75.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.
-        _this74.removeEventFromPendingList(event);
+        _this75.removeEventFromPendingList(event);
         return {
           clearEvent: JSON.parse(res.event),
           claimedEd25519Key: res.senderClaimedEd25519Key,
@@ -2096,7 +2121,7 @@ class EventDecryptor {
         };
       } catch (err) {
         if (err instanceof RustSdkCryptoJs.MegolmDecryptionError) {
-          _this74.onMegolmDecryptionError(event, err, yield _this74.perSessionBackupDownloader.getServerBackupInfo());
+          _this75.onMegolmDecryptionError(event, err, yield _this75.perSessionBackupDownloader.getServerBackupInfo());
         } else {
           throw new DecryptionError(DecryptionFailureCode.UNKNOWN_ERROR, "Unknown error");
         }
@@ -2182,7 +2207,7 @@ class EventDecryptor {
     }
   }
   getEncryptionInfoForEvent(event) {
-    var _this75 = this;
+    var _this76 = this;
     return _asyncToGenerator(function* () {
       if (!event.getClearContent() || event.isDecryptionFailure()) {
         // not successfully decrypted
@@ -2196,8 +2221,8 @@ class EventDecryptor {
           shieldReason: null
         };
       }
-      var encryptionInfo = yield _this75.olmMachine.getRoomEventEncryptionInfo(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()));
-      return rustEncryptionInfoToJsEncryptionInfo(_this75.logger, encryptionInfo);
+      var encryptionInfo = yield _this76.olmMachine.getRoomEventEncryptionInfo(stringifyEvent(event), new RustSdkCryptoJs.RoomId(event.getRoomId()));
+      return rustEncryptionInfoToJsEncryptionInfo(_this76.logger, encryptionInfo);
     })();
   }