@unwanted/matrix-sdk-mini 34.12.0 → 36.0.0

package/lib/models/event.js

@@ -1,4 +1,3 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /*
 Copyright 2015 - 2023 The Matrix.org Foundation C.I.C.
@@ -22,15 +21,12 @@ limitations under the License.
  */
 
 import { ExtensibleEvents } from "matrix-events-sdk";
-import { logger } from "../logger.js";
 import { EVENT_VISIBILITY_CHANGE_TYPE, EventType, RelationType, ToDeviceMessageId, UNSIGNED_THREAD_ID_FIELD, UNSIGNED_MEMBERSHIP_FIELD } from "../@types/event.js";
 import { deepSortedObjectEntries, internaliseString } from "../utils.js";
 import { THREAD_RELATION_TYPE, ThreadEvent } from "./thread.js";
 import { TypedReEmitter } from "../ReEmitter.js";
 import { TypedEventEmitter } from "./typed-event-emitter.js";
-import { DecryptionError } from "../common-crypto/CryptoBackend.js";
 import { EventTimeline } from "./event-timeline.js";
-import { DecryptionFailureCode } from "../crypto-api/index.js";
 export { EventStatus } from "./event-status.js";
 
 /* eslint-disable camelcase */
@@ -66,9 +62,57 @@ export var MatrixEventEvent = /*#__PURE__*/function (MatrixEventEvent) {
   MatrixEventEvent["Status"] = "Event.status";
   MatrixEventEvent["Replaced"] = "Event.replaced";
   MatrixEventEvent["RelationsCreated"] = "Event.relationsCreated";
+  MatrixEventEvent["SentinelUpdated"] = "Event.sentinelUpdated";
   return MatrixEventEvent;
 }({});
 export class MatrixEvent extends TypedEventEmitter {
+  /**
+   * Update the sentinels and forwardLooking flag for this event.
+   * @param stateContext -  the room state to be queried
+   * @param toStartOfTimeline -  if true the event's forwardLooking flag is set false
+   * @internal
+   */
+  setMetadata(stateContext, toStartOfTimeline) {
+    var _this$sender, _this$target;
+    // If an event is an m.room.member state event then we should set the sentinels again in case setEventMetadata
+    // was already called before the state was applied and thus the sentinel points at the member from before this event.
+    var affectsSelf = this.isState() && this.getType() === EventType.RoomMember && this.getSender() === this.getStateKey();
+    var changed = false;
+    // When we try to generate a sentinel member before we have that member
+    // in the members object, we still generate a sentinel but it doesn't
+    // have a membership event, so test to see if events.member is set. We
+    // check this to avoid overriding non-sentinel members by sentinel ones
+    // when adding the event to a filtered timeline
+    if (affectsSelf || !((_this$sender = this.sender) !== null && _this$sender !== void 0 && (_this$sender = _this$sender.events) !== null && _this$sender !== void 0 && _this$sender.member)) {
+      var newSender = stateContext.getSentinelMember(this.getSender());
+      if (newSender !== this.sender) changed = true;
+      this.sender = newSender;
+    }
+    if (affectsSelf || !((_this$target = this.target) !== null && _this$target !== void 0 && (_this$target = _this$target.events) !== null && _this$target !== void 0 && _this$target.member) && this.getType() === EventType.RoomMember) {
+      var newTarget = stateContext.getSentinelMember(this.getStateKey());
+      if (newTarget !== this.target) changed = true;
+      this.target = newTarget;
+    }
+    if (this.isState()) {
+      // room state has no concept of 'old' or 'current', but we want the
+      // room state to regress back to previous values if toStartOfTimeline
+      // is set, which means inspecting prev_content if it exists. This
+      // is done by toggling the forwardLooking flag.
+      if (toStartOfTimeline) {
+        this.forwardLooking = false;
+      }
+    }
+    if (changed) {
+      this.emit(MatrixEventEvent.SentinelUpdated);
+    }
+  }
+
+  /**
+   * The sending status of the event.
+   * @privateRemarks
+   * Should be read-only
+   */
+
   /**
    * Construct a Matrix Event object
    *
@@ -104,8 +148,6 @@ export class MatrixEvent extends TypedEventEmitter {
     // a public getter to decide if the cache is valid.
     _defineProperty(this, "_hasCachedExtEv", false);
     _defineProperty(this, "_cachedExtEv", undefined);
-    /** If we failed to decrypt this event, the reason for the failure. Otherwise, `null`. */
-    _defineProperty(this, "_decryptionFailureReason", null);
     /* curve25519 key which we believe belongs to the sender of the event. See
      * getSenderKey()
      */
@@ -122,15 +164,6 @@ export class MatrixEvent extends TypedEventEmitter {
     /* where the decryption key is untrusted
      */
     _defineProperty(this, "untrusted", null);
-    /* if we have a process decrypting this event, a Promise which resolves
-     * when it is finished. Normally null.
-     */
-    _defineProperty(this, "decryptionPromise", null);
-    /* flag to indicate if we should retry decrypting this event after the
-     * first attempt (eg, we have received new data which means that a second
-     * attempt may succeed)
-     */
-    _defineProperty(this, "retryDecryption", false);
     /* The txnId with which this event was sent if it was during this session,
      * allows for a unique ID which does not change when the event comes back down sync.
      */
@@ -163,11 +196,6 @@ export class MatrixEvent extends TypedEventEmitter {
      * Should be read-only
      */
     _defineProperty(this, "target", null);
-    /**
-     * The sending status of the event.
-     * @privateRemarks
-     * Should be read-only
-     */
     _defineProperty(this, "status", null);
     /**
      * most recent error associated with sending the event, if any
@@ -184,11 +212,6 @@ export class MatrixEvent extends TypedEventEmitter {
      * Should be read-only
      */
     _defineProperty(this, "forwardLooking", true);
-    /* If the event is a `m.key.verification.request` (or to_device `m.key.verification.start`) event,
-     * `Crypto` will set this the `VerificationRequest` for the event
-     * so it can be easily accessed from the timeline.
-     */
-    _defineProperty(this, "verificationRequest", void 0);
     _defineProperty(this, "reEmitter", void 0);
     ["state_key", "type", "sender", "room_id", "membership"].forEach(prop => {
       if (typeof event[prop] !== "string") return;
@@ -363,13 +386,15 @@ export class MatrixEvent extends TypedEventEmitter {
    * @returns The event content JSON, or an empty object.
    */
   getOriginalContent() {
+    var _this$event$content;
     if (this._localRedactionEvent) {
       return {};
     }
     if (this.clearEvent) {
-      return this.clearEvent.content || {};
+      var _this$clearEvent$cont;
+      return (_this$clearEvent$cont = this.clearEvent.content) !== null && _this$clearEvent$cont !== void 0 ? _this$clearEvent$cont : {};
     }
-    return this.event.content || {};
+    return (_this$event$content = this.event.content) !== null && _this$event$content !== void 0 ? _this$event$content : {};
   }
 
   /**
@@ -383,7 +408,8 @@ export class MatrixEvent extends TypedEventEmitter {
     if (this._localRedactionEvent) {
       return {};
     } else if (this._replacingEvent) {
-      return this._replacingEvent.getContent()["m.new_content"] || {};
+      var _this$_replacingEvent;
+      return (_this$_replacingEvent = this._replacingEvent.getContent()["m.new_content"]) !== null && _this$_replacingEvent !== void 0 ? _this$_replacingEvent : {};
     } else {
       return this.getOriginalContent();
     }
@@ -521,146 +547,13 @@ export class MatrixEvent extends TypedEventEmitter {
     var unsigned = this.getUnsigned();
     return UNSIGNED_MEMBERSHIP_FIELD.findIn(unsigned);
   }
-
-  /**
-   * Replace the content of this event with encrypted versions.
-   * (This is used when sending an event; it should not be used by applications).
-   *
-   * @internal
-   *
-   * @param cryptoType - type of the encrypted event - typically
-   * <tt>"m.room.encrypted"</tt>
-   *
-   * @param cryptoContent - raw 'content' for the encrypted event.
-   *
-   * @param senderCurve25519Key - curve25519 key to record for the
-   *   sender of this event.
-   *   See {@link MatrixEvent#getSenderKey}.
-   *
-   * @param claimedEd25519Key - claimed ed25519 key to record for the
-   *   sender if this event.
-   *   See {@link MatrixEvent#getClaimedEd25519Key}
-   */
-  makeEncrypted(cryptoType, cryptoContent, senderCurve25519Key, claimedEd25519Key) {
-    // keep the plain-text data for 'view source'
-    this.clearEvent = {
-      type: this.event.type,
-      content: this.event.content
-    };
-    this.event.type = cryptoType;
-    this.event.content = cryptoContent;
-    this.senderCurve25519Key = senderCurve25519Key;
-    this.claimedEd25519Key = claimedEd25519Key;
-  }
-
-  /**
-   * Check if this event is currently being decrypted.
-   *
-   * @returns True if this event is currently being decrypted, else false.
-   */
-  isBeingDecrypted() {
-    return this.decryptionPromise != null;
-  }
-  getDecryptionPromise() {
-    return this.decryptionPromise;
-  }
-
-  /**
-   * Check if this event is an encrypted event which we failed to decrypt
-   *
-   * (This implies that we might retry decryption at some point in the future)
-   *
-   * @returns True if this event is an encrypted event which we
-   *     couldn't decrypt.
-   */
-  isDecryptionFailure() {
-    return this._decryptionFailureReason !== null;
-  }
-
-  /** If we failed to decrypt this event, the reason for the failure. Otherwise, `null`. */
-  get decryptionFailureReason() {
-    return this._decryptionFailureReason;
-  }
-
-  /**
-   * True if this event is an encrypted event which we failed to decrypt, the receiver's device is unverified and
-   * the sender has disabled encrypting to unverified devices.
-   *
-   * @deprecated: Prefer `event.decryptionFailureReason === DecryptionFailureCode.MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE`.
-   */
-  get isEncryptedDisabledForUnverifiedDevices() {
-    return this.decryptionFailureReason === DecryptionFailureCode.MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE;
-  }
   shouldAttemptDecryption() {
     if (this.isRedacted()) return false;
-    if (this.isBeingDecrypted()) return false;
     if (this.clearEvent) return false;
     if (!this.isEncrypted()) return false;
     return true;
   }
 
-  /**
-   * Start the process of trying to decrypt this event.
-   *
-   * (This is used within the SDK: it isn't intended for use by applications)
-   *
-   * @internal
-   *
-   * @param crypto - crypto module
-   *
-   * @returns promise which resolves (to undefined) when the decryption
-   * attempt is completed.
-   */
-  attemptDecryption(crypto) {
-    var _arguments = arguments,
-      _this = this;
-    return _asyncToGenerator(function* () {
-      var options = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : {};
-      // start with a couple of sanity checks.
-      if (!_this.isEncrypted()) {
-        throw new Error("Attempt to decrypt event which isn't encrypted");
-      }
-      var alreadyDecrypted = _this.clearEvent && !_this.isDecryptionFailure();
-      var forceRedecrypt = options.forceRedecryptIfUntrusted && _this.isKeySourceUntrusted();
-      if (alreadyDecrypted && !forceRedecrypt) {
-        // we may want to just ignore this? let's start with rejecting it.
-        throw new Error("Attempt to decrypt event which has already been decrypted");
-      }
-
-      // if we already have a decryption attempt in progress, then it may
-      // fail because it was using outdated info. We now have reason to
-      // succeed where it failed before, but we don't want to have multiple
-      // attempts going at the same time, so just set a flag that says we have
-      // new info.
-      //
-      if (_this.decryptionPromise) {
-        logger.log("Event ".concat(_this.getId(), " already being decrypted; queueing a retry"));
-        _this.retryDecryption = true;
-        return _this.decryptionPromise;
-      }
-      _this.decryptionPromise = _this.decryptionLoop(crypto, options);
-      return _this.decryptionPromise;
-    })();
-  }
-
-  /**
-   * Cancel any room key request for this event and resend another.
-   *
-   * @param crypto - crypto module
-   * @param userId - the user who received this event
-   *
-   * @returns a promise that resolves when the request is queued
-   */
-  cancelAndResendKeyRequest(crypto, userId) {
-    var wireContent = this.getWireContent();
-    return crypto.requestRoomKey({
-      algorithm: wireContent.algorithm,
-      room_id: this.getRoomId(),
-      session_id: wireContent.session_id,
-      sender_key: wireContent.sender_key
-    }, this.getKeyRequestRecipients(userId), true);
-  }
-
   /**
    * Calculate the recipients for keyshare requests.
    *
@@ -676,124 +569,6 @@ export class MatrixEvent extends TypedEventEmitter {
     }];
     return recipients;
   }
-  decryptionLoop(crypto) {
-    var _arguments2 = arguments,
-      _this2 = this;
-    return _asyncToGenerator(function* () {
-      var options = _arguments2.length > 1 && _arguments2[1] !== undefined ? _arguments2[1] : {};
-      // make sure that this method never runs completely synchronously.
-      // (doing so would mean that we would clear decryptionPromise *before*
-      // it is set in attemptDecryption - and hence end up with a stuck
-      // `decryptionPromise`).
-      yield Promise.resolve();
-
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
-        _this2.retryDecryption = false;
-        var err = undefined;
-        try {
-          var res = yield crypto.decryptEvent(_this2);
-          if (options.isRetry === true) {
-            logger.info("Decrypted event on retry (".concat(_this2.getDetails(), ")"));
-          }
-          _this2.setClearData(res);
-          _this2._decryptionFailureReason = null;
-        } catch (e) {
-          var detailedError = e instanceof DecryptionError ? e.detailedString : String(e);
-          err = e;
-
-          // see if we have a retry queued.
-          //
-          // NB: make sure to keep this check in the same tick of the
-          //   event loop as `decryptionPromise = null` below - otherwise we
-          //   risk a race:
-          //
-          //   * A: we check retryDecryption here and see that it is
-          //        false
-          //   * B: we get a second call to attemptDecryption, which sees
-          //        that decryptionPromise is set so sets
-          //        retryDecryption
-          //   * A: we continue below, clear decryptionPromise, and
-          //        never do the retry.
-          //
-          if (_this2.retryDecryption) {
-            // decryption error, but we have a retry queued.
-            logger.log("Error decrypting event (".concat(_this2.getDetails(), "), but retrying: ").concat(detailedError));
-            continue;
-          }
-
-          // decryption error, no retries queued. Warn about the error and
-          // set it to m.bad.encrypted.
-          //
-          // the detailedString already includes the name and message of the error, and the stack isn't much use,
-          // so we don't bother to log `e` separately.
-          logger.warn("Error decrypting event (".concat(_this2.getDetails(), "): ").concat(detailedError));
-          _this2.setClearDataForDecryptionFailure(String(e));
-          _this2._decryptionFailureReason = e instanceof DecryptionError ? e.code : DecryptionFailureCode.UNKNOWN_ERROR;
-        }
-
-        // Make sure we clear 'decryptionPromise' before sending the 'Event.decrypted' event,
-        // otherwise the app will be confused to see `isBeingDecrypted` still set when
-        // there isn't an `Event.decrypted` on the way.
-        //
-        // see also notes on retryDecryption above.
-        //
-        _this2.decryptionPromise = null;
-        _this2.retryDecryption = false;
-
-        // Before we emit the event, clear the push actions so that they can be recalculated
-        // by relevant code. We do this because the clear event has now changed, making it
-        // so that existing rules can be re-run over the applicable properties. Stuff like
-        // highlighting when the user's name is mentioned rely on this happening. We also want
-        // to set the push actions before emitting so that any notification listeners don't
-        // pick up the wrong contents.
-        _this2.setPushDetails();
-        if (options.emit !== false) {
-          _this2.emit(MatrixEventEvent.Decrypted, _this2, err);
-        }
-        return;
-      }
-    })();
-  }
-
-  /**
-   * Update the cleartext data on this event.
-   *
-   * (This is used after decrypting an event; it should not be used by applications).
-   *
-   * @internal
-   *
-   * @param decryptionResult - the decryption result, including the plaintext and some key info
-   */
-  setClearData(decryptionResult) {
-    var _decryptionResult$sen, _decryptionResult$cla;
-    this.clearEvent = decryptionResult.clearEvent;
-    this.senderCurve25519Key = (_decryptionResult$sen = decryptionResult.senderCurve25519Key) !== null && _decryptionResult$sen !== void 0 ? _decryptionResult$sen : null;
-    this.claimedEd25519Key = (_decryptionResult$cla = decryptionResult.claimedEd25519Key) !== null && _decryptionResult$cla !== void 0 ? _decryptionResult$cla : null;
-    this.forwardingCurve25519KeyChain = decryptionResult.forwardingCurve25519KeyChain || [];
-    this.untrusted = decryptionResult.untrusted || false;
-    this.invalidateExtensibleEvent();
-  }
-
-  /**
-   * Update the cleartext data on this event after a decryption failure.
-   *
-   * @param reason - the textual reason for the failure
-   */
-  setClearDataForDecryptionFailure(reason) {
-    this.clearEvent = {
-      type: EventType.RoomMessage,
-      content: {
-        msgtype: "m.bad.encrypted",
-        body: "** Unable to decrypt: ".concat(reason, " **")
-      }
-    };
-    this.senderCurve25519Key = null;
-    this.claimedEd25519Key = null;
-    this.forwardingCurve25519KeyChain = [];
-    this.untrusted = false;
-    this.invalidateExtensibleEvent();
-  }
 
   /**
    * Gets the cleartext content for this event. If the event is not encrypted,
@@ -1032,7 +807,7 @@ export class MatrixEvent extends TypedEventEmitter {
     var timeline = room.getLiveTimeline();
     // We use insertEventIntoTimeline to insert it in timestamp order,
     // because we don't know where it should go (until we have MSC4033).
-    timeline.getTimelineSet().insertEventIntoTimeline(this, timeline, timeline.getState(EventTimeline.FORWARDS));
+    timeline.getTimelineSet().insertEventIntoTimeline(this, timeline, timeline.getState(EventTimeline.FORWARDS), false);
   }
 
   /**
@@ -1156,6 +931,7 @@ export class MatrixEvent extends TypedEventEmitter {
    * @param event - the object to assign to the `event` property
    */
   handleRemoteEcho(event) {
+    var _this$getAge;
     var oldUnsigned = this.getUnsigned();
     var oldId = this.getId();
     this.event = event;
@@ -1176,7 +952,7 @@ export class MatrixEvent extends TypedEventEmitter {
       // emit the event if it changed
       this.emit(MatrixEventEvent.LocalEventIdReplaced, this);
     }
-    this.localTimestamp = Date.now() - this.getAge();
+    this.localTimestamp = Date.now() - ((_this$getAge = this.getAge()) !== null && _this$getAge !== void 0 ? _this$getAge : 0);
   }
 
   /**
@@ -1308,8 +1084,8 @@ export class MatrixEvent extends TypedEventEmitter {
         return new Date(ts);
       }
     } else if (this._replacingEvent) {
-      var _this$_replacingEvent;
-      return (_this$_replacingEvent = this._replacingEvent.getDate()) !== null && _this$_replacingEvent !== void 0 ? _this$_replacingEvent : undefined;
+      var _this$_replacingEvent2;
+      return (_this$_replacingEvent2 = this._replacingEvent.getDate()) !== null && _this$_replacingEvent2 !== void 0 ? _this$_replacingEvent2 : undefined;
     }
   }
 
@@ -1447,9 +1223,6 @@ export class MatrixEvent extends TypedEventEmitter {
       encrypted: this.event
     };
   }
-  setVerificationRequest(request) {
-    this.verificationRequest = request;
-  }
   setTxnId(txnId) {
     this.txnId = txnId;
   }