@unwanted/matrix-sdk-mini 34.12.0-1

package/lib/crypto/OutgoingRoomKeyRequestManager.js

@@ -0,0 +1,415 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/*
+Copyright 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.
+*/
+
+import { v4 as uuidv4 } from "uuid";
+import { logger } from "../logger.js";
+import { EventType, ToDeviceMessageId } from "../@types/event.js";
+import { MapWithDefault } from "../utils.js";
+
+/**
+ * Internal module. Management of outgoing room key requests.
+ *
+ * See https://docs.google.com/document/d/1m4gQkcnJkxNuBmb5NoFCIadIY-DyqqNAS3lloE73BlQ
+ * for draft documentation on what we're supposed to be implementing here.
+ */
+
+// delay between deciding we want some keys, and sending out the request, to
+// allow for (a) it turning up anyway, (b) grouping requests together
+var SEND_KEY_REQUESTS_DELAY_MS = 500;
+
+/**
+ *  possible states for a room key request
+ *
+ * The state machine looks like:
+ * ```
+ *
+ *     |         (cancellation sent)
+ *     | .-------------------------------------------------.
+ *     | |                                                 |
+ *     V V       (cancellation requested)                  |
+ *   UNSENT  -----------------------------+                |
+ *     |                                  |                |
+ *     |                                  |                |
+ *     | (send successful)                |  CANCELLATION_PENDING_AND_WILL_RESEND
+ *     V                                  |                Λ
+ *    SENT                                |                |
+ *     |--------------------------------  |  --------------'
+ *     |                                  |  (cancellation requested with intent
+ *     |                                  |   to resend the original request)
+ *     |                                  |
+ *     | (cancellation requested)         |
+ *     V                                  |
+ * CANCELLATION_PENDING                   |
+ *     |                                  |
+ *     | (cancellation sent)              |
+ *     V                                  |
+ * (deleted)  <---------------------------+
+ * ```
+ */
+export var RoomKeyRequestState = /*#__PURE__*/function (RoomKeyRequestState) {
+  RoomKeyRequestState[RoomKeyRequestState["Unsent"] = 0] = "Unsent";
+  RoomKeyRequestState[RoomKeyRequestState["Sent"] = 1] = "Sent";
+  RoomKeyRequestState[RoomKeyRequestState["CancellationPending"] = 2] = "CancellationPending";
+  RoomKeyRequestState[RoomKeyRequestState["CancellationPendingAndWillResend"] = 3] = "CancellationPendingAndWillResend";
+  return RoomKeyRequestState;
+}({});
+export class OutgoingRoomKeyRequestManager {
+  constructor(baseApis, deviceId, cryptoStore) {
+    this.baseApis = baseApis;
+    this.deviceId = deviceId;
+    this.cryptoStore = cryptoStore;
+    // handle for the delayed call to sendOutgoingRoomKeyRequests. Non-null
+    // if the callback has been set, or if it is still running.
+    _defineProperty(this, "sendOutgoingRoomKeyRequestsTimer", void 0);
+    // sanity check to ensure that we don't end up with two concurrent runs
+    // of sendOutgoingRoomKeyRequests
+    _defineProperty(this, "sendOutgoingRoomKeyRequestsRunning", false);
+    _defineProperty(this, "clientRunning", true);
+  }
+
+  /**
+   * Called when the client is stopped. Stops any running background processes.
+   */
+  stop() {
+    logger.log("stopping OutgoingRoomKeyRequestManager");
+    // stop the timer on the next run
+    this.clientRunning = false;
+  }
+
+  /**
+   * Send any requests that have been queued
+   */
+  sendQueuedRequests() {
+    this.startTimer();
+  }
+
+  /**
+   * Queue up a room key request, if we haven't already queued or sent one.
+   *
+   * The `requestBody` is compared (with a deep-equality check) against
+   * previous queued or sent requests and if it matches, no change is made.
+   * Otherwise, a request is added to the pending list, and a job is started
+   * in the background to send it.
+   *
+   * @param resend - whether to resend the key request if there is
+   *    already one
+   *
+   * @returns resolves when the request has been added to the
+   *    pending list (or we have established that a similar request already
+   *    exists)
+   */
+  queueRoomKeyRequest(requestBody, recipients) {
+    var _arguments = arguments,
+      _this = this;
+    return _asyncToGenerator(function* () {
+      var resend = _arguments.length > 2 && _arguments[2] !== undefined ? _arguments[2] : false;
+      var req = yield _this.cryptoStore.getOutgoingRoomKeyRequest(requestBody);
+      if (!req) {
+        yield _this.cryptoStore.getOrAddOutgoingRoomKeyRequest({
+          requestBody: requestBody,
+          recipients: recipients,
+          requestId: _this.baseApis.makeTxnId(),
+          state: RoomKeyRequestState.Unsent
+        });
+      } else {
+        switch (req.state) {
+          case RoomKeyRequestState.CancellationPendingAndWillResend:
+          case RoomKeyRequestState.Unsent:
+            // nothing to do here, since we're going to send a request anyways
+            return;
+          case RoomKeyRequestState.CancellationPending:
+            {
+              // existing request is about to be cancelled.  If we want to
+              // resend, then change the state so that it resends after
+              // cancelling.  Otherwise, just cancel the cancellation.
+              var state = resend ? RoomKeyRequestState.CancellationPendingAndWillResend : RoomKeyRequestState.Sent;
+              yield _this.cryptoStore.updateOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.CancellationPending, {
+                state,
+                cancellationTxnId: _this.baseApis.makeTxnId()
+              });
+              break;
+            }
+          case RoomKeyRequestState.Sent:
+            {
+              // a request has already been sent.  If we don't want to
+              // resend, then do nothing.  If we do want to, then cancel the
+              // existing request and send a new one.
+              if (resend) {
+                var _state = RoomKeyRequestState.CancellationPendingAndWillResend;
+                var updatedReq = yield _this.cryptoStore.updateOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Sent, {
+                  state: _state,
+                  cancellationTxnId: _this.baseApis.makeTxnId(),
+                  // need to use a new transaction ID so that
+                  // the request gets sent
+                  requestTxnId: _this.baseApis.makeTxnId()
+                });
+                if (!updatedReq) {
+                  // updateOutgoingRoomKeyRequest couldn't find the request
+                  // in state ROOM_KEY_REQUEST_STATES.SENT, so we must have
+                  // raced with another tab to mark the request cancelled.
+                  // Try again, to make sure the request is resent.
+                  return _this.queueRoomKeyRequest(requestBody, recipients, resend);
+                }
+
+                // We don't want to wait for the timer, so we send it
+                // immediately. (We might actually end up racing with the timer,
+                // but that's ok: even if we make the request twice, we'll do it
+                // with the same transaction_id, so only one message will get
+                // sent).
+                //
+                // (We also don't want to wait for the response from the server
+                // here, as it will slow down processing of received keys if we
+                // do.)
+                try {
+                  yield _this.sendOutgoingRoomKeyRequestCancellation(updatedReq, true);
+                } catch (e) {
+                  logger.error("Error sending room key request cancellation;" + " will retry later.", e);
+                }
+                // The request has transitioned from
+                // CANCELLATION_PENDING_AND_WILL_RESEND to UNSENT. We
+                // still need to resend the request which is now UNSENT, so
+                // start the timer if it isn't already started.
+              }
+              break;
+            }
+          default:
+            throw new Error("unhandled state: " + req.state);
+        }
+      }
+    })();
+  }
+
+  /**
+   * Cancel room key requests, if any match the given requestBody
+   *
+   *
+   * @returns resolves when the request has been updated in our
+   *    pending list.
+   */
+  cancelRoomKeyRequest(requestBody) {
+    return this.cryptoStore.getOutgoingRoomKeyRequest(requestBody).then(req => {
+      if (!req) {
+        // no request was made for this key
+        return;
+      }
+      switch (req.state) {
+        case RoomKeyRequestState.CancellationPending:
+        case RoomKeyRequestState.CancellationPendingAndWillResend:
+          // nothing to do here
+          return;
+        case RoomKeyRequestState.Unsent:
+          // just delete it
+
+          // FIXME: ghahah we may have attempted to send it, and
+          // not yet got a successful response. So the server
+          // may have seen it, so we still need to send a cancellation
+          // in that case :/
+
+          logger.log("deleting unnecessary room key request for " + stringifyRequestBody(requestBody));
+          return this.cryptoStore.deleteOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Unsent);
+        case RoomKeyRequestState.Sent:
+          {
+            // send a cancellation.
+            return this.cryptoStore.updateOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Sent, {
+              state: RoomKeyRequestState.CancellationPending,
+              cancellationTxnId: this.baseApis.makeTxnId()
+            }).then(updatedReq => {
+              if (!updatedReq) {
+                // updateOutgoingRoomKeyRequest couldn't find the
+                // request in state ROOM_KEY_REQUEST_STATES.SENT,
+                // so we must have raced with another tab to mark
+                // the request cancelled. There is no point in
+                // sending another cancellation since the other tab
+                // will do it.
+                logger.log("Tried to cancel room key request for " + stringifyRequestBody(requestBody) + " but it was already cancelled in another tab");
+                return;
+              }
+
+              // We don't want to wait for the timer, so we send it
+              // immediately. (We might actually end up racing with the timer,
+              // but that's ok: even if we make the request twice, we'll do it
+              // with the same transaction_id, so only one message will get
+              // sent).
+              //
+              // (We also don't want to wait for the response from the server
+              // here, as it will slow down processing of received keys if we
+              // do.)
+              this.sendOutgoingRoomKeyRequestCancellation(updatedReq).catch(e => {
+                logger.error("Error sending room key request cancellation;" + " will retry later.", e);
+                this.startTimer();
+              });
+            });
+          }
+        default:
+          throw new Error("unhandled state: " + req.state);
+      }
+    });
+  }
+
+  /**
+   * Look for room key requests by target device and state
+   *
+   * @param userId - Target user ID
+   * @param deviceId - Target device ID
+   *
+   * @returns resolves to a list of all the {@link OutgoingRoomKeyRequest}
+   */
+  getOutgoingSentRoomKeyRequest(userId, deviceId) {
+    return this.cryptoStore.getOutgoingRoomKeyRequestsByTarget(userId, deviceId, [RoomKeyRequestState.Sent]);
+  }
+
+  /**
+   * Find anything in `sent` state, and kick it around the loop again.
+   * This is intended for situations where something substantial has changed, and we
+   * don't really expect the other end to even care about the cancellation.
+   * For example, after initialization or self-verification.
+   * @returns An array of `queueRoomKeyRequest` outputs.
+   */
+  cancelAndResendAllOutgoingRequests() {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      var outgoings = yield _this2.cryptoStore.getAllOutgoingRoomKeyRequestsByState(RoomKeyRequestState.Sent);
+      return Promise.all(outgoings.map(_ref => {
+        var {
+          requestBody,
+          recipients
+        } = _ref;
+        return _this2.queueRoomKeyRequest(requestBody, recipients, true);
+      }));
+    })();
+  }
+
+  // start the background timer to send queued requests, if the timer isn't
+  // already running
+  startTimer() {
+    if (this.sendOutgoingRoomKeyRequestsTimer) {
+      return;
+    }
+    var startSendingOutgoingRoomKeyRequests = () => {
+      if (this.sendOutgoingRoomKeyRequestsRunning) {
+        throw new Error("RoomKeyRequestSend already in progress!");
+      }
+      this.sendOutgoingRoomKeyRequestsRunning = true;
+      this.sendOutgoingRoomKeyRequests().finally(() => {
+        this.sendOutgoingRoomKeyRequestsRunning = false;
+      }).catch(e => {
+        // this should only happen if there is an indexeddb error,
+        // in which case we're a bit stuffed anyway.
+        logger.warn("error in OutgoingRoomKeyRequestManager: ".concat(e));
+      });
+    };
+    this.sendOutgoingRoomKeyRequestsTimer = setTimeout(startSendingOutgoingRoomKeyRequests, SEND_KEY_REQUESTS_DELAY_MS);
+  }
+
+  // look for and send any queued requests. Runs itself recursively until
+  // there are no more requests, or there is an error (in which case, the
+  // timer will be restarted before the promise resolves).
+  sendOutgoingRoomKeyRequests() {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      if (!_this3.clientRunning) {
+        _this3.sendOutgoingRoomKeyRequestsTimer = undefined;
+        return;
+      }
+      var req = yield _this3.cryptoStore.getOutgoingRoomKeyRequestByState([RoomKeyRequestState.CancellationPending, RoomKeyRequestState.CancellationPendingAndWillResend, RoomKeyRequestState.Unsent]);
+      if (!req) {
+        _this3.sendOutgoingRoomKeyRequestsTimer = undefined;
+        return;
+      }
+      try {
+        switch (req.state) {
+          case RoomKeyRequestState.Unsent:
+            yield _this3.sendOutgoingRoomKeyRequest(req);
+            break;
+          case RoomKeyRequestState.CancellationPending:
+            yield _this3.sendOutgoingRoomKeyRequestCancellation(req);
+            break;
+          case RoomKeyRequestState.CancellationPendingAndWillResend:
+            yield _this3.sendOutgoingRoomKeyRequestCancellation(req, true);
+            break;
+        }
+
+        // go around the loop again
+        return _this3.sendOutgoingRoomKeyRequests();
+      } catch (e) {
+        logger.error("Error sending room key request; will retry later.", e);
+        _this3.sendOutgoingRoomKeyRequestsTimer = undefined;
+      }
+    })();
+  }
+
+  // given a RoomKeyRequest, send it and update the request record
+  sendOutgoingRoomKeyRequest(req) {
+    logger.log("Requesting keys for ".concat(stringifyRequestBody(req.requestBody)) + " from ".concat(stringifyRecipientList(req.recipients)) + "(id ".concat(req.requestId, ")"));
+    var requestMessage = {
+      action: "request",
+      requesting_device_id: this.deviceId,
+      request_id: req.requestId,
+      body: req.requestBody
+    };
+    return this.sendMessageToDevices(requestMessage, req.recipients, req.requestTxnId || req.requestId).then(() => {
+      return this.cryptoStore.updateOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Unsent, {
+        state: RoomKeyRequestState.Sent
+      });
+    });
+  }
+
+  // Given a RoomKeyRequest, cancel it and delete the request record unless
+  // andResend is set, in which case transition to UNSENT.
+  sendOutgoingRoomKeyRequestCancellation(req) {
+    var andResend = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    logger.log("Sending cancellation for key request for " + "".concat(stringifyRequestBody(req.requestBody), " to ") + "".concat(stringifyRecipientList(req.recipients), " ") + "(cancellation id ".concat(req.cancellationTxnId, ")"));
+    var requestMessage = {
+      action: "request_cancellation",
+      requesting_device_id: this.deviceId,
+      request_id: req.requestId
+    };
+    return this.sendMessageToDevices(requestMessage, req.recipients, req.cancellationTxnId).then(() => {
+      if (andResend) {
+        // We want to resend, so transition to UNSENT
+        return this.cryptoStore.updateOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.CancellationPendingAndWillResend, {
+          state: RoomKeyRequestState.Unsent
+        });
+      }
+      return this.cryptoStore.deleteOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.CancellationPending);
+    });
+  }
+
+  // send a RoomKeyRequest to a list of recipients
+  sendMessageToDevices(message, recipients, txnId) {
+    var contentMap = new MapWithDefault(() => new Map());
+    for (var recip of recipients) {
+      var userDeviceMap = contentMap.getOrCreate(recip.userId);
+      userDeviceMap.set(recip.deviceId, _objectSpread(_objectSpread({}, message), {}, {
+        [ToDeviceMessageId]: uuidv4()
+      }));
+    }
+    return this.baseApis.sendToDevice(EventType.RoomKeyRequest, contentMap, txnId);
+  }
+}
+function stringifyRequestBody(requestBody) {
+  // we assume that the request is for megolm keys, which are identified by
+  // room id and session id
+  return requestBody.room_id + " / " + requestBody.session_id;
+}
+function stringifyRecipientList(recipients) {
+  return "[".concat(recipients.map(r => "".concat(r.userId, ":").concat(r.deviceId)).join(","), "]");
+}
+//# sourceMappingURL=OutgoingRoomKeyRequestManager.js.map

package/lib/crypto/OutgoingRoomKeyRequestManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutgoingRoomKeyRequestManager.js","names":["v4","uuidv4","logger","EventType","ToDeviceMessageId","MapWithDefault","SEND_KEY_REQUESTS_DELAY_MS","RoomKeyRequestState","OutgoingRoomKeyRequestManager","constructor","baseApis","deviceId","cryptoStore","_defineProperty","stop","log","clientRunning","sendQueuedRequests","startTimer","queueRoomKeyRequest","requestBody","recipients","_arguments","arguments","_this","_asyncToGenerator","resend","length","undefined","req","getOutgoingRoomKeyRequest","getOrAddOutgoingRoomKeyRequest","requestId","makeTxnId","state","Unsent","CancellationPendingAndWillResend","CancellationPending","Sent","updateOutgoingRoomKeyRequest","cancellationTxnId","updatedReq","requestTxnId","sendOutgoingRoomKeyRequestCancellation","e","error","Error","cancelRoomKeyRequest","then","stringifyRequestBody","deleteOutgoingRoomKeyRequest","catch","getOutgoingSentRoomKeyRequest","userId","getOutgoingRoomKeyRequestsByTarget","cancelAndResendAllOutgoingRequests","_this2","outgoings","getAllOutgoingRoomKeyRequestsByState","Promise","all","map","_ref","sendOutgoingRoomKeyRequestsTimer","startSendingOutgoingRoomKeyRequests","sendOutgoingRoomKeyRequestsRunning","sendOutgoingRoomKeyRequests","finally","warn","concat","setTimeout","_this3","getOutgoingRoomKeyRequestByState","sendOutgoingRoomKeyRequest","stringifyRecipientList","requestMessage","action","requesting_device_id","request_id","body","sendMessageToDevices","andResend","message","txnId","contentMap","Map","recip","userDeviceMap","getOrCreate","set","_objectSpread","sendToDevice","RoomKeyRequest","room_id","session_id","r","join"],"sources":["../../src/crypto/OutgoingRoomKeyRequestManager.ts"],"sourcesContent":["/*\nCopyright 2017 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { v4 as uuidv4 } from \"uuid\";\n\nimport { logger } from \"../logger.ts\";\nimport { MatrixClient } from \"../client.ts\";\nimport { IRoomKeyRequestBody, IRoomKeyRequestRecipient } from \"./index.ts\";\nimport { CryptoStore, OutgoingRoomKeyRequest } from \"./store/base.ts\";\nimport { EventType, ToDeviceMessageId } from \"../@types/event.ts\";\nimport { MapWithDefault } from \"../utils.ts\";\n\n/**\n * Internal module. Management of outgoing room key requests.\n *\n * See https://docs.google.com/document/d/1m4gQkcnJkxNuBmb5NoFCIadIY-DyqqNAS3lloE73BlQ\n * for draft documentation on what we're supposed to be implementing here.\n */\n\n// delay between deciding we want some keys, and sending out the request, to\n// allow for (a) it turning up anyway, (b) grouping requests together\nconst SEND_KEY_REQUESTS_DELAY_MS = 500;\n\n/**\n *  possible states for a room key request\n *\n * The state machine looks like:\n * ```\n *\n *     |         (cancellation sent)\n *     | .-------------------------------------------------.\n *     | |                                                 |\n *     V V       (cancellation requested)                  |\n *   UNSENT  -----------------------------+                |\n *     |                                  |                |\n *     |                                  |                |\n *     | (send successful)                |  CANCELLATION_PENDING_AND_WILL_RESEND\n *     V                                  |                Λ\n *    SENT                                |                |\n *     |--------------------------------  |  --------------'\n *     |                                  |  (cancellation requested with intent\n *     |                                  |   to resend the original request)\n *     |                                  |\n *     | (cancellation requested)         |\n *     V                                  |\n * CANCELLATION_PENDING                   |\n *     |                                  |\n *     | (cancellation sent)              |\n *     V                                  |\n * (deleted)  <---------------------------+\n * ```\n */\nexport enum RoomKeyRequestState {\n    /** request not yet sent */\n    Unsent,\n    /** request sent, awaiting reply */\n    Sent,\n    /** reply received, cancellation not yet sent */\n    CancellationPending,\n    /**\n     * Cancellation not yet sent and will transition to UNSENT instead of\n     * being deleted once the cancellation has been sent.\n     */\n    CancellationPendingAndWillResend,\n}\n\ninterface RequestMessageBase {\n    requesting_device_id: string;\n    request_id: string;\n}\n\ninterface RequestMessageRequest extends RequestMessageBase {\n    action: \"request\";\n    body: IRoomKeyRequestBody;\n}\n\ninterface RequestMessageCancellation extends RequestMessageBase {\n    action: \"request_cancellation\";\n}\n\ntype RequestMessage = RequestMessageRequest | RequestMessageCancellation;\n\nexport class OutgoingRoomKeyRequestManager {\n    // handle for the delayed call to sendOutgoingRoomKeyRequests. Non-null\n    // if the callback has been set, or if it is still running.\n    private sendOutgoingRoomKeyRequestsTimer?: ReturnType<typeof setTimeout>;\n\n    // sanity check to ensure that we don't end up with two concurrent runs\n    // of sendOutgoingRoomKeyRequests\n    private sendOutgoingRoomKeyRequestsRunning = false;\n\n    private clientRunning = true;\n\n    public constructor(\n        private readonly baseApis: MatrixClient,\n        private readonly deviceId: string,\n        private readonly cryptoStore: CryptoStore,\n    ) {}\n\n    /**\n     * Called when the client is stopped. Stops any running background processes.\n     */\n    public stop(): void {\n        logger.log(\"stopping OutgoingRoomKeyRequestManager\");\n        // stop the timer on the next run\n        this.clientRunning = false;\n    }\n\n    /**\n     * Send any requests that have been queued\n     */\n    public sendQueuedRequests(): void {\n        this.startTimer();\n    }\n\n    /**\n     * Queue up a room key request, if we haven't already queued or sent one.\n     *\n     * The `requestBody` is compared (with a deep-equality check) against\n     * previous queued or sent requests and if it matches, no change is made.\n     * Otherwise, a request is added to the pending list, and a job is started\n     * in the background to send it.\n     *\n     * @param resend - whether to resend the key request if there is\n     *    already one\n     *\n     * @returns resolves when the request has been added to the\n     *    pending list (or we have established that a similar request already\n     *    exists)\n     */\n    public async queueRoomKeyRequest(\n        requestBody: IRoomKeyRequestBody,\n        recipients: IRoomKeyRequestRecipient[],\n        resend = false,\n    ): Promise<void> {\n        const req = await this.cryptoStore.getOutgoingRoomKeyRequest(requestBody);\n        if (!req) {\n            await this.cryptoStore.getOrAddOutgoingRoomKeyRequest({\n                requestBody: requestBody,\n                recipients: recipients,\n                requestId: this.baseApis.makeTxnId(),\n                state: RoomKeyRequestState.Unsent,\n            });\n        } else {\n            switch (req.state) {\n                case RoomKeyRequestState.CancellationPendingAndWillResend:\n                case RoomKeyRequestState.Unsent:\n                    // nothing to do here, since we're going to send a request anyways\n                    return;\n\n                case RoomKeyRequestState.CancellationPending: {\n                    // existing request is about to be cancelled.  If we want to\n                    // resend, then change the state so that it resends after\n                    // cancelling.  Otherwise, just cancel the cancellation.\n                    const state = resend\n                        ? RoomKeyRequestState.CancellationPendingAndWillResend\n                        : RoomKeyRequestState.Sent;\n                    await this.cryptoStore.updateOutgoingRoomKeyRequest(\n                        req.requestId,\n                        RoomKeyRequestState.CancellationPending,\n                        {\n                            state,\n                            cancellationTxnId: this.baseApis.makeTxnId(),\n                        },\n                    );\n                    break;\n                }\n                case RoomKeyRequestState.Sent: {\n                    // a request has already been sent.  If we don't want to\n                    // resend, then do nothing.  If we do want to, then cancel the\n                    // existing request and send a new one.\n                    if (resend) {\n                        const state = RoomKeyRequestState.CancellationPendingAndWillResend;\n                        const updatedReq = await this.cryptoStore.updateOutgoingRoomKeyRequest(\n                            req.requestId,\n                            RoomKeyRequestState.Sent,\n                            {\n                                state,\n                                cancellationTxnId: this.baseApis.makeTxnId(),\n                                // need to use a new transaction ID so that\n                                // the request gets sent\n                                requestTxnId: this.baseApis.makeTxnId(),\n                            },\n                        );\n                        if (!updatedReq) {\n                            // updateOutgoingRoomKeyRequest couldn't find the request\n                            // in state ROOM_KEY_REQUEST_STATES.SENT, so we must have\n                            // raced with another tab to mark the request cancelled.\n                            // Try again, to make sure the request is resent.\n                            return this.queueRoomKeyRequest(requestBody, recipients, resend);\n                        }\n\n                        // We don't want to wait for the timer, so we send it\n                        // immediately. (We might actually end up racing with the timer,\n                        // but that's ok: even if we make the request twice, we'll do it\n                        // with the same transaction_id, so only one message will get\n                        // sent).\n                        //\n                        // (We also don't want to wait for the response from the server\n                        // here, as it will slow down processing of received keys if we\n                        // do.)\n                        try {\n                            await this.sendOutgoingRoomKeyRequestCancellation(updatedReq, true);\n                        } catch (e) {\n                            logger.error(\"Error sending room key request cancellation;\" + \" will retry later.\", e);\n                        }\n                        // The request has transitioned from\n                        // CANCELLATION_PENDING_AND_WILL_RESEND to UNSENT. We\n                        // still need to resend the request which is now UNSENT, so\n                        // start the timer if it isn't already started.\n                    }\n                    break;\n                }\n                default:\n                    throw new Error(\"unhandled state: \" + req.state);\n            }\n        }\n    }\n\n    /**\n     * Cancel room key requests, if any match the given requestBody\n     *\n     *\n     * @returns resolves when the request has been updated in our\n     *    pending list.\n     */\n    public cancelRoomKeyRequest(requestBody: IRoomKeyRequestBody): Promise<unknown> {\n        return this.cryptoStore.getOutgoingRoomKeyRequest(requestBody).then((req): unknown => {\n            if (!req) {\n                // no request was made for this key\n                return;\n            }\n            switch (req.state) {\n                case RoomKeyRequestState.CancellationPending:\n                case RoomKeyRequestState.CancellationPendingAndWillResend:\n                    // nothing to do here\n                    return;\n\n                case RoomKeyRequestState.Unsent:\n                    // just delete it\n\n                    // FIXME: ghahah we may have attempted to send it, and\n                    // not yet got a successful response. So the server\n                    // may have seen it, so we still need to send a cancellation\n                    // in that case :/\n\n                    logger.log(\"deleting unnecessary room key request for \" + stringifyRequestBody(requestBody));\n                    return this.cryptoStore.deleteOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Unsent);\n\n                case RoomKeyRequestState.Sent: {\n                    // send a cancellation.\n                    return this.cryptoStore\n                        .updateOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Sent, {\n                            state: RoomKeyRequestState.CancellationPending,\n                            cancellationTxnId: this.baseApis.makeTxnId(),\n                        })\n                        .then((updatedReq) => {\n                            if (!updatedReq) {\n                                // updateOutgoingRoomKeyRequest couldn't find the\n                                // request in state ROOM_KEY_REQUEST_STATES.SENT,\n                                // so we must have raced with another tab to mark\n                                // the request cancelled. There is no point in\n                                // sending another cancellation since the other tab\n                                // will do it.\n                                logger.log(\n                                    \"Tried to cancel room key request for \" +\n                                        stringifyRequestBody(requestBody) +\n                                        \" but it was already cancelled in another tab\",\n                                );\n                                return;\n                            }\n\n                            // We don't want to wait for the timer, so we send it\n                            // immediately. (We might actually end up racing with the timer,\n                            // but that's ok: even if we make the request twice, we'll do it\n                            // with the same transaction_id, so only one message will get\n                            // sent).\n                            //\n                            // (We also don't want to wait for the response from the server\n                            // here, as it will slow down processing of received keys if we\n                            // do.)\n                            this.sendOutgoingRoomKeyRequestCancellation(updatedReq).catch((e) => {\n                                logger.error(\"Error sending room key request cancellation;\" + \" will retry later.\", e);\n                                this.startTimer();\n                            });\n                        });\n                }\n                default:\n                    throw new Error(\"unhandled state: \" + req.state);\n            }\n        });\n    }\n\n    /**\n     * Look for room key requests by target device and state\n     *\n     * @param userId - Target user ID\n     * @param deviceId - Target device ID\n     *\n     * @returns resolves to a list of all the {@link OutgoingRoomKeyRequest}\n     */\n    public getOutgoingSentRoomKeyRequest(userId: string, deviceId: string): Promise<OutgoingRoomKeyRequest[]> {\n        return this.cryptoStore.getOutgoingRoomKeyRequestsByTarget(userId, deviceId, [RoomKeyRequestState.Sent]);\n    }\n\n    /**\n     * Find anything in `sent` state, and kick it around the loop again.\n     * This is intended for situations where something substantial has changed, and we\n     * don't really expect the other end to even care about the cancellation.\n     * For example, after initialization or self-verification.\n     * @returns An array of `queueRoomKeyRequest` outputs.\n     */\n    public async cancelAndResendAllOutgoingRequests(): Promise<void[]> {\n        const outgoings = await this.cryptoStore.getAllOutgoingRoomKeyRequestsByState(RoomKeyRequestState.Sent);\n        return Promise.all(\n            outgoings.map(({ requestBody, recipients }) => this.queueRoomKeyRequest(requestBody, recipients, true)),\n        );\n    }\n\n    // start the background timer to send queued requests, if the timer isn't\n    // already running\n    private startTimer(): void {\n        if (this.sendOutgoingRoomKeyRequestsTimer) {\n            return;\n        }\n\n        const startSendingOutgoingRoomKeyRequests = (): void => {\n            if (this.sendOutgoingRoomKeyRequestsRunning) {\n                throw new Error(\"RoomKeyRequestSend already in progress!\");\n            }\n            this.sendOutgoingRoomKeyRequestsRunning = true;\n\n            this.sendOutgoingRoomKeyRequests()\n                .finally(() => {\n                    this.sendOutgoingRoomKeyRequestsRunning = false;\n                })\n                .catch((e) => {\n                    // this should only happen if there is an indexeddb error,\n                    // in which case we're a bit stuffed anyway.\n                    logger.warn(`error in OutgoingRoomKeyRequestManager: ${e}`);\n                });\n        };\n\n        this.sendOutgoingRoomKeyRequestsTimer = setTimeout(\n            startSendingOutgoingRoomKeyRequests,\n            SEND_KEY_REQUESTS_DELAY_MS,\n        );\n    }\n\n    // look for and send any queued requests. Runs itself recursively until\n    // there are no more requests, or there is an error (in which case, the\n    // timer will be restarted before the promise resolves).\n    private async sendOutgoingRoomKeyRequests(): Promise<void> {\n        if (!this.clientRunning) {\n            this.sendOutgoingRoomKeyRequestsTimer = undefined;\n            return;\n        }\n\n        const req = await this.cryptoStore.getOutgoingRoomKeyRequestByState([\n            RoomKeyRequestState.CancellationPending,\n            RoomKeyRequestState.CancellationPendingAndWillResend,\n            RoomKeyRequestState.Unsent,\n        ]);\n\n        if (!req) {\n            this.sendOutgoingRoomKeyRequestsTimer = undefined;\n            return;\n        }\n\n        try {\n            switch (req.state) {\n                case RoomKeyRequestState.Unsent:\n                    await this.sendOutgoingRoomKeyRequest(req);\n                    break;\n                case RoomKeyRequestState.CancellationPending:\n                    await this.sendOutgoingRoomKeyRequestCancellation(req);\n                    break;\n                case RoomKeyRequestState.CancellationPendingAndWillResend:\n                    await this.sendOutgoingRoomKeyRequestCancellation(req, true);\n                    break;\n            }\n\n            // go around the loop again\n            return this.sendOutgoingRoomKeyRequests();\n        } catch (e) {\n            logger.error(\"Error sending room key request; will retry later.\", e);\n            this.sendOutgoingRoomKeyRequestsTimer = undefined;\n        }\n    }\n\n    // given a RoomKeyRequest, send it and update the request record\n    private sendOutgoingRoomKeyRequest(req: OutgoingRoomKeyRequest): Promise<unknown> {\n        logger.log(\n            `Requesting keys for ${stringifyRequestBody(req.requestBody)}` +\n                ` from ${stringifyRecipientList(req.recipients)}` +\n                `(id ${req.requestId})`,\n        );\n\n        const requestMessage: RequestMessage = {\n            action: \"request\",\n            requesting_device_id: this.deviceId,\n            request_id: req.requestId,\n            body: req.requestBody,\n        };\n\n        return this.sendMessageToDevices(requestMessage, req.recipients, req.requestTxnId || req.requestId).then(() => {\n            return this.cryptoStore.updateOutgoingRoomKeyRequest(req.requestId, RoomKeyRequestState.Unsent, {\n                state: RoomKeyRequestState.Sent,\n            });\n        });\n    }\n\n    // Given a RoomKeyRequest, cancel it and delete the request record unless\n    // andResend is set, in which case transition to UNSENT.\n    private sendOutgoingRoomKeyRequestCancellation(req: OutgoingRoomKeyRequest, andResend = false): Promise<unknown> {\n        logger.log(\n            `Sending cancellation for key request for ` +\n                `${stringifyRequestBody(req.requestBody)} to ` +\n                `${stringifyRecipientList(req.recipients)} ` +\n                `(cancellation id ${req.cancellationTxnId})`,\n        );\n\n        const requestMessage: RequestMessage = {\n            action: \"request_cancellation\",\n            requesting_device_id: this.deviceId,\n            request_id: req.requestId,\n        };\n\n        return this.sendMessageToDevices(requestMessage, req.recipients, req.cancellationTxnId).then(() => {\n            if (andResend) {\n                // We want to resend, so transition to UNSENT\n                return this.cryptoStore.updateOutgoingRoomKeyRequest(\n                    req.requestId,\n                    RoomKeyRequestState.CancellationPendingAndWillResend,\n                    { state: RoomKeyRequestState.Unsent },\n                );\n            }\n            return this.cryptoStore.deleteOutgoingRoomKeyRequest(\n                req.requestId,\n                RoomKeyRequestState.CancellationPending,\n            );\n        });\n    }\n\n    // send a RoomKeyRequest to a list of recipients\n    private sendMessageToDevices(\n        message: RequestMessage,\n        recipients: IRoomKeyRequestRecipient[],\n        txnId?: string,\n    ): Promise<{}> {\n        const contentMap = new MapWithDefault<string, Map<string, Record<string, any>>>(() => new Map());\n        for (const recip of recipients) {\n            const userDeviceMap = contentMap.getOrCreate(recip.userId);\n            userDeviceMap.set(recip.deviceId, {\n                ...message,\n                [ToDeviceMessageId]: uuidv4(),\n            });\n        }\n\n        return this.baseApis.sendToDevice(EventType.RoomKeyRequest, contentMap, txnId);\n    }\n}\n\nfunction stringifyRequestBody(requestBody: IRoomKeyRequestBody): string {\n    // we assume that the request is for megolm keys, which are identified by\n    // room id and session id\n    return requestBody.room_id + \" / \" + requestBody.session_id;\n}\n\nfunction stringifyRecipientList(recipients: IRoomKeyRequestRecipient[]): string {\n    return `[${recipients.map((r) => `${r.userId}:${r.deviceId}`).join(\",\")}]`;\n}\n"],"mappings":";;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,EAAE,IAAIC,MAAM,QAAQ,MAAM;AAEnC,SAASC,MAAM,QAAQ,cAAc;AAIrC,SAASC,SAAS,EAAEC,iBAAiB,QAAQ,oBAAoB;AACjE,SAASC,cAAc,QAAQ,aAAa;;AAE5C;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,IAAMC,0BAA0B,GAAG,GAAG;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAYC,mBAAmB,0BAAnBA,mBAAmB;EAAnBA,mBAAmB,CAAnBA,mBAAmB;EAAnBA,mBAAmB,CAAnBA,mBAAmB;EAAnBA,mBAAmB,CAAnBA,mBAAmB;EAAnBA,mBAAmB,CAAnBA,mBAAmB;EAAA,OAAnBA,mBAAmB;AAAA;AA8B/B,OAAO,MAAMC,6BAA6B,CAAC;EAWhCC,WAAWA,CACGC,QAAsB,EACtBC,QAAgB,EAChBC,WAAwB,EAC3C;IAAA,KAHmBF,QAAsB,GAAtBA,QAAsB;IAAA,KACtBC,QAAgB,GAAhBA,QAAgB;IAAA,KAChBC,WAAwB,GAAxBA,WAAwB;IAb7C;IACA;IAAAC,eAAA;IAGA;IACA;IAAAA,eAAA,6CAC6C,KAAK;IAAAA,eAAA,wBAE1B,IAAI;EAMzB;;EAEH;AACJ;AACA;EACWC,IAAIA,CAAA,EAAS;IAChBZ,MAAM,CAACa,GAAG,CAAC,wCAAwC,CAAC;IACpD;IACA,IAAI,CAACC,aAAa,GAAG,KAAK;EAC9B;;EAEA;AACJ;AACA;EACWC,kBAAkBA,CAAA,EAAS;IAC9B,IAAI,CAACC,UAAU,CAAC,CAAC;EACrB;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACiBC,mBAAmBA,CAC5BC,WAAgC,EAChCC,UAAsC,EAEzB;IAAA,IAAAC,UAAA,GAAAC,SAAA;MAAAC,KAAA;IAAA,OAAAC,iBAAA;MAAA,IADbC,MAAM,GAAAJ,UAAA,CAAAK,MAAA,QAAAL,UAAA,QAAAM,SAAA,GAAAN,UAAA,MAAG,KAAK;MAEd,IAAMO,GAAG,SAASL,KAAI,CAACZ,WAAW,CAACkB,yBAAyB,CAACV,WAAW,CAAC;MACzE,IAAI,CAACS,GAAG,EAAE;QACN,MAAML,KAAI,CAACZ,WAAW,CAACmB,8BAA8B,CAAC;UAClDX,WAAW,EAAEA,WAAW;UACxBC,UAAU,EAAEA,UAAU;UACtBW,SAAS,EAAER,KAAI,CAACd,QAAQ,CAACuB,SAAS,CAAC,CAAC;UACpCC,KAAK,EAAE3B,mBAAmB,CAAC4B;QAC/B,CAAC,CAAC;MACN,CAAC,MAAM;QACH,QAAQN,GAAG,CAACK,KAAK;UACb,KAAK3B,mBAAmB,CAAC6B,gCAAgC;UACzD,KAAK7B,mBAAmB,CAAC4B,MAAM;YAC3B;YACA;UAEJ,KAAK5B,mBAAmB,CAAC8B,mBAAmB;YAAE;cAC1C;cACA;cACA;cACA,IAAMH,KAAK,GAAGR,MAAM,GACdnB,mBAAmB,CAAC6B,gCAAgC,GACpD7B,mBAAmB,CAAC+B,IAAI;cAC9B,MAAMd,KAAI,CAACZ,WAAW,CAAC2B,4BAA4B,CAC/CV,GAAG,CAACG,SAAS,EACbzB,mBAAmB,CAAC8B,mBAAmB,EACvC;gBACIH,KAAK;gBACLM,iBAAiB,EAAEhB,KAAI,CAACd,QAAQ,CAACuB,SAAS,CAAC;cAC/C,CACJ,CAAC;cACD;YACJ;UACA,KAAK1B,mBAAmB,CAAC+B,IAAI;YAAE;cAC3B;cACA;cACA;cACA,IAAIZ,MAAM,EAAE;gBACR,IAAMQ,MAAK,GAAG3B,mBAAmB,CAAC6B,gCAAgC;gBAClE,IAAMK,UAAU,SAASjB,KAAI,CAACZ,WAAW,CAAC2B,4BAA4B,CAClEV,GAAG,CAACG,SAAS,EACbzB,mBAAmB,CAAC+B,IAAI,EACxB;kBACIJ,KAAK,EAALA,MAAK;kBACLM,iBAAiB,EAAEhB,KAAI,CAACd,QAAQ,CAACuB,SAAS,CAAC,CAAC;kBAC5C;kBACA;kBACAS,YAAY,EAAElB,KAAI,CAACd,QAAQ,CAACuB,SAAS,CAAC;gBAC1C,CACJ,CAAC;gBACD,IAAI,CAACQ,UAAU,EAAE;kBACb;kBACA;kBACA;kBACA;kBACA,OAAOjB,KAAI,CAACL,mBAAmB,CAACC,WAAW,EAAEC,UAAU,EAAEK,MAAM,CAAC;gBACpE;;gBAEA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA,IAAI;kBACA,MAAMF,KAAI,CAACmB,sCAAsC,CAACF,UAAU,EAAE,IAAI,CAAC;gBACvE,CAAC,CAAC,OAAOG,CAAC,EAAE;kBACR1C,MAAM,CAAC2C,KAAK,CAAC,8CAA8C,GAAG,oBAAoB,EAAED,CAAC,CAAC;gBAC1F;gBACA;gBACA;gBACA;gBACA;cACJ;cACA;YACJ;UACA;YACI,MAAM,IAAIE,KAAK,CAAC,mBAAmB,GAAGjB,GAAG,CAACK,KAAK,CAAC;QACxD;MACJ;IAAC;EACL;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;EACWa,oBAAoBA,CAAC3B,WAAgC,EAAoB;IAC5E,OAAO,IAAI,CAACR,WAAW,CAACkB,yBAAyB,CAACV,WAAW,CAAC,CAAC4B,IAAI,CAAEnB,GAAG,IAAc;MAClF,IAAI,CAACA,GAAG,EAAE;QACN;QACA;MACJ;MACA,QAAQA,GAAG,CAACK,KAAK;QACb,KAAK3B,mBAAmB,CAAC8B,mBAAmB;QAC5C,KAAK9B,mBAAmB,CAAC6B,gCAAgC;UACrD;UACA;QAEJ,KAAK7B,mBAAmB,CAAC4B,MAAM;UAC3B;;UAEA;UACA;UACA;UACA;;UAEAjC,MAAM,CAACa,GAAG,CAAC,4CAA4C,GAAGkC,oBAAoB,CAAC7B,WAAW,CAAC,CAAC;UAC5F,OAAO,IAAI,CAACR,WAAW,CAACsC,4BAA4B,CAACrB,GAAG,CAACG,SAAS,EAAEzB,mBAAmB,CAAC4B,MAAM,CAAC;QAEnG,KAAK5B,mBAAmB,CAAC+B,IAAI;UAAE;YAC3B;YACA,OAAO,IAAI,CAAC1B,WAAW,CAClB2B,4BAA4B,CAACV,GAAG,CAACG,SAAS,EAAEzB,mBAAmB,CAAC+B,IAAI,EAAE;cACnEJ,KAAK,EAAE3B,mBAAmB,CAAC8B,mBAAmB;cAC9CG,iBAAiB,EAAE,IAAI,CAAC9B,QAAQ,CAACuB,SAAS,CAAC;YAC/C,CAAC,CAAC,CACDe,IAAI,CAAEP,UAAU,IAAK;cAClB,IAAI,CAACA,UAAU,EAAE;gBACb;gBACA;gBACA;gBACA;gBACA;gBACA;gBACAvC,MAAM,CAACa,GAAG,CACN,uCAAuC,GACnCkC,oBAAoB,CAAC7B,WAAW,CAAC,GACjC,8CACR,CAAC;gBACD;cACJ;;cAEA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA,IAAI,CAACuB,sCAAsC,CAACF,UAAU,CAAC,CAACU,KAAK,CAAEP,CAAC,IAAK;gBACjE1C,MAAM,CAAC2C,KAAK,CAAC,8CAA8C,GAAG,oBAAoB,EAAED,CAAC,CAAC;gBACtF,IAAI,CAAC1B,UAAU,CAAC,CAAC;cACrB,CAAC,CAAC;YACN,CAAC,CAAC;UACV;QACA;UACI,MAAM,IAAI4B,KAAK,CAAC,mBAAmB,GAAGjB,GAAG,CAACK,KAAK,CAAC;MACxD;IACJ,CAAC,CAAC;EACN;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;EACWkB,6BAA6BA,CAACC,MAAc,EAAE1C,QAAgB,EAAqC;IACtG,OAAO,IAAI,CAACC,WAAW,CAAC0C,kCAAkC,CAACD,MAAM,EAAE1C,QAAQ,EAAE,CAACJ,mBAAmB,CAAC+B,IAAI,CAAC,CAAC;EAC5G;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;EACiBiB,kCAAkCA,CAAA,EAAoB;IAAA,IAAAC,MAAA;IAAA,OAAA/B,iBAAA;MAC/D,IAAMgC,SAAS,SAASD,MAAI,CAAC5C,WAAW,CAAC8C,oCAAoC,CAACnD,mBAAmB,CAAC+B,IAAI,CAAC;MACvG,OAAOqB,OAAO,CAACC,GAAG,CACdH,SAAS,CAACI,GAAG,CAACC,IAAA;QAAA,IAAC;UAAE1C,WAAW;UAAEC;QAAW,CAAC,GAAAyC,IAAA;QAAA,OAAKN,MAAI,CAACrC,mBAAmB,CAACC,WAAW,EAAEC,UAAU,EAAE,IAAI,CAAC;MAAA,EAC1G,CAAC;IAAC;EACN;;EAEA;EACA;EACQH,UAAUA,CAAA,EAAS;IACvB,IAAI,IAAI,CAAC6C,gCAAgC,EAAE;MACvC;IACJ;IAEA,IAAMC,mCAAmC,GAAGA,CAAA,KAAY;MACpD,IAAI,IAAI,CAACC,kCAAkC,EAAE;QACzC,MAAM,IAAInB,KAAK,CAAC,yCAAyC,CAAC;MAC9D;MACA,IAAI,CAACmB,kCAAkC,GAAG,IAAI;MAE9C,IAAI,CAACC,2BAA2B,CAAC,CAAC,CAC7BC,OAAO,CAAC,MAAM;QACX,IAAI,CAACF,kCAAkC,GAAG,KAAK;MACnD,CAAC,CAAC,CACDd,KAAK,CAAEP,CAAC,IAAK;QACV;QACA;QACA1C,MAAM,CAACkE,IAAI,4CAAAC,MAAA,CAA4CzB,CAAC,CAAE,CAAC;MAC/D,CAAC,CAAC;IACV,CAAC;IAED,IAAI,CAACmB,gCAAgC,GAAGO,UAAU,CAC9CN,mCAAmC,EACnC1D,0BACJ,CAAC;EACL;;EAEA;EACA;EACA;EACc4D,2BAA2BA,CAAA,EAAkB;IAAA,IAAAK,MAAA;IAAA,OAAA9C,iBAAA;MACvD,IAAI,CAAC8C,MAAI,CAACvD,aAAa,EAAE;QACrBuD,MAAI,CAACR,gCAAgC,GAAGnC,SAAS;QACjD;MACJ;MAEA,IAAMC,GAAG,SAAS0C,MAAI,CAAC3D,WAAW,CAAC4D,gCAAgC,CAAC,CAChEjE,mBAAmB,CAAC8B,mBAAmB,EACvC9B,mBAAmB,CAAC6B,gCAAgC,EACpD7B,mBAAmB,CAAC4B,MAAM,CAC7B,CAAC;MAEF,IAAI,CAACN,GAAG,EAAE;QACN0C,MAAI,CAACR,gCAAgC,GAAGnC,SAAS;QACjD;MACJ;MAEA,IAAI;QACA,QAAQC,GAAG,CAACK,KAAK;UACb,KAAK3B,mBAAmB,CAAC4B,MAAM;YAC3B,MAAMoC,MAAI,CAACE,0BAA0B,CAAC5C,GAAG,CAAC;YAC1C;UACJ,KAAKtB,mBAAmB,CAAC8B,mBAAmB;YACxC,MAAMkC,MAAI,CAAC5B,sCAAsC,CAACd,GAAG,CAAC;YACtD;UACJ,KAAKtB,mBAAmB,CAAC6B,gCAAgC;YACrD,MAAMmC,MAAI,CAAC5B,sCAAsC,CAACd,GAAG,EAAE,IAAI,CAAC;YAC5D;QACR;;QAEA;QACA,OAAO0C,MAAI,CAACL,2BAA2B,CAAC,CAAC;MAC7C,CAAC,CAAC,OAAOtB,CAAC,EAAE;QACR1C,MAAM,CAAC2C,KAAK,CAAC,mDAAmD,EAAED,CAAC,CAAC;QACpE2B,MAAI,CAACR,gCAAgC,GAAGnC,SAAS;MACrD;IAAC;EACL;;EAEA;EACQ6C,0BAA0BA,CAAC5C,GAA2B,EAAoB;IAC9E3B,MAAM,CAACa,GAAG,CACN,uBAAAsD,MAAA,CAAuBpB,oBAAoB,CAACpB,GAAG,CAACT,WAAW,CAAC,aAAAiD,MAAA,CAC/CK,sBAAsB,CAAC7C,GAAG,CAACR,UAAU,CAAC,CAAE,UAAAgD,MAAA,CAC1CxC,GAAG,CAACG,SAAS,MAC5B,CAAC;IAED,IAAM2C,cAA8B,GAAG;MACnCC,MAAM,EAAE,SAAS;MACjBC,oBAAoB,EAAE,IAAI,CAAClE,QAAQ;MACnCmE,UAAU,EAAEjD,GAAG,CAACG,SAAS;MACzB+C,IAAI,EAAElD,GAAG,CAACT;IACd,CAAC;IAED,OAAO,IAAI,CAAC4D,oBAAoB,CAACL,cAAc,EAAE9C,GAAG,CAACR,UAAU,EAAEQ,GAAG,CAACa,YAAY,IAAIb,GAAG,CAACG,SAAS,CAAC,CAACgB,IAAI,CAAC,MAAM;MAC3G,OAAO,IAAI,CAACpC,WAAW,CAAC2B,4BAA4B,CAACV,GAAG,CAACG,SAAS,EAAEzB,mBAAmB,CAAC4B,MAAM,EAAE;QAC5FD,KAAK,EAAE3B,mBAAmB,CAAC+B;MAC/B,CAAC,CAAC;IACN,CAAC,CAAC;EACN;;EAEA;EACA;EACQK,sCAAsCA,CAACd,GAA2B,EAAuC;IAAA,IAArCoD,SAAS,GAAA1D,SAAA,CAAAI,MAAA,QAAAJ,SAAA,QAAAK,SAAA,GAAAL,SAAA,MAAG,KAAK;IACzFrB,MAAM,CAACa,GAAG,CACN,iDAAAsD,MAAA,CACOpB,oBAAoB,CAACpB,GAAG,CAACT,WAAW,CAAC,SAAM,MAAAiD,MAAA,CAC3CK,sBAAsB,CAAC7C,GAAG,CAACR,UAAU,CAAC,MAAG,uBAAAgD,MAAA,CACxBxC,GAAG,CAACW,iBAAiB,MACjD,CAAC;IAED,IAAMmC,cAA8B,GAAG;MACnCC,MAAM,EAAE,sBAAsB;MAC9BC,oBAAoB,EAAE,IAAI,CAAClE,QAAQ;MACnCmE,UAAU,EAAEjD,GAAG,CAACG;IACpB,CAAC;IAED,OAAO,IAAI,CAACgD,oBAAoB,CAACL,cAAc,EAAE9C,GAAG,CAACR,UAAU,EAAEQ,GAAG,CAACW,iBAAiB,CAAC,CAACQ,IAAI,CAAC,MAAM;MAC/F,IAAIiC,SAAS,EAAE;QACX;QACA,OAAO,IAAI,CAACrE,WAAW,CAAC2B,4BAA4B,CAChDV,GAAG,CAACG,SAAS,EACbzB,mBAAmB,CAAC6B,gCAAgC,EACpD;UAAEF,KAAK,EAAE3B,mBAAmB,CAAC4B;QAAO,CACxC,CAAC;MACL;MACA,OAAO,IAAI,CAACvB,WAAW,CAACsC,4BAA4B,CAChDrB,GAAG,CAACG,SAAS,EACbzB,mBAAmB,CAAC8B,mBACxB,CAAC;IACL,CAAC,CAAC;EACN;;EAEA;EACQ2C,oBAAoBA,CACxBE,OAAuB,EACvB7D,UAAsC,EACtC8D,KAAc,EACH;IACX,IAAMC,UAAU,GAAG,IAAI/E,cAAc,CAA2C,MAAM,IAAIgF,GAAG,CAAC,CAAC,CAAC;IAChG,KAAK,IAAMC,KAAK,IAAIjE,UAAU,EAAE;MAC5B,IAAMkE,aAAa,GAAGH,UAAU,CAACI,WAAW,CAACF,KAAK,CAACjC,MAAM,CAAC;MAC1DkC,aAAa,CAACE,GAAG,CAACH,KAAK,CAAC3E,QAAQ,EAAA+E,aAAA,CAAAA,aAAA,KACzBR,OAAO;QACV,CAAC9E,iBAAiB,GAAGH,MAAM,CAAC;MAAC,EAChC,CAAC;IACN;IAEA,OAAO,IAAI,CAACS,QAAQ,CAACiF,YAAY,CAACxF,SAAS,CAACyF,cAAc,EAAER,UAAU,EAAED,KAAK,CAAC;EAClF;AACJ;AAEA,SAASlC,oBAAoBA,CAAC7B,WAAgC,EAAU;EACpE;EACA;EACA,OAAOA,WAAW,CAACyE,OAAO,GAAG,KAAK,GAAGzE,WAAW,CAAC0E,UAAU;AAC/D;AAEA,SAASpB,sBAAsBA,CAACrD,UAAsC,EAAU;EAC5E,WAAAgD,MAAA,CAAWhD,UAAU,CAACwC,GAAG,CAAEkC,CAAC,OAAA1B,MAAA,CAAQ0B,CAAC,CAAC1C,MAAM,OAAAgB,MAAA,CAAI0B,CAAC,CAACpF,QAAQ,CAAE,CAAC,CAACqF,IAAI,CAAC,GAAG,CAAC;AAC3E","ignoreList":[]}

package/lib/crypto/RoomList.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Manages the list of encrypted rooms
+ */
+import { CryptoStore } from "./store/base.ts";
+export interface IRoomEncryption {
+    algorithm: string;
+    rotation_period_ms?: number;
+    rotation_period_msgs?: number;
+}
+/**
+ * Information about the encryption settings of rooms. Loads this information
+ * from the supplied crypto store when `init()` is called, and saves it to the
+ * crypto store whenever it is updated via `setRoomEncryption()`. Can supply
+ * full information about a room's encryption via `getRoomEncryption()`, or just
+ * answer whether or not a room has encryption via `isRoomEncrypted`.
+ */
+export declare class RoomList {
+    private readonly cryptoStore?;
+    private roomEncryption;
+    constructor(cryptoStore?: CryptoStore | undefined);
+    init(): Promise<void>;
+    getRoomEncryption(roomId: string): IRoomEncryption | null;
+    isRoomEncrypted(roomId: string): boolean;
+    setRoomEncryption(roomId: string, roomInfo: IRoomEncryption): Promise<void>;
+}
+//# sourceMappingURL=RoomList.d.ts.map

package/lib/crypto/RoomList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoomList.d.ts","sourceRoot":"","sources":["../../src/crypto/RoomList.ts"],"names":[],"mappings":"AAgBA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAI9C,MAAM,WAAW,eAAe;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACjC;AAGD;;;;;;GAMG;AACH,qBAAa,QAAQ;IAIE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAFhD,OAAO,CAAC,cAAc,CAAuC;gBAEzB,WAAW,CAAC,EAAE,WAAW,YAAA;IAEhD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ3B,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI;IAIzD,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIlC,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;CAS3F"}

package/lib/crypto/RoomList.js

@@ -0,0 +1,71 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*
+Copyright 2018 - 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 encrypted rooms
+ */
+
+import { IndexedDBCryptoStore } from "./store/indexeddb-crypto-store.js";
+
+/* eslint-disable camelcase */
+
+/* eslint-enable camelcase */
+
+/**
+ * Information about the encryption settings of rooms. Loads this information
+ * from the supplied crypto store when `init()` is called, and saves it to the
+ * crypto store whenever it is updated via `setRoomEncryption()`. Can supply
+ * full information about a room's encryption via `getRoomEncryption()`, or just
+ * answer whether or not a room has encryption via `isRoomEncrypted`.
+ */
+export class RoomList {
+  constructor(cryptoStore) {
+    this.cryptoStore = cryptoStore;
+    // Object of roomId -> room e2e info object (body of the m.room.encryption event)
+    _defineProperty(this, "roomEncryption", {});
+  }
+  init() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      yield _this.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ROOMS], txn => {
+        _this.cryptoStore.getEndToEndRooms(txn, result => {
+          _this.roomEncryption = result;
+        });
+      });
+    })();
+  }
+  getRoomEncryption(roomId) {
+    return this.roomEncryption[roomId] || null;
+  }
+  isRoomEncrypted(roomId) {
+    return Boolean(this.getRoomEncryption(roomId));
+  }
+  setRoomEncryption(roomId, roomInfo) {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      // important that this happens before calling into the store
+      // as it prevents the Crypto::setRoomEncryption from calling
+      // this twice for consecutive m.room.encryption events
+      _this2.roomEncryption[roomId] = roomInfo;
+      yield _this2.cryptoStore.doTxn("readwrite", [IndexedDBCryptoStore.STORE_ROOMS], txn => {
+        _this2.cryptoStore.storeEndToEndRoom(roomId, roomInfo, txn);
+      });
+    })();
+  }
+}
+//# sourceMappingURL=RoomList.js.map

package/lib/crypto/RoomList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoomList.js","names":["IndexedDBCryptoStore","RoomList","constructor","cryptoStore","_defineProperty","init","_this","_asyncToGenerator","doTxn","STORE_ROOMS","txn","getEndToEndRooms","result","roomEncryption","getRoomEncryption","roomId","isRoomEncrypted","Boolean","setRoomEncryption","roomInfo","_this2","storeEndToEndRoom"],"sources":["../../src/crypto/RoomList.ts"],"sourcesContent":["/*\nCopyright 2018 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Manages the list of encrypted rooms\n */\n\nimport { CryptoStore } from \"./store/base.ts\";\nimport { IndexedDBCryptoStore } from \"./store/indexeddb-crypto-store.ts\";\n\n/* eslint-disable camelcase */\nexport interface IRoomEncryption {\n    algorithm: string;\n    rotation_period_ms?: number;\n    rotation_period_msgs?: number;\n}\n/* eslint-enable camelcase */\n\n/**\n * Information about the encryption settings of rooms. Loads this information\n * from the supplied crypto store when `init()` is called, and saves it to the\n * crypto store whenever it is updated via `setRoomEncryption()`. Can supply\n * full information about a room's encryption via `getRoomEncryption()`, or just\n * answer whether or not a room has encryption via `isRoomEncrypted`.\n */\nexport class RoomList {\n    // Object of roomId -> room e2e info object (body of the m.room.encryption event)\n    private roomEncryption: Record<string, IRoomEncryption> = {};\n\n    public constructor(private readonly cryptoStore?: CryptoStore) {}\n\n    public async init(): Promise<void> {\n        await this.cryptoStore!.doTxn(\"readwrite\", [IndexedDBCryptoStore.STORE_ROOMS], (txn) => {\n            this.cryptoStore!.getEndToEndRooms(txn, (result) => {\n                this.roomEncryption = result;\n            });\n        });\n    }\n\n    public getRoomEncryption(roomId: string): IRoomEncryption | null {\n        return this.roomEncryption[roomId] || null;\n    }\n\n    public isRoomEncrypted(roomId: string): boolean {\n        return Boolean(this.getRoomEncryption(roomId));\n    }\n\n    public async setRoomEncryption(roomId: string, roomInfo: IRoomEncryption): Promise<void> {\n        // important that this happens before calling into the store\n        // as it prevents the Crypto::setRoomEncryption from calling\n        // this twice for consecutive m.room.encryption events\n        this.roomEncryption[roomId] = roomInfo;\n        await this.cryptoStore!.doTxn(\"readwrite\", [IndexedDBCryptoStore.STORE_ROOMS], (txn) => {\n            this.cryptoStore!.storeEndToEndRoom(roomId, roomInfo, txn);\n        });\n    }\n}\n"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAGA,SAASA,oBAAoB,QAAQ,mCAAmC;;AAExE;;AAMA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,QAAQ,CAAC;EAIXC,WAAWA,CAAkBC,WAAyB,EAAE;IAAA,KAA3BA,WAAyB,GAAzBA,WAAyB;IAH7D;IAAAC,eAAA,yBAC0D,CAAC,CAAC;EAEI;EAEnDC,IAAIA,CAAA,EAAkB;IAAA,IAAAC,KAAA;IAAA,OAAAC,iBAAA;MAC/B,MAAMD,KAAI,CAACH,WAAW,CAAEK,KAAK,CAAC,WAAW,EAAE,CAACR,oBAAoB,CAACS,WAAW,CAAC,EAAGC,GAAG,IAAK;QACpFJ,KAAI,CAACH,WAAW,CAAEQ,gBAAgB,CAACD,GAAG,EAAGE,MAAM,IAAK;UAChDN,KAAI,CAACO,cAAc,GAAGD,MAAM;QAChC,CAAC,CAAC;MACN,CAAC,CAAC;IAAC;EACP;EAEOE,iBAAiBA,CAACC,MAAc,EAA0B;IAC7D,OAAO,IAAI,CAACF,cAAc,CAACE,MAAM,CAAC,IAAI,IAAI;EAC9C;EAEOC,eAAeA,CAACD,MAAc,EAAW;IAC5C,OAAOE,OAAO,CAAC,IAAI,CAACH,iBAAiB,CAACC,MAAM,CAAC,CAAC;EAClD;EAEaG,iBAAiBA,CAACH,MAAc,EAAEI,QAAyB,EAAiB;IAAA,IAAAC,MAAA;IAAA,OAAAb,iBAAA;MACrF;MACA;MACA;MACAa,MAAI,CAACP,cAAc,CAACE,MAAM,CAAC,GAAGI,QAAQ;MACtC,MAAMC,MAAI,CAACjB,WAAW,CAAEK,KAAK,CAAC,WAAW,EAAE,CAACR,oBAAoB,CAACS,WAAW,CAAC,EAAGC,GAAG,IAAK;QACpFU,MAAI,CAACjB,WAAW,CAAEkB,iBAAiB,CAACN,MAAM,EAAEI,QAAQ,EAAET,GAAG,CAAC;MAC9D,CAAC,CAAC;IAAC;EACP;AACJ","ignoreList":[]}

package/lib/crypto/SecretSharing.d.ts

@@ -0,0 +1,24 @@
+import { MatrixClient } from "../client.ts";
+import { ICryptoCallbacks } from "./index.ts";
+import { MatrixEvent } from "../models/event.ts";
+export interface ISecretRequest {
+    requestId: string;
+    promise: Promise<string>;
+    cancel: (reason: string) => void;
+}
+export declare class SecretSharing {
+    private readonly baseApis;
+    private readonly cryptoCallbacks;
+    private requests;
+    constructor(baseApis: MatrixClient, cryptoCallbacks: ICryptoCallbacks);
+    /**
+     * Request a secret from another device
+     *
+     * @param name - the name of the secret to request
+     * @param devices - the devices to request the secret from
+     */
+    request(name: string, devices: string[]): ISecretRequest;
+    onRequestReceived(event: MatrixEvent): Promise<void>;
+    onSecretReceived(event: MatrixEvent): void;
+}
+//# sourceMappingURL=SecretSharing.d.ts.map

package/lib/crypto/SecretSharing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecretSharing.d.ts","sourceRoot":"","sources":["../../src/crypto/SecretSharing.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAqB,MAAM,YAAY,CAAC;AAIjE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAGjD,MAAM,WAAW,cAAc;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACzB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAQD,qBAAa,aAAa;IAIlB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAJpC,OAAO,CAAC,QAAQ,CAA6C;gBAGxC,QAAQ,EAAE,YAAY,EACtB,eAAe,EAAE,gBAAgB;IAGtD;;;;;OAKG;IACI,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc;IA8ClD,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAyF1D,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;CAqDpD"}