@unwanted/matrix-sdk-mini 34.12.0-1

package/lib/crypto/DeviceList.js

@@ -0,0 +1,892 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*
+Copyright 2017 - 2021 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/**
+ * Manages the list of other users' devices
+ */
+
+import { logger } from "../logger.js";
+import { DeviceInfo } from "./deviceinfo.js";
+import { CrossSigningInfo } from "./CrossSigning.js";
+import * as olmlib from "./olmlib.js";
+import { IndexedDBCryptoStore } from "./store/indexeddb-crypto-store.js";
+import { chunkPromises, defer, sleep } from "../utils.js";
+import { TypedEventEmitter } from "../models/typed-event-emitter.js";
+import { CryptoEvent } from "./index.js";
+
+/* State transition diagram for DeviceList.deviceTrackingStatus
+ *
+ *                                |
+ *     stopTrackingDeviceList     V
+ *   +---------------------> NOT_TRACKED
+ *   |                            |
+ *   +<--------------------+      | startTrackingDeviceList
+ *   |                     |      V
+ *   |   +-------------> PENDING_DOWNLOAD <--------------------+-+
+ *   |   |                      ^ |                            | |
+ *   |   | restart     download | |  start download            | | invalidateUserDeviceList
+ *   |   | client        failed | |                            | |
+ *   |   |                      | V                            | |
+ *   |   +------------ DOWNLOAD_IN_PROGRESS -------------------+ |
+ *   |                    |       |                              |
+ *   +<-------------------+       |  download successful         |
+ *   ^                            V                              |
+ *   +----------------------- UP_TO_DATE ------------------------+
+ */
+
+// constants for DeviceList.deviceTrackingStatus
+export var TrackingStatus = /*#__PURE__*/function (TrackingStatus) {
+  TrackingStatus[TrackingStatus["NotTracked"] = 0] = "NotTracked";
+  TrackingStatus[TrackingStatus["PendingDownload"] = 1] = "PendingDownload";
+  TrackingStatus[TrackingStatus["DownloadInProgress"] = 2] = "DownloadInProgress";
+  TrackingStatus[TrackingStatus["UpToDate"] = 3] = "UpToDate";
+  return TrackingStatus;
+}({});
+
+// user-Id → device-Id → DeviceInfo
+
+export class DeviceList extends TypedEventEmitter {
+  constructor(baseApis, cryptoStore, olmDevice) {
+    var keyDownloadChunkSize = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 250;
+    super();
+    this.cryptoStore = cryptoStore;
+    this.keyDownloadChunkSize = keyDownloadChunkSize;
+    _defineProperty(this, "devices", {});
+    _defineProperty(this, "crossSigningInfo", {});
+    // map of identity keys to the user who owns it
+    _defineProperty(this, "userByIdentityKey", {});
+    // which users we are tracking device status for.
+    _defineProperty(this, "deviceTrackingStatus", {});
+    // loaded from storage in load()
+    // The 'next_batch' sync token at the point the data was written,
+    // ie. a token representing the point immediately after the
+    // moment represented by the snapshot in the db.
+    _defineProperty(this, "syncToken", null);
+    _defineProperty(this, "keyDownloadsInProgressByUser", new Map());
+    // Set whenever changes are made other than setting the sync token
+    _defineProperty(this, "dirty", false);
+    // Promise resolved when device data is saved
+    _defineProperty(this, "savePromise", null);
+    // Function that resolves the save promise
+    _defineProperty(this, "resolveSavePromise", null);
+    // The time the save is scheduled for
+    _defineProperty(this, "savePromiseTime", null);
+    // The timer used to delay the save
+    _defineProperty(this, "saveTimer", null);
+    // True if we have fetched data from the server or loaded a non-empty
+    // set of device data from the store
+    _defineProperty(this, "hasFetched", null);
+    _defineProperty(this, "serialiser", void 0);
+    this.serialiser = new DeviceListUpdateSerialiser(baseApis, olmDevice, this);
+  }
+
+  /**
+   * Load the device tracking state from storage
+   */
+  load() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      yield _this.cryptoStore.doTxn("readonly", [IndexedDBCryptoStore.STORE_DEVICE_DATA], txn => {
+        _this.cryptoStore.getEndToEndDeviceData(txn, deviceData => {
+          var _deviceData$syncToken;
+          _this.hasFetched = Boolean(deviceData === null || deviceData === void 0 ? void 0 : deviceData.devices);
+          _this.devices = deviceData ? deviceData.devices : {};
+          _this.crossSigningInfo = deviceData ? deviceData.crossSigningInfo || {} : {};
+          _this.deviceTrackingStatus = deviceData ? deviceData.trackingStatus : {};
+          _this.syncToken = (_deviceData$syncToken = deviceData === null || deviceData === void 0 ? void 0 : deviceData.syncToken) !== null && _deviceData$syncToken !== void 0 ? _deviceData$syncToken : null;
+          _this.userByIdentityKey = {};
+          for (var user of Object.keys(_this.devices)) {
+            var userDevices = _this.devices[user];
+            for (var device of Object.keys(userDevices)) {
+              var idKey = userDevices[device].keys["curve25519:" + device];
+              if (idKey !== undefined) {
+                _this.userByIdentityKey[idKey] = user;
+              }
+            }
+          }
+        });
+      });
+      for (var u of Object.keys(_this.deviceTrackingStatus)) {
+        // if a download was in progress when we got shut down, it isn't any more.
+        if (_this.deviceTrackingStatus[u] == TrackingStatus.DownloadInProgress) {
+          _this.deviceTrackingStatus[u] = TrackingStatus.PendingDownload;
+        }
+      }
+    })();
+  }
+  stop() {
+    if (this.saveTimer !== null) {
+      clearTimeout(this.saveTimer);
+    }
+  }
+
+  /**
+   * Save the device tracking state to storage, if any changes are
+   * pending other than updating the sync token
+   *
+   * The actual save will be delayed by a short amount of time to
+   * aggregate multiple writes to the database.
+   *
+   * @param delay - Time in ms before which the save actually happens.
+   *     By default, the save is delayed for a short period in order to batch
+   *     multiple writes, but this behaviour can be disabled by passing 0.
+   *
+   * @returns true if the data was saved, false if
+   *     it was not (eg. because no changes were pending). The promise
+   *     will only resolve once the data is saved, so may take some time
+   *     to resolve.
+   */
+  saveIfDirty() {
+    var _arguments = arguments,
+      _this2 = this;
+    return _asyncToGenerator(function* () {
+      var delay = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : 500;
+      if (!_this2.dirty) return Promise.resolve(false);
+      // Delay saves for a bit so we can aggregate multiple saves that happen
+      // in quick succession (eg. when a whole room's devices are marked as known)
+
+      var targetTime = Date.now() + delay;
+      if (_this2.savePromiseTime && targetTime < _this2.savePromiseTime) {
+        // There's a save scheduled but for after we would like: cancel
+        // it & schedule one for the time we want
+        clearTimeout(_this2.saveTimer);
+        _this2.saveTimer = null;
+        _this2.savePromiseTime = null;
+        // (but keep the save promise since whatever called save before
+        // will still want to know when the save is done)
+      }
+      var savePromise = _this2.savePromise;
+      if (savePromise === null) {
+        savePromise = new Promise(resolve => {
+          _this2.resolveSavePromise = resolve;
+        });
+        _this2.savePromise = savePromise;
+      }
+      if (_this2.saveTimer === null) {
+        var resolveSavePromise = _this2.resolveSavePromise;
+        _this2.savePromiseTime = targetTime;
+        _this2.saveTimer = setTimeout(() => {
+          logger.log("Saving device tracking data", _this2.syncToken);
+
+          // null out savePromise now (after the delay but before the write),
+          // otherwise we could return the existing promise when the save has
+          // actually already happened.
+          _this2.savePromiseTime = null;
+          _this2.saveTimer = null;
+          _this2.savePromise = null;
+          _this2.resolveSavePromise = null;
+          _this2.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_DEVICE_DATA], txn => {
+            var _this2$syncToken;
+            _this2.cryptoStore.storeEndToEndDeviceData({
+              devices: _this2.devices,
+              crossSigningInfo: _this2.crossSigningInfo,
+              trackingStatus: _this2.deviceTrackingStatus,
+              syncToken: (_this2$syncToken = _this2.syncToken) !== null && _this2$syncToken !== void 0 ? _this2$syncToken : undefined
+            }, txn);
+          }).then(() => {
+            // The device list is considered dirty until the write completes.
+            _this2.dirty = false;
+            resolveSavePromise === null || resolveSavePromise === void 0 || resolveSavePromise(true);
+          }, err => {
+            logger.error("Failed to save device tracking data", _this2.syncToken);
+            logger.error(err);
+          });
+        }, delay);
+      }
+      return savePromise;
+    })();
+  }
+
+  /**
+   * Gets the sync token last set with setSyncToken
+   *
+   * @returns The sync token
+   */
+  getSyncToken() {
+    return this.syncToken;
+  }
+
+  /**
+   * Sets the sync token that the app will pass as the 'since' to the /sync
+   * endpoint next time it syncs.
+   * The sync token must always be set after any changes made as a result of
+   * data in that sync since setting the sync token to a newer one will mean
+   * those changed will not be synced from the server if a new client starts
+   * up with that data.
+   *
+   * @param st - The sync token
+   */
+  setSyncToken(st) {
+    this.syncToken = st;
+  }
+
+  /**
+   * Ensures up to date keys for a list of users are stored in the session store,
+   * downloading and storing them if they're not (or if forceDownload is
+   * true).
+   * @param userIds - The users to fetch.
+   * @param forceDownload - Always download the keys even if cached.
+   *
+   * @returns A promise which resolves to a map userId-\>deviceId-\>{@link DeviceInfo}.
+   */
+  downloadKeys(userIds, forceDownload) {
+    var usersToDownload = [];
+    var promises = [];
+    userIds.forEach(u => {
+      var trackingStatus = this.deviceTrackingStatus[u];
+      if (this.keyDownloadsInProgressByUser.has(u)) {
+        // already a key download in progress/queued for this user; its results
+        // will be good enough for us.
+        logger.log("downloadKeys: already have a download in progress for " + "".concat(u, ": awaiting its result"));
+        promises.push(this.keyDownloadsInProgressByUser.get(u));
+      } else if (forceDownload || trackingStatus != TrackingStatus.UpToDate) {
+        usersToDownload.push(u);
+      }
+    });
+    if (usersToDownload.length != 0) {
+      logger.log("downloadKeys: downloading for", usersToDownload);
+      var downloadPromise = this.doKeyDownload(usersToDownload);
+      promises.push(downloadPromise);
+    }
+    if (promises.length === 0) {
+      logger.log("downloadKeys: already have all necessary keys");
+    }
+    return Promise.all(promises).then(() => {
+      return this.getDevicesFromStore(userIds);
+    });
+  }
+
+  /**
+   * Get the stored device keys for a list of user ids
+   *
+   * @param userIds - the list of users to list keys for.
+   *
+   * @returns userId-\>deviceId-\>{@link DeviceInfo}.
+   */
+  getDevicesFromStore(userIds) {
+    var stored = new Map();
+    userIds.forEach(userId => {
+      var _this$getStoredDevice;
+      var deviceMap = new Map();
+      (_this$getStoredDevice = this.getStoredDevicesForUser(userId)) === null || _this$getStoredDevice === void 0 || _this$getStoredDevice.forEach(function (device) {
+        deviceMap.set(device.deviceId, device);
+      });
+      stored.set(userId, deviceMap);
+    });
+    return stored;
+  }
+
+  /**
+   * Returns a list of all user IDs the DeviceList knows about
+   *
+   * @returns All known user IDs
+   */
+  getKnownUserIds() {
+    return Object.keys(this.devices);
+  }
+
+  /**
+   * Get the stored device keys for a user id
+   *
+   * @param userId - the user to list keys for.
+   *
+   * @returns list of devices, or null if we haven't
+   * managed to get a list of devices for this user yet.
+   */
+  getStoredDevicesForUser(userId) {
+    var devs = this.devices[userId];
+    if (!devs) {
+      return null;
+    }
+    var res = [];
+    for (var deviceId in devs) {
+      if (devs.hasOwnProperty(deviceId)) {
+        res.push(DeviceInfo.fromStorage(devs[deviceId], deviceId));
+      }
+    }
+    return res;
+  }
+
+  /**
+   * Get the stored device data for a user, in raw object form
+   *
+   * @param userId - the user to get data for
+   *
+   * @returns `deviceId->{object}` devices, or undefined if
+   * there is no data for this user.
+   */
+  getRawStoredDevicesForUser(userId) {
+    return this.devices[userId];
+  }
+  getStoredCrossSigningForUser(userId) {
+    if (!this.crossSigningInfo[userId]) return null;
+    return CrossSigningInfo.fromStorage(this.crossSigningInfo[userId], userId);
+  }
+  storeCrossSigningForUser(userId, info) {
+    this.crossSigningInfo[userId] = info;
+    this.dirty = true;
+  }
+
+  /**
+   * Get the stored keys for a single device
+   *
+   *
+   * @returns device, or undefined
+   * if we don't know about this device
+   */
+  getStoredDevice(userId, deviceId) {
+    var devs = this.devices[userId];
+    if (!(devs !== null && devs !== void 0 && devs[deviceId])) {
+      return undefined;
+    }
+    return DeviceInfo.fromStorage(devs[deviceId], deviceId);
+  }
+
+  /**
+   * Get a user ID by one of their device's curve25519 identity key
+   *
+   * @param algorithm -  encryption algorithm
+   * @param senderKey -  curve25519 key to match
+   *
+   * @returns user ID
+   */
+  getUserByIdentityKey(algorithm, senderKey) {
+    if (algorithm !== olmlib.OLM_ALGORITHM && algorithm !== olmlib.MEGOLM_ALGORITHM) {
+      // we only deal in olm keys
+      return null;
+    }
+    return this.userByIdentityKey[senderKey];
+  }
+
+  /**
+   * Find a device by curve25519 identity key
+   *
+   * @param algorithm -  encryption algorithm
+   * @param senderKey -  curve25519 key to match
+   */
+  getDeviceByIdentityKey(algorithm, senderKey) {
+    var userId = this.getUserByIdentityKey(algorithm, senderKey);
+    if (!userId) {
+      return null;
+    }
+    var devices = this.devices[userId];
+    if (!devices) {
+      return null;
+    }
+    for (var deviceId in devices) {
+      if (!devices.hasOwnProperty(deviceId)) {
+        continue;
+      }
+      var device = devices[deviceId];
+      for (var keyId in device.keys) {
+        if (!device.keys.hasOwnProperty(keyId)) {
+          continue;
+        }
+        if (keyId.indexOf("curve25519:") !== 0) {
+          continue;
+        }
+        var deviceKey = device.keys[keyId];
+        if (deviceKey == senderKey) {
+          return DeviceInfo.fromStorage(device, deviceId);
+        }
+      }
+    }
+
+    // doesn't match a known device
+    return null;
+  }
+
+  /**
+   * Replaces the list of devices for a user with the given device list
+   *
+   * @param userId - The user ID
+   * @param devices - New device info for user
+   */
+  storeDevicesForUser(userId, devices) {
+    this.setRawStoredDevicesForUser(userId, devices);
+    this.dirty = true;
+  }
+
+  /**
+   * flag the given user for device-list tracking, if they are not already.
+   *
+   * This will mean that a subsequent call to refreshOutdatedDeviceLists()
+   * will download the device list for the user, and that subsequent calls to
+   * invalidateUserDeviceList will trigger more updates.
+   *
+   */
+  startTrackingDeviceList(userId) {
+    // sanity-check the userId. This is mostly paranoia, but if synapse
+    // can't parse the userId we give it as an mxid, it 500s the whole
+    // request and we can never update the device lists again (because
+    // the broken userId is always 'invalid' and always included in any
+    // refresh request).
+    // By checking it is at least a string, we can eliminate a class of
+    // silly errors.
+    if (typeof userId !== "string") {
+      throw new Error("userId must be a string; was " + userId);
+    }
+    if (!this.deviceTrackingStatus[userId]) {
+      logger.log("Now tracking device list for " + userId);
+      this.deviceTrackingStatus[userId] = TrackingStatus.PendingDownload;
+      // we don't yet persist the tracking status, since there may be a lot
+      // of calls; we save all data together once the sync is done
+      this.dirty = true;
+    }
+  }
+
+  /**
+   * Mark the given user as no longer being tracked for device-list updates.
+   *
+   * This won't affect any in-progress downloads, which will still go on to
+   * complete; it will just mean that we don't think that we have an up-to-date
+   * list for future calls to downloadKeys.
+   *
+   */
+  stopTrackingDeviceList(userId) {
+    if (this.deviceTrackingStatus[userId]) {
+      logger.log("No longer tracking device list for " + userId);
+      this.deviceTrackingStatus[userId] = TrackingStatus.NotTracked;
+
+      // we don't yet persist the tracking status, since there may be a lot
+      // of calls; we save all data together once the sync is done
+      this.dirty = true;
+    }
+  }
+
+  /**
+   * Set all users we're currently tracking to untracked
+   *
+   * This will flag each user whose devices we are tracking as in need of an
+   * update.
+   */
+  stopTrackingAllDeviceLists() {
+    for (var userId of Object.keys(this.deviceTrackingStatus)) {
+      this.deviceTrackingStatus[userId] = TrackingStatus.NotTracked;
+    }
+    this.dirty = true;
+  }
+
+  /**
+   * Mark the cached device list for the given user outdated.
+   *
+   * If we are not tracking this user's devices, we'll do nothing. Otherwise
+   * we flag the user as needing an update.
+   *
+   * This doesn't actually set off an update, so that several users can be
+   * batched together. Call refreshOutdatedDeviceLists() for that.
+   *
+   */
+  invalidateUserDeviceList(userId) {
+    if (this.deviceTrackingStatus[userId]) {
+      logger.log("Marking device list outdated for", userId);
+      this.deviceTrackingStatus[userId] = TrackingStatus.PendingDownload;
+
+      // we don't yet persist the tracking status, since there may be a lot
+      // of calls; we save all data together once the sync is done
+      this.dirty = true;
+    }
+  }
+
+  /**
+   * If we have users who have outdated device lists, start key downloads for them
+   *
+   * @returns which completes when the download completes; normally there
+   *    is no need to wait for this (it's mostly for the unit tests).
+   */
+  refreshOutdatedDeviceLists() {
+    this.saveIfDirty();
+    var usersToDownload = [];
+    for (var userId of Object.keys(this.deviceTrackingStatus)) {
+      var stat = this.deviceTrackingStatus[userId];
+      if (stat == TrackingStatus.PendingDownload) {
+        usersToDownload.push(userId);
+      }
+    }
+    return this.doKeyDownload(usersToDownload);
+  }
+
+  /**
+   * Set the stored device data for a user, in raw object form
+   * Used only by internal class DeviceListUpdateSerialiser
+   *
+   * @param userId - the user to get data for
+   *
+   * @param devices - `deviceId->{object}` the new devices
+   */
+  setRawStoredDevicesForUser(userId, devices) {
+    // remove old devices from userByIdentityKey
+    if (this.devices[userId] !== undefined) {
+      for (var [deviceId, dev] of Object.entries(this.devices[userId])) {
+        var identityKey = dev.keys["curve25519:" + deviceId];
+        delete this.userByIdentityKey[identityKey];
+      }
+    }
+    this.devices[userId] = devices;
+
+    // add new devices into userByIdentityKey
+    for (var [_deviceId, _dev] of Object.entries(devices)) {
+      var _identityKey = _dev.keys["curve25519:" + _deviceId];
+      this.userByIdentityKey[_identityKey] = userId;
+    }
+  }
+  setRawStoredCrossSigningForUser(userId, info) {
+    this.crossSigningInfo[userId] = info;
+  }
+
+  /**
+   * Fire off download update requests for the given users, and update the
+   * device list tracking status for them, and the
+   * keyDownloadsInProgressByUser map for them.
+   *
+   * @param users -  list of userIds
+   *
+   * @returns resolves when all the users listed have
+   *     been updated. rejects if there was a problem updating any of the
+   *     users.
+   */
+  doKeyDownload(users) {
+    if (users.length === 0) {
+      // nothing to do
+      return Promise.resolve();
+    }
+    var prom = this.serialiser.updateDevicesForUsers(users, this.syncToken).then(() => {
+      finished(true);
+    }, e => {
+      logger.error("Error downloading keys for " + users + ":", e);
+      finished(false);
+      throw e;
+    });
+    users.forEach(u => {
+      this.keyDownloadsInProgressByUser.set(u, prom);
+      var stat = this.deviceTrackingStatus[u];
+      if (stat == TrackingStatus.PendingDownload) {
+        this.deviceTrackingStatus[u] = TrackingStatus.DownloadInProgress;
+      }
+    });
+    var finished = success => {
+      this.emit(CryptoEvent.WillUpdateDevices, users, !this.hasFetched);
+      users.forEach(u => {
+        this.dirty = true;
+
+        // we may have queued up another download request for this user
+        // since we started this request. If that happens, we should
+        // ignore the completion of the first one.
+        if (this.keyDownloadsInProgressByUser.get(u) !== prom) {
+          logger.log("Another update in the queue for", u, "- not marking up-to-date");
+          return;
+        }
+        this.keyDownloadsInProgressByUser.delete(u);
+        var stat = this.deviceTrackingStatus[u];
+        if (stat == TrackingStatus.DownloadInProgress) {
+          if (success) {
+            // we didn't get any new invalidations since this download started:
+            // this user's device list is now up to date.
+            this.deviceTrackingStatus[u] = TrackingStatus.UpToDate;
+            logger.log("Device list for", u, "now up to date");
+          } else {
+            this.deviceTrackingStatus[u] = TrackingStatus.PendingDownload;
+          }
+        }
+      });
+      this.saveIfDirty();
+      this.emit(CryptoEvent.DevicesUpdated, users, !this.hasFetched);
+      this.hasFetched = true;
+    };
+    return prom;
+  }
+}
+
+/**
+ * Serialises updates to device lists
+ *
+ * Ensures that results from /keys/query are not overwritten if a second call
+ * completes *before* an earlier one.
+ *
+ * It currently does this by ensuring only one call to /keys/query happens at a
+ * time (and queuing other requests up).
+ */
+class DeviceListUpdateSerialiser {
+  // The sync token we send with the requests
+
+  /*
+   * @param baseApis - Base API object
+   * @param olmDevice - The Olm Device
+   * @param deviceList - The device list object, the device list to be updated
+   */
+  constructor(baseApis, olmDevice, deviceList) {
+    this.baseApis = baseApis;
+    this.olmDevice = olmDevice;
+    this.deviceList = deviceList;
+    _defineProperty(this, "downloadInProgress", false);
+    // users which are queued for download
+    // userId -> true
+    _defineProperty(this, "keyDownloadsQueuedByUser", {});
+    // deferred which is resolved when the queued users are downloaded.
+    // non-null indicates that we have users queued for download.
+    _defineProperty(this, "queuedQueryDeferred", void 0);
+    _defineProperty(this, "syncToken", void 0);
+  }
+
+  /**
+   * Make a key query request for the given users
+   *
+   * @param users - list of user ids
+   *
+   * @param syncToken - sync token to pass in the query request, to
+   *     help the HS give the most recent results
+   *
+   * @returns resolves when all the users listed have
+   *     been updated. rejects if there was a problem updating any of the
+   *     users.
+   */
+  updateDevicesForUsers(users, syncToken) {
+    users.forEach(u => {
+      this.keyDownloadsQueuedByUser[u] = true;
+    });
+    if (!this.queuedQueryDeferred) {
+      this.queuedQueryDeferred = defer();
+    }
+
+    // We always take the new sync token and just use the latest one we've
+    // been given, since it just needs to be at least as recent as the
+    // sync response the device invalidation message arrived in
+    this.syncToken = syncToken;
+    if (this.downloadInProgress) {
+      // just queue up these users
+      logger.log("Queued key download for", users);
+      return this.queuedQueryDeferred.promise;
+    }
+
+    // start a new download.
+    return this.doQueuedQueries();
+  }
+  doQueuedQueries() {
+    var _this3 = this;
+    if (this.downloadInProgress) {
+      throw new Error("DeviceListUpdateSerialiser.doQueuedQueries called with request active");
+    }
+    var downloadUsers = Object.keys(this.keyDownloadsQueuedByUser);
+    this.keyDownloadsQueuedByUser = {};
+    var deferred = this.queuedQueryDeferred;
+    this.queuedQueryDeferred = undefined;
+    logger.log("Starting key download for", downloadUsers);
+    this.downloadInProgress = true;
+    var opts = {};
+    if (this.syncToken) {
+      opts.token = this.syncToken;
+    }
+    var factories = [];
+    var _loop = function _loop() {
+      var userSlice = downloadUsers.slice(i, i + _this3.deviceList.keyDownloadChunkSize);
+      factories.push(() => _this3.baseApis.downloadKeysForUsers(userSlice, opts));
+    };
+    for (var i = 0; i < downloadUsers.length; i += this.deviceList.keyDownloadChunkSize) {
+      _loop();
+    }
+    chunkPromises(factories, 3).then(/*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (responses) {
+        var dk = Object.assign({}, ...responses.map(res => res.device_keys || {}));
+        var masterKeys = Object.assign({}, ...responses.map(res => res.master_keys || {}));
+        var ssks = Object.assign({}, ...responses.map(res => res.self_signing_keys || {}));
+        var usks = Object.assign({}, ...responses.map(res => res.user_signing_keys || {}));
+
+        // yield to other things that want to execute in between users, to
+        // avoid wedging the CPU
+        // (https://github.com/vector-im/element-web/issues/3158)
+        //
+        // of course we ought to do this in a web worker or similar, but
+        // this serves as an easy solution for now.
+        for (var userId of downloadUsers) {
+          yield sleep(5);
+          try {
+            yield _this3.processQueryResponseForUser(userId, dk[userId], {
+              master: masterKeys === null || masterKeys === void 0 ? void 0 : masterKeys[userId],
+              self_signing: ssks === null || ssks === void 0 ? void 0 : ssks[userId],
+              user_signing: usks === null || usks === void 0 ? void 0 : usks[userId]
+            });
+          } catch (e) {
+            // log the error but continue, so that one bad key
+            // doesn't kill the whole process
+            logger.error("Error processing keys for ".concat(userId, ":"), e);
+          }
+        }
+      });
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }()).then(() => {
+      logger.log("Completed key download for " + downloadUsers);
+      this.downloadInProgress = false;
+      deferred === null || deferred === void 0 || deferred.resolve();
+
+      // if we have queued users, fire off another request.
+      if (this.queuedQueryDeferred) {
+        this.doQueuedQueries();
+      }
+    }, e => {
+      logger.warn("Error downloading keys for " + downloadUsers + ":", e);
+      this.downloadInProgress = false;
+      deferred === null || deferred === void 0 || deferred.reject(e);
+    });
+    return deferred.promise;
+  }
+  processQueryResponseForUser(userId, dkResponse, crossSigningResponse) {
+    var _this4 = this;
+    return _asyncToGenerator(function* () {
+      logger.log("got device keys for " + userId + ":", dkResponse);
+      logger.log("got cross-signing keys for " + userId + ":", crossSigningResponse);
+      {
+        // map from deviceid -> deviceinfo for this user
+        var userStore = {};
+        var devs = _this4.deviceList.getRawStoredDevicesForUser(userId);
+        if (devs) {
+          Object.keys(devs).forEach(deviceId => {
+            var d = DeviceInfo.fromStorage(devs[deviceId], deviceId);
+            userStore[deviceId] = d;
+          });
+        }
+        yield updateStoredDeviceKeysForUser(_this4.olmDevice, userId, userStore, dkResponse || {}, _this4.baseApis.getUserId(), _this4.baseApis.deviceId);
+
+        // put the updates into the object that will be returned as our results
+        var storage = {};
+        Object.keys(userStore).forEach(deviceId => {
+          storage[deviceId] = userStore[deviceId].toStorage();
+        });
+        _this4.deviceList.setRawStoredDevicesForUser(userId, storage);
+      }
+
+      // now do the same for the cross-signing keys
+      {
+        // FIXME: should we be ignoring empty cross-signing responses, or
+        // should we be dropping the keys?
+        if (crossSigningResponse && (crossSigningResponse.master || crossSigningResponse.self_signing || crossSigningResponse.user_signing)) {
+          var crossSigning = _this4.deviceList.getStoredCrossSigningForUser(userId) || new CrossSigningInfo(userId);
+          crossSigning.setKeys(crossSigningResponse);
+          _this4.deviceList.setRawStoredCrossSigningForUser(userId, crossSigning.toStorage());
+
+          // NB. Unlike most events in the js-sdk, this one is internal to the
+          // js-sdk and is not re-emitted
+          _this4.deviceList.emit(CryptoEvent.UserCrossSigningUpdated, userId);
+        }
+      }
+    })();
+  }
+}
+function updateStoredDeviceKeysForUser(_x2, _x3, _x4, _x5, _x6, _x7) {
+  return _updateStoredDeviceKeysForUser.apply(this, arguments);
+}
+/*
+ * Process a device in a /query response, and add it to the userStore
+ *
+ * returns (a promise for) true if a change was made, else false
+ */
+function _updateStoredDeviceKeysForUser() {
+  _updateStoredDeviceKeysForUser = _asyncToGenerator(function* (olmDevice, userId, userStore, userResult, localUserId, localDeviceId) {
+    var updated = false;
+
+    // remove any devices in the store which aren't in the response
+    for (var deviceId in userStore) {
+      if (!userStore.hasOwnProperty(deviceId)) {
+        continue;
+      }
+      if (!(deviceId in userResult)) {
+        if (userId === localUserId && deviceId === localDeviceId) {
+          logger.warn("Local device ".concat(deviceId, " missing from sync, skipping removal"));
+          continue;
+        }
+        logger.log("Device " + userId + ":" + deviceId + " has been removed");
+        delete userStore[deviceId];
+        updated = true;
+      }
+    }
+    for (var _deviceId2 in userResult) {
+      if (!userResult.hasOwnProperty(_deviceId2)) {
+        continue;
+      }
+      var deviceResult = userResult[_deviceId2];
+
+      // check that the user_id and device_id in the response object are
+      // correct
+      if (deviceResult.user_id !== userId) {
+        logger.warn("Mismatched user_id " + deviceResult.user_id + " in keys from " + userId + ":" + _deviceId2);
+        continue;
+      }
+      if (deviceResult.device_id !== _deviceId2) {
+        logger.warn("Mismatched device_id " + deviceResult.device_id + " in keys from " + userId + ":" + _deviceId2);
+        continue;
+      }
+      if (yield storeDeviceKeys(olmDevice, userStore, deviceResult)) {
+        updated = true;
+      }
+    }
+    return updated;
+  });
+  return _updateStoredDeviceKeysForUser.apply(this, arguments);
+}
+function storeDeviceKeys(_x8, _x9, _x10) {
+  return _storeDeviceKeys.apply(this, arguments);
+}
+function _storeDeviceKeys() {
+  _storeDeviceKeys = _asyncToGenerator(function* (olmDevice, userStore, deviceResult) {
+    if (!deviceResult.keys) {
+      // no keys?
+      return false;
+    }
+    var deviceId = deviceResult.device_id;
+    var userId = deviceResult.user_id;
+    var signKeyId = "ed25519:" + deviceId;
+    var signKey = deviceResult.keys[signKeyId];
+    if (!signKey) {
+      logger.warn("Device " + userId + ":" + deviceId + " has no ed25519 key");
+      return false;
+    }
+    var unsigned = deviceResult.unsigned || {};
+    var signatures = deviceResult.signatures || {};
+    try {
+      yield olmlib.verifySignature(olmDevice, deviceResult, userId, deviceId, signKey);
+    } catch (e) {
+      logger.warn("Unable to verify signature on device " + userId + ":" + deviceId + ":" + e);
+      return false;
+    }
+
+    // DeviceInfo
+    var deviceStore;
+    if (deviceId in userStore) {
+      // already have this device.
+      deviceStore = userStore[deviceId];
+      if (deviceStore.getFingerprint() != signKey) {
+        // this should only happen if the list has been MITMed; we are
+        // best off sticking with the original keys.
+        //
+        // Should we warn the user about it somehow?
+        logger.warn("Ed25519 key for device " + userId + ":" + deviceId + " has changed");
+        return false;
+      }
+    } else {
+      userStore[deviceId] = deviceStore = new DeviceInfo(deviceId);
+    }
+    deviceStore.keys = deviceResult.keys || {};
+    deviceStore.algorithms = deviceResult.algorithms || [];
+    deviceStore.unsigned = unsigned;
+    deviceStore.signatures = signatures;
+    return true;
+  });
+  return _storeDeviceKeys.apply(this, arguments);
+}
+//# sourceMappingURL=DeviceList.js.map