@unwanted/matrix-sdk-mini 34.12.0-1 → 34.12.0-3

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 */
@@ -104,8 +100,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 +116,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.
      */
@@ -184,11 +169,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;
@@ -521,146 +501,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 +523,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,
@@ -1447,9 +1176,6 @@ export class MatrixEvent extends TypedEventEmitter {
       encrypted: this.event
     };
   }
-  setVerificationRequest(request) {
-    this.verificationRequest = request;
-  }
   setTxnId(txnId) {
     this.txnId = txnId;
   }