@unwanted/matrix-sdk-mini 34.12.0 → 34.13.0

package/src/models/event.ts

@@ -21,9 +21,6 @@ limitations under the License.
 
 import { ExtensibleEvent, ExtensibleEvents, Optional } from "matrix-events-sdk";
 
-import type { IEventDecryptionResult } from "../@types/crypto.ts";
-import { logger } from "../logger.ts";
-import { VerificationRequest } from "../crypto/verification/request/VerificationRequest.ts";
 import {
     EVENT_VISIBILITY_CHANGE_TYPE,
     EventType,
@@ -33,7 +30,6 @@ import {
     UNSIGNED_THREAD_ID_FIELD,
     UNSIGNED_MEMBERSHIP_FIELD,
 } from "../@types/event.ts";
-import { Crypto } from "../crypto/index.ts";
 import { deepSortedObjectEntries, internaliseString } from "../utils.ts";
 import { RoomMember } from "./room-member.ts";
 import { Thread, THREAD_RELATION_TYPE, ThreadEvent, ThreadEventHandlerMap } from "./thread.ts";
@@ -42,12 +38,10 @@ import { TypedReEmitter } from "../ReEmitter.ts";
 import { MatrixError } from "../http-api/index.ts";
 import { TypedEventEmitter } from "./typed-event-emitter.ts";
 import { EventStatus } from "./event-status.ts";
-import { CryptoBackend, DecryptionError } from "../common-crypto/CryptoBackend.ts";
 import { IAnnotatedPushRule } from "../@types/PushRules.ts";
 import { Room } from "./room.ts";
 import { EventTimeline } from "./event-timeline.ts";
 import { Membership } from "../@types/membership.ts";
-import { DecryptionFailureCode } from "../crypto-api/index.ts";
 
 export { EventStatus } from "./event-status.ts";
 
@@ -266,9 +260,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
     private _hasCachedExtEv = false;
     private _cachedExtEv: Optional<ExtensibleEvent> = undefined;
 
-    /** If we failed to decrypt this event, the reason for the failure. Otherwise, `null`. */
-    private _decryptionFailureReason: DecryptionFailureCode | null = null;
-
     /* curve25519 key which we believe belongs to the sender of the event. See
      * getSenderKey()
      */
@@ -289,17 +280,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      */
     private untrusted: boolean | null = null;
 
-    /* if we have a process decrypting this event, a Promise which resolves
-     * when it is finished. Normally null.
-     */
-    private decryptionPromise: Promise<void> | null = 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)
-     */
-    private 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.
      */
@@ -357,12 +337,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      */
     public 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.
-     */
-    public verificationRequest?: VerificationRequest;
-
     private readonly reEmitter: TypedReEmitter<MatrixEventEmittedEvents, MatrixEventHandlerMap>;
 
     /**
@@ -559,9 +533,9 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
             return {} as T;
         }
         if (this.clearEvent) {
-            return (this.clearEvent.content || {}) as T;
+            return (this.clearEvent.content ?? {}) as T;
         }
-        return (this.event.content || {}) as T;
+        return (this.event.content ?? {}) as T;
     }
 
     /**
@@ -575,7 +549,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         if (this._localRedactionEvent) {
             return {} as T;
         } else if (this._replacingEvent) {
-            return this._replacingEvent.getContent()["m.new_content"] || {};
+            return this._replacingEvent.getContent()["m.new_content"] ?? {};
         } else {
             return this.getOriginalContent();
         }
@@ -714,154 +688,14 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         return UNSIGNED_MEMBERSHIP_FIELD.findIn<Membership | string>(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}
-     */
-    public makeEncrypted(
-        cryptoType: string,
-        cryptoContent: object,
-        senderCurve25519Key: string,
-        claimedEd25519Key: string,
-    ): void {
-        // 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.
-     */
-    public isBeingDecrypted(): boolean {
-        return this.decryptionPromise != null;
-    }
-
-    public getDecryptionPromise(): Promise<void> | null {
-        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.
-     */
-    public isDecryptionFailure(): boolean {
-        return this._decryptionFailureReason !== null;
-    }
-
-    /** If we failed to decrypt this event, the reason for the failure. Otherwise, `null`. */
-    public get decryptionFailureReason(): DecryptionFailureCode | null {
-        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`.
-     */
-    public get isEncryptedDisabledForUnverifiedDevices(): boolean {
-        return this.decryptionFailureReason === DecryptionFailureCode.MEGOLM_KEY_WITHHELD_FOR_UNVERIFIED_DEVICE;
-    }
-
     public shouldAttemptDecryption(): boolean {
         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.
-     */
-    public async attemptDecryption(crypto: CryptoBackend, options: IDecryptOptions = {}): Promise<void> {
-        // start with a couple of sanity checks.
-        if (!this.isEncrypted()) {
-            throw new Error("Attempt to decrypt event which isn't encrypted");
-        }
-
-        const alreadyDecrypted = this.clearEvent && !this.isDecryptionFailure();
-        const 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 ${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
-     */
-    public cancelAndResendKeyRequest(crypto: Crypto, userId: string): Promise<void> {
-        const 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.
      *
@@ -881,125 +715,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         return recipients;
     }
 
-    private async decryptionLoop(crypto: CryptoBackend, options: IDecryptOptions = {}): Promise<void> {
-        // 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`).
-        await Promise.resolve();
-
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            this.retryDecryption = false;
-
-            let err: Error | undefined = undefined;
-            try {
-                const res = await crypto.decryptEvent(this);
-                if (options.isRetry === true) {
-                    logger.info(`Decrypted event on retry (${this.getDetails()})`);
-                }
-                this.setClearData(res);
-                this._decryptionFailureReason = null;
-            } catch (e) {
-                const detailedError = e instanceof DecryptionError ? (<DecryptionError>e).detailedString : String(e);
-
-                err = e as Error;
-
-                // 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 (this.retryDecryption) {
-                    // decryption error, but we have a retry queued.
-                    logger.log(`Error decrypting event (${this.getDetails()}), but retrying: ${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 (${this.getDetails()}): ${detailedError}`);
-
-                this.setClearDataForDecryptionFailure(String(e));
-                this._decryptionFailureReason =
-                    e instanceof DecryptionError ? (<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.
-            //
-            this.decryptionPromise = null;
-            this.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.
-            this.setPushDetails();
-
-            if (options.emit !== false) {
-                this.emit(MatrixEventEvent.Decrypted, this, 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
-     */
-    private setClearData(decryptionResult: IEventDecryptionResult): void {
-        this.clearEvent = decryptionResult.clearEvent;
-        this.senderCurve25519Key = decryptionResult.senderCurve25519Key ?? null;
-        this.claimedEd25519Key = decryptionResult.claimedEd25519Key ?? 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
-     */
-    private setClearDataForDecryptionFailure(reason: string): void {
-        this.clearEvent = {
-            type: EventType.RoomMessage,
-            content: {
-                msgtype: "m.bad.encrypted",
-                body: `** Unable to decrypt: ${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,
      * or encryption has not been completed, this will return null.
@@ -1250,7 +965,9 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         const 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);
     }
 
     /**
@@ -1394,7 +1111,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
             this.emit(MatrixEventEvent.LocalEventIdReplaced, this);
         }
 
-        this.localTimestamp = Date.now() - this.getAge()!;
+        this.localTimestamp = Date.now() - (this.getAge() ?? 0);
     }
 
     /**
@@ -1631,7 +1348,7 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
      * @param otherEvent - The other event to check against.
      * @returns True if the events are the same, false otherwise.
      */
-    public isEquivalentTo(otherEvent: MatrixEvent): boolean {
+    public isEquivalentTo(otherEvent?: MatrixEvent): boolean {
         if (!otherEvent) return false;
         if (otherEvent === this) return true;
         const myProps = deepSortedObjectEntries(this.event);
@@ -1669,10 +1386,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         };
     }
 
-    public setVerificationRequest(request: VerificationRequest): void {
-        this.verificationRequest = request;
-    }
-
     public setTxnId(txnId: string): void {
         this.txnId = txnId;
     }

package/src/models/poll.ts

@@ -48,9 +48,6 @@ const filterResponseRelations = (
     responseEvents: MatrixEvent[];
 } => {
     const responseEvents = relationEvents.filter((event) => {
-        if (event.isDecryptionFailure()) {
-            return;
-        }
         return (
             M_POLL_RESPONSE.matches(event.getType()) &&
             // From MSC3381:
@@ -172,8 +169,6 @@ export class Poll extends TypedEventEmitter<Exclude<PollEvent, PollEvent.New>, P
             },
         );
 
-        await Promise.all(allRelations.events.map((event) => this.matrixClient.decryptEventIfNeeded(event)));
-
         const responses =
             this.responses ||
             new Relations("m.reference", M_POLL_RESPONSE.name, this.matrixClient, [M_POLL_RESPONSE.altName!]);
@@ -235,7 +230,6 @@ export class Poll extends TypedEventEmitter<Exclude<PollEvent, PollEvent.New>, P
 
     private countUndecryptableEvents = (events: MatrixEvent[]): void => {
         const undecryptableEventIds = events
-            .filter((event) => event.isDecryptionFailure())
             .map((event) => event.getId()!);
 
         const previousCount = this.undecryptableRelationsCount;

package/src/models/relations-container.ts

@@ -98,18 +98,11 @@ export class RelationsContainer {
         if (!relation) return;
 
         const onEventDecrypted = (): void => {
-            if (event.isDecryptionFailure()) {
-                // This could for example happen if the encryption keys are not yet available.
-                // The event may still be decrypted later. Register the listener again.
-                event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
-                return;
-            }
-
             this.aggregateChildEvent(event, timelineSet);
         };
 
         // If the event is currently encrypted, wait until it has been decrypted.
-        if (event.isBeingDecrypted() || event.shouldAttemptDecryption()) {
+        if (event.shouldAttemptDecryption()) {
             event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
             return;
         }

package/src/models/relations.ts

@@ -52,7 +52,6 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
     private sortedAnnotationsByKey: [string, Set<MatrixEvent>][] = [];
     private targetEvent: MatrixEvent | null = null;
     private creationEmitted = false;
-    private readonly client: MatrixClient;
 
     /**
      * @param relationType - The type of relation involved, such as "m.annotation", "m.reference", "m.replace", etc.
@@ -67,7 +66,6 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
         public readonly altEventTypes?: string[],
     ) {
         super();
-        this.client = client instanceof Room ? client.client : client;
     }
 
     /**
@@ -323,12 +321,6 @@ export class Relations extends TypedEventEmitter<RelationsEvent, EventHandlerMap
             return event;
         }, null);
 
-        if (lastReplacement?.shouldAttemptDecryption() && this.client.isCryptoEnabled()) {
-            await lastReplacement.attemptDecryption(this.client.crypto!);
-        } else if (lastReplacement?.isBeingDecrypted()) {
-            await lastReplacement.getDecryptionPromise();
-        }
-
         return lastReplacement;
     }
 

package/src/models/room-state.ts

@@ -18,7 +18,7 @@ import { RoomMember } from "./room-member.ts";
 import { logger } from "../logger.ts";
 import { isNumber, removeHiddenChars } from "../utils.ts";
 import { EventType, UNSTABLE_MSC2716_MARKER } from "../@types/event.ts";
-import { IEvent, MatrixEvent, MatrixEventEvent } from "./event.ts";
+import { IEvent, MatrixEvent } from "./event.ts";
 import { MatrixClient } from "../client.ts";
 import { GuestAccess, HistoryVisibility, JoinRule } from "../@types/partials.ts";
 import { TypedEventEmitter } from "./typed-event-emitter.ts";
@@ -194,22 +194,11 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      * As the timeline might get reset while they are loading, this state needs to be inherited
      * and shared when the room state is cloned for the new timeline.
      * This should only be passed from clone.
-     * @param isStartTimelineState - Optional. This state is marked as a start state.
-     * This is used to skip state insertions that are
-     * in the wrong order. The order is determined by the `replaces_state` id.
-     *
-     * Example:
-     * A current state events `replaces_state` value is `1`.
-     * Trying to insert a state event with `event_id` `1` in its place would fail if isStartTimelineState = false.
-     *
-     * A current state events `event_id` is `2`.
-     * Trying to insert a state event where its `replaces_state` value is `2` would fail if isStartTimelineState = true.
      */
 
     public constructor(
         public readonly roomId: string,
         private oobMemberFlags = { status: OobStatus.NotStarted },
-        public readonly isStartTimelineState = false,
     ) {
         super();
         this.updateModifiedTime();
@@ -420,7 +409,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      * Fires {@link RoomStateEvent.Events}
      * Fires {@link RoomStateEvent.Marker}
      */
-    public setStateEvents(stateEvents: MatrixEvent[], options?: IMarkerFoundOptions): void {
+    public setStateEvents(stateEvents: MatrixEvent[], markerFoundOptions?: IMarkerFoundOptions): void {
         this.updateModifiedTime();
 
         // update the core event dict
@@ -432,22 +421,6 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
             }
 
             const lastStateEvent = this.getStateEventMatching(event);
-
-            // Safety measure to not update the room (and emit the update) with older state.
-            // The sync loop really should not send old events but it does very regularly.
-            // Logging on return in those two conditions results in a large amount of logging. (on startup and when running element)
-            const lastReplaceId = lastStateEvent?.event.unsigned?.replaces_state;
-            const lastId = lastStateEvent?.event.event_id;
-            const newReplaceId = event.event.unsigned?.replaces_state;
-            const newId = event.event.event_id;
-            if (this.isStartTimelineState) {
-                // Add an event to the start of the timeline. Its replace id should not be the same as the one of the current/last start state event.
-                if (newReplaceId && lastId && newReplaceId === lastId) return;
-            } else {
-                // Add an event to the end of the timeline. It should not be the same as the one replaced by the current/last end state event.
-                if (lastReplaceId && newId && lastReplaceId === newId) return;
-            }
-
             this.setStateEvent(event);
             if (event.getType() === EventType.RoomMember) {
                 this.updateDisplayNameCache(event.getStateKey()!, event.getContent().displayname ?? "");
@@ -504,7 +477,7 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
                 // assume all our sentinels are now out-of-date
                 this.sentinels = {};
             } else if (UNSTABLE_MSC2716_MARKER.matches(event.getType())) {
-                this.emit(RoomStateEvent.Marker, event, options);
+                this.emit(RoomStateEvent.Marker, event, markerFoundOptions);
             }
         });
 
@@ -544,15 +517,9 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
             if (!M_BEACON.matches(event.getType()) && !event.isEncrypted()) return;
 
             try {
-                await matrixClient.decryptEventIfNeeded(event);
                 processBeaconRelation(relatedToEventId, event);
             } catch {
-                if (event.isDecryptionFailure()) {
-                    // add an event listener for once the event is decrypted.
-                    event.once(MatrixEventEvent.Decrypted, async () => {
-                        processBeaconRelation(relatedToEventId, event);
-                    });
-                }
+                //
             }
         }
     }