@unwanted/matrix-sdk-mini 34.12.0 → 36.0.0

package/lib/crypto/verification/request/VerificationRequest.js

@@ -1,937 +0,0 @@
-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.
-*/
-
-import { logger } from "../../../logger.js";
-import { errorFactory, errorFromEvent, newUnexpectedMessageError, newUnknownMethodError } from "../Error.js";
-import { QRCodeData, SCAN_QR_CODE_METHOD } from "../QRCode.js";
-import { EventType } from "../../../@types/event.js";
-import { TypedEventEmitter } from "../../../models/typed-event-emitter.js";
-import { canAcceptVerificationRequest, VerificationPhase as Phase, VerificationRequestEvent } from "../../../crypto-api/verification.js";
-
-// backwards-compatibility exports
-export { VerificationPhase as Phase, VerificationRequestEvent } from "../../../crypto-api/verification.js";
-
-// How long after the event's timestamp that the request times out
-var TIMEOUT_FROM_EVENT_TS = 10 * 60 * 1000; // 10 minutes
-
-// How long after we receive the event that the request times out
-var TIMEOUT_FROM_EVENT_RECEIPT = 2 * 60 * 1000; // 2 minutes
-
-// to avoid almost expired verification notifications
-// from showing a notification and almost immediately
-// disappearing, also ignore verification requests that
-// are this amount of time away from expiring.
-var VERIFICATION_REQUEST_MARGIN = 3 * 1000; // 3 seconds
-
-export var EVENT_PREFIX = "m.key.verification.";
-export var REQUEST_TYPE = EVENT_PREFIX + "request";
-export var START_TYPE = EVENT_PREFIX + "start";
-export var CANCEL_TYPE = EVENT_PREFIX + "cancel";
-export var DONE_TYPE = EVENT_PREFIX + "done";
-export var READY_TYPE = EVENT_PREFIX + "ready";
-
-// Legacy export fields
-export var PHASE_UNSENT = Phase.Unsent;
-export var PHASE_REQUESTED = Phase.Requested;
-export var PHASE_READY = Phase.Ready;
-export var PHASE_STARTED = Phase.Started;
-export var PHASE_CANCELLED = Phase.Cancelled;
-export var PHASE_DONE = Phase.Done;
-/**
- * State machine for verification requests.
- * Things that differ based on what channel is used to
- * send and receive verification events are put in `InRoomChannel` or `ToDeviceChannel`.
- *
- * @deprecated Avoid direct references: instead prefer {@link Crypto.VerificationRequest}.
- */
-export class VerificationRequest extends TypedEventEmitter {
-  constructor(channel, verificationMethods, client) {
-    var _this;
-    super();
-    _this = this;
-    this.channel = channel;
-    this.verificationMethods = verificationMethods;
-    this.client = client;
-    _defineProperty(this, "eventsByUs", new Map());
-    _defineProperty(this, "eventsByThem", new Map());
-    _defineProperty(this, "_observeOnly", false);
-    _defineProperty(this, "timeoutTimer", null);
-    _defineProperty(this, "_accepting", false);
-    _defineProperty(this, "_declining", false);
-    _defineProperty(this, "verifierHasFinished", false);
-    _defineProperty(this, "_cancelled", false);
-    _defineProperty(this, "_chosenMethod", null);
-    // we keep a copy of the QR Code data (including other user master key) around
-    // for QR reciprocate verification, to protect against
-    // cross-signing identity reset between the .ready and .start event
-    // and signing the wrong key after .start
-    _defineProperty(this, "_qrCodeData", null);
-    // The timestamp when we received the request event from the other side
-    _defineProperty(this, "requestReceivedAt", null);
-    _defineProperty(this, "commonMethods", []);
-    _defineProperty(this, "_phase", void 0);
-    _defineProperty(this, "_cancellingUserId", void 0);
-    // Used in tests only
-    _defineProperty(this, "_verifier", void 0);
-    _defineProperty(this, "cancelOnTimeout", /*#__PURE__*/_asyncToGenerator(function* () {
-      try {
-        if (_this.initiatedByMe) {
-          yield _this.cancel({
-            reason: "Other party didn't accept in time",
-            code: "m.timeout"
-          });
-        } else {
-          yield _this.cancel({
-            reason: "User didn't accept in time",
-            code: "m.timeout"
-          });
-        }
-      } catch (err) {
-        logger.error("Error while cancelling verification request", err);
-      }
-    }));
-    this.channel.request = this;
-    this.setPhase(PHASE_UNSENT, false);
-  }
-
-  /**
-   * Stateless validation logic not specific to the channel.
-   * Invoked by the same static method in either channel.
-   * @param type - the "symbolic" event type, as returned by the `getEventType` function on the channel.
-   * @param event - the event to validate. Don't call getType() on it but use the `type` parameter instead.
-   * @param client - the client to get the current user and device id from
-   * @returns whether the event is valid and should be passed to handleEvent
-   */
-  static validateEvent(type, event, client) {
-    var content = event.getContent();
-    if (!type || !type.startsWith(EVENT_PREFIX)) {
-      return false;
-    }
-
-    // from here on we're fairly sure that this is supposed to be
-    // part of a verification request, so be noisy when rejecting something
-    if (!content) {
-      logger.log("VerificationRequest: validateEvent: no content");
-      return false;
-    }
-    if (type === REQUEST_TYPE || type === READY_TYPE) {
-      if (!Array.isArray(content.methods)) {
-        logger.log("VerificationRequest: validateEvent: " + "fail because methods");
-        return false;
-      }
-    }
-    if (type === REQUEST_TYPE || type === READY_TYPE || type === START_TYPE) {
-      if (typeof content.from_device !== "string" || content.from_device.length === 0) {
-        logger.log("VerificationRequest: validateEvent: " + "fail because from_device");
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Unique ID for this verification request.
-   *
-   * An ID isn't assigned until the first message is sent, so this may be `undefined` in the early phases.
-   */
-  get transactionId() {
-    return this.channel.transactionId;
-  }
-
-  /**
-   * For an in-room verification, the ID of the room.
-   */
-  get roomId() {
-    return this.channel.roomId;
-  }
-  get invalid() {
-    return this.phase === PHASE_UNSENT;
-  }
-
-  /** returns whether the phase is PHASE_REQUESTED */
-  get requested() {
-    return this.phase === PHASE_REQUESTED;
-  }
-
-  /** returns whether the phase is PHASE_CANCELLED */
-  get cancelled() {
-    return this.phase === PHASE_CANCELLED;
-  }
-
-  /** returns whether the phase is PHASE_READY */
-  get ready() {
-    return this.phase === PHASE_READY;
-  }
-
-  /** returns whether the phase is PHASE_STARTED */
-  get started() {
-    return this.phase === PHASE_STARTED;
-  }
-
-  /** returns whether the phase is PHASE_DONE */
-  get done() {
-    return this.phase === PHASE_DONE;
-  }
-
-  /** once the phase is PHASE_STARTED (and !initiatedByMe) or PHASE_READY: common methods supported by both sides */
-  get methods() {
-    return this.commonMethods;
-  }
-
-  /** the method picked in the .start event */
-  get chosenMethod() {
-    return this._chosenMethod;
-  }
-  calculateEventTimeout(event) {
-    var effectiveExpiresAt = this.channel.getTimestamp(event) + TIMEOUT_FROM_EVENT_TS;
-    if (this.requestReceivedAt && !this.initiatedByMe && this.phase <= PHASE_REQUESTED) {
-      var expiresAtByReceipt = this.requestReceivedAt + TIMEOUT_FROM_EVENT_RECEIPT;
-      effectiveExpiresAt = Math.min(effectiveExpiresAt, expiresAtByReceipt);
-    }
-    return Math.max(0, effectiveExpiresAt - Date.now());
-  }
-
-  /** The current remaining amount of ms before the request should be automatically cancelled */
-  get timeout() {
-    var requestEvent = this.getEventByEither(REQUEST_TYPE);
-    if (requestEvent) {
-      return this.calculateEventTimeout(requestEvent);
-    }
-    return 0;
-  }
-
-  /**
-   * The key verification request event.
-   * @returns The request event, or falsey if not found.
-   */
-  get requestEvent() {
-    return this.getEventByEither(REQUEST_TYPE);
-  }
-
-  /** current phase of the request. Some properties might only be defined in a current phase. */
-  get phase() {
-    return this._phase;
-  }
-
-  /** The verifier to do the actual verification, once the method has been established. Only defined when the `phase` is PHASE_STARTED. */
-  get verifier() {
-    return this._verifier;
-  }
-  get canAccept() {
-    return canAcceptVerificationRequest(this);
-  }
-  get accepting() {
-    return this._accepting;
-  }
-  get declining() {
-    return this._declining;
-  }
-
-  /** whether this request has sent it's initial event and needs more events to complete */
-  get pending() {
-    return !this.observeOnly && this._phase !== PHASE_DONE && this._phase !== PHASE_CANCELLED;
-  }
-
-  /** Only set after a .ready if the other party can scan a QR code
-   *
-   * @deprecated Prefer `generateQRCode`.
-   */
-  get qrCodeData() {
-    return this._qrCodeData;
-  }
-
-  /**
-   * Get the data for a QR code allowing the other device to verify this one, if it supports it.
-   *
-   * Only set after a .ready if the other party can scan a QR code, otherwise undefined.
-   *
-   * @deprecated Prefer `generateQRCode`.
-   */
-  getQRCodeBytes() {
-    var _this$_qrCodeData;
-    return (_this$_qrCodeData = this._qrCodeData) === null || _this$_qrCodeData === void 0 ? void 0 : _this$_qrCodeData.getBuffer();
-  }
-
-  /**
-   * Generate the data for a QR code allowing the other device to verify this one, if it supports it.
-   *
-   * Only returns data once `phase` is `Ready` and the other party can scan a QR code;
-   * otherwise returns `undefined`.
-   */
-  generateQRCode() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      return _this2.getQRCodeBytes();
-    })();
-  }
-
-  /** Checks whether the other party supports a given verification method.
-   *  This is useful when setting up the QR code UI, as it is somewhat asymmetrical:
-   *  if the other party supports SCAN_QR, we should show a QR code in the UI, and vice versa.
-   *  For methods that need to be supported by both ends, use the `methods` property.
-   *  @param method - the method to check
-   *  @param force - to check even if the phase is not ready or started yet, internal usage
-   *  @returns whether or not the other party said the supported the method */
-  otherPartySupportsMethod(method) {
-    var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    if (!force && !this.ready && !this.started) {
-      return false;
-    }
-    var theirMethodEvent = this.eventsByThem.get(REQUEST_TYPE) || this.eventsByThem.get(READY_TYPE);
-    if (!theirMethodEvent) {
-      // if we started straight away with .start event,
-      // we are assuming that the other side will support the
-      // chosen method, so return true for that.
-      if (this.started && this.initiatedByMe) {
-        var myStartEvent = this.eventsByUs.get(START_TYPE);
-        var _content = myStartEvent && myStartEvent.getContent();
-        var myStartMethod = _content && _content.method;
-        return method == myStartMethod;
-      }
-      return false;
-    }
-    var content = theirMethodEvent.getContent();
-    if (!content) {
-      return false;
-    }
-    var {
-      methods
-    } = content;
-    if (!Array.isArray(methods)) {
-      return false;
-    }
-    return methods.includes(method);
-  }
-
-  /** Whether this request was initiated by the syncing user.
-   * For InRoomChannel, this is who sent the .request event.
-   * For ToDeviceChannel, this is who sent the .start event
-   */
-  get initiatedByMe() {
-    // event created by us but no remote echo has been received yet
-    var noEventsYet = this.eventsByUs.size + this.eventsByThem.size === 0;
-    if (this._phase === PHASE_UNSENT && noEventsYet) {
-      return true;
-    }
-    var hasMyRequest = this.eventsByUs.has(REQUEST_TYPE);
-    var hasTheirRequest = this.eventsByThem.has(REQUEST_TYPE);
-    if (hasMyRequest && !hasTheirRequest) {
-      return true;
-    }
-    if (!hasMyRequest && hasTheirRequest) {
-      return false;
-    }
-    var hasMyStart = this.eventsByUs.has(START_TYPE);
-    var hasTheirStart = this.eventsByThem.has(START_TYPE);
-    if (hasMyStart && !hasTheirStart) {
-      return true;
-    }
-    return false;
-  }
-
-  /** The id of the user that initiated the request */
-  get requestingUserId() {
-    if (this.initiatedByMe) {
-      return this.client.getUserId();
-    } else {
-      return this.otherUserId;
-    }
-  }
-
-  /** The id of the user that (will) receive(d) the request */
-  get receivingUserId() {
-    if (this.initiatedByMe) {
-      return this.otherUserId;
-    } else {
-      return this.client.getUserId();
-    }
-  }
-
-  /** The user id of the other party in this request */
-  get otherUserId() {
-    return this.channel.userId;
-  }
-
-  /** The device id of the other party in this request, for requests happening over to-device messages only. */
-  get otherDeviceId() {
-    return this.channel.deviceId;
-  }
-  get isSelfVerification() {
-    return this.client.getUserId() === this.otherUserId;
-  }
-
-  /**
-   * The id of the user that cancelled the request,
-   * only defined when phase is PHASE_CANCELLED
-   */
-  get cancellingUserId() {
-    var myCancel = this.eventsByUs.get(CANCEL_TYPE);
-    var theirCancel = this.eventsByThem.get(CANCEL_TYPE);
-    if (myCancel && (!theirCancel || myCancel.getId() < theirCancel.getId())) {
-      return myCancel.getSender();
-    }
-    if (theirCancel) {
-      return theirCancel.getSender();
-    }
-    return undefined;
-  }
-
-  /**
-   * The cancellation code e.g m.user which is responsible for cancelling this verification
-   */
-  get cancellationCode() {
-    var ev = this.getEventByEither(CANCEL_TYPE);
-    return ev ? ev.getContent().code : null;
-  }
-  get observeOnly() {
-    return this._observeOnly;
-  }
-
-  /**
-   * Gets which device the verification should be started with
-   * given the events sent so far in the verification. This is the
-   * same algorithm used to determine which device to send the
-   * verification to when no specific device is specified.
-   * @returns The device information
-   */
-  get targetDevice() {
-    var theirFirstEvent = this.eventsByThem.get(REQUEST_TYPE) || this.eventsByThem.get(READY_TYPE) || this.eventsByThem.get(START_TYPE);
-    var theirFirstContent = theirFirstEvent === null || theirFirstEvent === void 0 ? void 0 : theirFirstEvent.getContent();
-    var fromDevice = theirFirstContent === null || theirFirstContent === void 0 ? void 0 : theirFirstContent.from_device;
-    return {
-      userId: this.otherUserId,
-      deviceId: fromDevice
-    };
-  }
-
-  /* Start the key verification, creating a verifier and sending a .start event.
-   * If no previous events have been sent, pass in `targetDevice` to set who to direct this request to.
-   * @param method - the name of the verification method to use.
-   * @param targetDevice.userId the id of the user to direct this request to
-   * @param targetDevice.deviceId the id of the device to direct this request to
-   * @returns the verifier of the given method
-   */
-  beginKeyVerification(method) {
-    var targetDevice = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    // need to allow also when unsent in case of to_device
-    if (!this.observeOnly && !this._verifier) {
-      var validStartPhase = this.phase === PHASE_REQUESTED || this.phase === PHASE_READY || this.phase === PHASE_UNSENT && this.channel.canCreateRequest(START_TYPE);
-      if (validStartPhase) {
-        // when called on a request that was initiated with .request event
-        // check the method is supported by both sides
-        if (this.commonMethods.length && !this.commonMethods.includes(method)) {
-          throw newUnknownMethodError();
-        }
-        this._verifier = this.createVerifier(method, null, targetDevice);
-        if (!this._verifier) {
-          throw newUnknownMethodError();
-        }
-        this._chosenMethod = method;
-      }
-    }
-    return this._verifier;
-  }
-  startVerification(method) {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      var verifier = _this3.beginKeyVerification(method);
-      // kick off the verification in the background, but *don't* wait for to complete: we need to return the `Verifier`.
-      verifier.verify();
-      return verifier;
-    })();
-  }
-  scanQRCode(qrCodeData) {
-    throw new Error("QR code scanning not supported by legacy crypto");
-  }
-
-  /**
-   * sends the initial .request event.
-   * @returns resolves when the event has been sent.
-   */
-  sendRequest() {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this4.observeOnly && _this4._phase === PHASE_UNSENT) {
-        var methods = [..._this4.verificationMethods.keys()];
-        yield _this4.channel.send(REQUEST_TYPE, {
-          methods
-        });
-      }
-    })();
-  }
-
-  /**
-   * Cancels the request, sending a cancellation to the other party
-   * @param params
-   * @param params.reason - the error reason to send the cancellation with
-   * @param params.code - the error code to send the cancellation with
-   * @returns resolves when the event has been sent.
-   */
-  cancel() {
-    var _arguments = arguments,
-      _this5 = this;
-    return _asyncToGenerator(function* () {
-      var {
-        reason = "User declined",
-        code = "m.user"
-      } = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : {};
-      if (!_this5.observeOnly && _this5._phase !== PHASE_CANCELLED) {
-        _this5._declining = true;
-        _this5.emit(VerificationRequestEvent.Change);
-        if (_this5._verifier) {
-          return _this5._verifier.cancel(errorFactory(code, reason)());
-        } else {
-          _this5._cancellingUserId = _this5.client.getUserId();
-          yield _this5.channel.send(CANCEL_TYPE, {
-            code,
-            reason
-          });
-        }
-      }
-    })();
-  }
-
-  /**
-   * Accepts the request, sending a .ready event to the other party
-   * @returns resolves when the event has been sent.
-   */
-  accept() {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this6.observeOnly && _this6.phase === PHASE_REQUESTED && !_this6.initiatedByMe) {
-        var methods = [..._this6.verificationMethods.keys()];
-        _this6._accepting = true;
-        _this6.emit(VerificationRequestEvent.Change);
-        yield _this6.channel.send(READY_TYPE, {
-          methods
-        });
-      }
-    })();
-  }
-
-  /**
-   * Can be used to listen for state changes until the callback returns true.
-   * @param fn - callback to evaluate whether the request is in the desired state.
-   *                      Takes the request as an argument.
-   * @returns that resolves once the callback returns true
-   * @throws Error when the request is cancelled
-   */
-  waitFor(fn) {
-    return new Promise((resolve, reject) => {
-      var check = () => {
-        var handled = false;
-        if (fn(this)) {
-          resolve(this);
-          handled = true;
-        } else if (this.cancelled) {
-          reject(new Error("cancelled"));
-          handled = true;
-        }
-        if (handled) {
-          this.off(VerificationRequestEvent.Change, check);
-        }
-        return handled;
-      };
-      if (!check()) {
-        this.on(VerificationRequestEvent.Change, check);
-      }
-    });
-  }
-  setPhase(phase) {
-    var notify = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    this._phase = phase;
-    if (notify) {
-      this.emit(VerificationRequestEvent.Change);
-    }
-  }
-  getEventByEither(type) {
-    return this.eventsByThem.get(type) || this.eventsByUs.get(type);
-  }
-  getEventBy(type) {
-    var byThem = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    if (byThem) {
-      return this.eventsByThem.get(type);
-    } else {
-      return this.eventsByUs.get(type);
-    }
-  }
-  calculatePhaseTransitions() {
-    var transitions = [{
-      phase: PHASE_UNSENT
-    }];
-    var phase = () => transitions[transitions.length - 1].phase;
-
-    // always pass by .request first to be sure channel.userId has been set
-    var hasRequestByThem = this.eventsByThem.has(REQUEST_TYPE);
-    var requestEvent = this.getEventBy(REQUEST_TYPE, hasRequestByThem);
-    if (requestEvent) {
-      transitions.push({
-        phase: PHASE_REQUESTED,
-        event: requestEvent
-      });
-    }
-    var readyEvent = requestEvent && this.getEventBy(READY_TYPE, !hasRequestByThem);
-    if (readyEvent && phase() === PHASE_REQUESTED) {
-      transitions.push({
-        phase: PHASE_READY,
-        event: readyEvent
-      });
-    }
-    var startEvent;
-    if (readyEvent || !requestEvent) {
-      var theirStartEvent = this.eventsByThem.get(START_TYPE);
-      var ourStartEvent = this.eventsByUs.get(START_TYPE);
-      // any party can send .start after a .ready or unsent
-      if (theirStartEvent && ourStartEvent) {
-        startEvent = theirStartEvent.getSender() < ourStartEvent.getSender() ? theirStartEvent : ourStartEvent;
-      } else {
-        startEvent = theirStartEvent ? theirStartEvent : ourStartEvent;
-      }
-    } else {
-      startEvent = this.getEventBy(START_TYPE, !hasRequestByThem);
-    }
-    if (startEvent) {
-      var fromRequestPhase = phase() === PHASE_REQUESTED && (requestEvent === null || requestEvent === void 0 ? void 0 : requestEvent.getSender()) !== startEvent.getSender();
-      var fromUnsentPhase = phase() === PHASE_UNSENT && this.channel.canCreateRequest(START_TYPE);
-      if (fromRequestPhase || phase() === PHASE_READY || fromUnsentPhase) {
-        transitions.push({
-          phase: PHASE_STARTED,
-          event: startEvent
-        });
-      }
-    }
-    var ourDoneEvent = this.eventsByUs.get(DONE_TYPE);
-    if (this.verifierHasFinished || ourDoneEvent && phase() === PHASE_STARTED) {
-      transitions.push({
-        phase: PHASE_DONE
-      });
-    }
-    var cancelEvent = this.getEventByEither(CANCEL_TYPE);
-    if ((this._cancelled || cancelEvent) && phase() !== PHASE_DONE) {
-      transitions.push({
-        phase: PHASE_CANCELLED,
-        event: cancelEvent
-      });
-      return transitions;
-    }
-    return transitions;
-  }
-  transitionToPhase(transition) {
-    var {
-      phase,
-      event
-    } = transition;
-    // get common methods
-    if (phase === PHASE_REQUESTED || phase === PHASE_READY) {
-      if (!this.wasSentByOwnDevice(event)) {
-        var content = event.getContent();
-        this.commonMethods = content.methods.filter(m => this.verificationMethods.has(m));
-      }
-    }
-    // detect if we're not a party in the request, and we should just observe
-    if (!this.observeOnly) {
-      // if requested or accepted by one of my other devices
-      if (phase === PHASE_REQUESTED || phase === PHASE_STARTED || phase === PHASE_READY) {
-        if (this.channel.receiveStartFromOtherDevices && this.wasSentByOwnUser(event) && !this.wasSentByOwnDevice(event)) {
-          this._observeOnly = true;
-        }
-      }
-    }
-    // create verifier
-    if (phase === PHASE_STARTED) {
-      var {
-        method
-      } = event.getContent();
-      if (!this._verifier && !this.observeOnly) {
-        this._verifier = this.createVerifier(method, event);
-        if (!this._verifier) {
-          this.cancel({
-            code: "m.unknown_method",
-            reason: "Unknown method: ".concat(method)
-          });
-        } else {
-          this._chosenMethod = method;
-        }
-      }
-    }
-  }
-  applyPhaseTransitions() {
-    var transitions = this.calculatePhaseTransitions();
-    var existingIdx = transitions.findIndex(t => t.phase === this.phase);
-    // trim off phases we already went through, if any
-    var newTransitions = transitions.slice(existingIdx + 1);
-    // transition to all new phases
-    for (var transition of newTransitions) {
-      this.transitionToPhase(transition);
-    }
-    return newTransitions;
-  }
-  isWinningStartRace(newEvent) {
-    if (newEvent.getType() !== START_TYPE) {
-      return false;
-    }
-    var oldEvent = this._verifier.startEvent;
-    var oldRaceIdentifier;
-    if (this.isSelfVerification) {
-      // if the verifier does not have a startEvent,
-      // it is because it's still sending and we are on the initator side
-      // we know we are sending a .start event because we already
-      // have a verifier (checked in calling method)
-      if (oldEvent) {
-        var oldContent = oldEvent.getContent();
-        oldRaceIdentifier = oldContent && oldContent.from_device;
-      } else {
-        oldRaceIdentifier = this.client.getDeviceId();
-      }
-    } else {
-      if (oldEvent) {
-        oldRaceIdentifier = oldEvent.getSender();
-      } else {
-        oldRaceIdentifier = this.client.getUserId();
-      }
-    }
-    var newRaceIdentifier;
-    if (this.isSelfVerification) {
-      var newContent = newEvent.getContent();
-      newRaceIdentifier = newContent && newContent.from_device;
-    } else {
-      newRaceIdentifier = newEvent.getSender();
-    }
-    return newRaceIdentifier < oldRaceIdentifier;
-  }
-  hasEventId(eventId) {
-    for (var event of this.eventsByUs.values()) {
-      if (event.getId() === eventId) {
-        return true;
-      }
-    }
-    for (var _event of this.eventsByThem.values()) {
-      if (_event.getId() === eventId) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Changes the state of the request and verifier in response to a key verification event.
-   * @param type - the "symbolic" event type, as returned by the `getEventType` function on the channel.
-   * @param event - the event to handle. Don't call getType() on it but use the `type` parameter instead.
-   * @param isLiveEvent - whether this is an even received through sync or not
-   * @param isRemoteEcho - whether this is the remote echo of an event sent by the same device
-   * @param isSentByUs - whether this event is sent by a party that can accept and/or observe the request like one of our peers.
-   *   For InRoomChannel this means any device for the syncing user. For ToDeviceChannel, just the syncing device.
-   * @returns a promise that resolves when any requests as an answer to the passed-in event are sent.
-   */
-  handleEvent(type, event, isLiveEvent, isRemoteEcho, isSentByUs) {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      // if reached phase cancelled or done, ignore anything else that comes
-      if (_this7.done || _this7.cancelled) {
-        return;
-      }
-      var wasObserveOnly = _this7._observeOnly;
-      _this7.adjustObserveOnly(event, isLiveEvent);
-      if (!_this7.observeOnly && !isRemoteEcho) {
-        if (yield _this7.cancelOnError(type, event)) {
-          return;
-        }
-      }
-
-      // This assumes verification won't need to send an event with
-      // the same type for the same party twice.
-      // This is true for QR and SAS verification, and was
-      // added here to prevent verification getting cancelled
-      // when the server duplicates an event (https://github.com/matrix-org/synapse/issues/3365)
-      var isDuplicateEvent = isSentByUs ? _this7.eventsByUs.has(type) : _this7.eventsByThem.has(type);
-      if (isDuplicateEvent) {
-        return;
-      }
-      var oldPhase = _this7.phase;
-      _this7.addEvent(type, event, isSentByUs);
-
-      // this will create if needed the verifier so needs to happen before calling it
-      var newTransitions = _this7.applyPhaseTransitions();
-      try {
-        // only pass events from the other side to the verifier,
-        // no remote echos of our own events
-        if (_this7._verifier && !_this7.observeOnly) {
-          var newEventWinsRace = _this7.isWinningStartRace(event);
-          if (_this7._verifier.canSwitchStartEvent(event) && newEventWinsRace) {
-            _this7._verifier.switchStartEvent(event);
-          } else if (!isRemoteEcho) {
-            var _this7$_verifier$even;
-            if (type === CANCEL_TYPE || (_this7$_verifier$even = _this7._verifier.events) !== null && _this7$_verifier$even !== void 0 && _this7$_verifier$even.includes(type)) {
-              _this7._verifier.handleEvent(event);
-            }
-          }
-        }
-        if (newTransitions.length) {
-          // create QRCodeData if the other side can scan
-          // important this happens before emitting a phase change,
-          // so listeners can rely on it being there already
-          // We only do this for live events because it is important that
-          // we sign the keys that were in the QR code, and not the keys
-          // we happen to have at some later point in time.
-          if (isLiveEvent && newTransitions.some(t => t.phase === PHASE_READY)) {
-            var shouldGenerateQrCode = _this7.otherPartySupportsMethod(SCAN_QR_CODE_METHOD, true);
-            if (shouldGenerateQrCode) {
-              _this7._qrCodeData = yield QRCodeData.create(_this7, _this7.client);
-            }
-          }
-          var lastTransition = newTransitions[newTransitions.length - 1];
-          var {
-            phase
-          } = lastTransition;
-          _this7.setupTimeout(phase);
-          // set phase as last thing as this emits the "change" event
-          _this7.setPhase(phase);
-        } else if (_this7._observeOnly !== wasObserveOnly) {
-          _this7.emit(VerificationRequestEvent.Change);
-        }
-      } finally {
-        // log events we processed so we can see from rageshakes what events were added to a request
-        logger.log("Verification request ".concat(_this7.channel.transactionId, ": ") + "".concat(type, " event with id:").concat(event.getId(), ", ") + "content:".concat(JSON.stringify(event.getContent()), " ") + "deviceId:".concat(_this7.channel.deviceId, ", ") + "sender:".concat(event.getSender(), ", isSentByUs:").concat(isSentByUs, ", ") + "isLiveEvent:".concat(isLiveEvent, ", isRemoteEcho:").concat(isRemoteEcho, ", ") + "phase:".concat(oldPhase, "=>").concat(_this7.phase, ", ") + "observeOnly:".concat(wasObserveOnly, "=>").concat(_this7._observeOnly));
-      }
-    })();
-  }
-  setupTimeout(phase) {
-    var shouldTimeout = !this.timeoutTimer && !this.observeOnly && phase === PHASE_REQUESTED;
-    if (shouldTimeout) {
-      this.timeoutTimer = setTimeout(this.cancelOnTimeout, this.timeout);
-    }
-    if (this.timeoutTimer) {
-      var shouldClear = phase === PHASE_STARTED || phase === PHASE_READY || phase === PHASE_DONE || phase === PHASE_CANCELLED;
-      if (shouldClear) {
-        clearTimeout(this.timeoutTimer);
-        this.timeoutTimer = null;
-      }
-    }
-  }
-  cancelOnError(type, event) {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      if (type === START_TYPE) {
-        var method = event.getContent().method;
-        if (!_this8.verificationMethods.has(method)) {
-          yield _this8.cancel(errorFromEvent(newUnknownMethodError()));
-          return true;
-        }
-      }
-      var isUnexpectedRequest = type === REQUEST_TYPE && _this8.phase !== PHASE_UNSENT;
-      var isUnexpectedReady = type === READY_TYPE && _this8.phase !== PHASE_REQUESTED && _this8.phase !== PHASE_STARTED;
-      // only if phase has passed from PHASE_UNSENT should we cancel, because events
-      // are allowed to come in in any order (at least with InRoomChannel). So we only know
-      // we're dealing with a valid request we should participate in once we've moved to PHASE_REQUESTED.
-      // Before that, we could be looking at somebody else's verification request and we just
-      // happen to be in the room
-      if (_this8.phase !== PHASE_UNSENT && (isUnexpectedRequest || isUnexpectedReady)) {
-        logger.warn("Cancelling, unexpected ".concat(type, " verification ") + "event from ".concat(event.getSender()));
-        var reason = "Unexpected ".concat(type, " event in phase ").concat(_this8.phase);
-        yield _this8.cancel(errorFromEvent(newUnexpectedMessageError({
-          reason
-        })));
-        return true;
-      }
-      return false;
-    })();
-  }
-  adjustObserveOnly(event) {
-    var isLiveEvent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    // don't send out events for historical requests
-    if (!isLiveEvent) {
-      this._observeOnly = true;
-    }
-    if (this.calculateEventTimeout(event) < VERIFICATION_REQUEST_MARGIN) {
-      this._observeOnly = true;
-    }
-  }
-  addEvent(type, event) {
-    var isSentByUs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    if (isSentByUs) {
-      this.eventsByUs.set(type, event);
-    } else {
-      this.eventsByThem.set(type, event);
-    }
-
-    // once we know the userId of the other party (from the .request event)
-    // see if any event by anyone else crept into this.eventsByThem
-    if (type === REQUEST_TYPE) {
-      for (var [_type, _event2] of this.eventsByThem.entries()) {
-        if (_event2.getSender() !== this.otherUserId) {
-          this.eventsByThem.delete(_type);
-        }
-      }
-      // also remember when we received the request event
-      this.requestReceivedAt = Date.now();
-    }
-  }
-  createVerifier(method) {
-    var startEvent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    var targetDevice = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-    if (!targetDevice) {
-      targetDevice = this.targetDevice;
-    }
-    var {
-      userId,
-      deviceId
-    } = targetDevice;
-    var VerifierCtor = this.verificationMethods.get(method);
-    if (!VerifierCtor) {
-      logger.warn("could not find verifier constructor for method", method);
-      return;
-    }
-    return new VerifierCtor(this.channel, this.client, userId, deviceId, startEvent, this);
-  }
-  wasSentByOwnUser(event) {
-    return (event === null || event === void 0 ? void 0 : event.getSender()) === this.client.getUserId();
-  }
-
-  // only for .request, .ready or .start
-  wasSentByOwnDevice(event) {
-    if (!this.wasSentByOwnUser(event)) {
-      return false;
-    }
-    var content = event.getContent();
-    if (!content || content.from_device !== this.client.getDeviceId()) {
-      return false;
-    }
-    return true;
-  }
-  onVerifierCancelled() {
-    this._cancelled = true;
-    // move to cancelled phase
-    var newTransitions = this.applyPhaseTransitions();
-    if (newTransitions.length) {
-      this.setPhase(newTransitions[newTransitions.length - 1].phase);
-    }
-  }
-  onVerifierFinished() {
-    this.channel.send(EventType.KeyVerificationDone, {});
-    this.verifierHasFinished = true;
-    // move to .done phase
-    var newTransitions = this.applyPhaseTransitions();
-    if (newTransitions.length) {
-      this.setPhase(newTransitions[newTransitions.length - 1].phase);
-    }
-  }
-  getEventFromOtherParty(type) {
-    return this.eventsByThem.get(type);
-  }
-}
-//# sourceMappingURL=VerificationRequest.js.map