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

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";
@@ -544,15 +544,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);
-                    });
-                }
+                //
             }
         }
     }

package/src/models/room.ts

@@ -494,7 +494,6 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                 });
                 events.forEach(async (serializedEvent: Partial<IEvent>) => {
                     const event = mapper(serializedEvent);
-                    await client.decryptEventIfNeeded(event);
                     event.setStatus(EventStatus.NOT_SENT);
                     this.addPendingEvent(event, event.getTxnId()!);
                 });
@@ -533,52 +532,6 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
         return null;
     }
 
-    /**
-     * Bulk decrypt critical events in a room
-     *
-     * Critical events represents the minimal set of events to decrypt
-     * for a typical UI to function properly
-     *
-     * - Last event of every room (to generate likely message preview)
-     * - All events up to the read receipt (to calculate an accurate notification count)
-     *
-     * @returns Signals when all events have been decrypted
-     */
-    public async decryptCriticalEvents(): Promise<void> {
-        if (!this.client.isCryptoEnabled()) return;
-
-        const readReceiptEventId = this.getEventReadUpTo(this.client.getUserId()!, true);
-        const events = this.getLiveTimeline().getEvents();
-        const readReceiptTimelineIndex = events.findIndex((matrixEvent) => {
-            return matrixEvent.event.event_id === readReceiptEventId;
-        });
-
-        const decryptionPromises = events
-            .slice(readReceiptTimelineIndex)
-            .reverse()
-            .map((event) => this.client.decryptEventIfNeeded(event));
-
-        await Promise.allSettled(decryptionPromises);
-    }
-
-    /**
-     * Bulk decrypt events in a room
-     *
-     * @returns Signals when all events have been decrypted
-     */
-    public async decryptAllEvents(): Promise<void> {
-        if (!this.client.isCryptoEnabled()) return;
-
-        const decryptionPromises = this.getUnfilteredTimelineSet()
-            .getLiveTimeline()
-            .getEvents()
-            .slice(0) // copy before reversing
-            .reverse()
-            .map((event) => this.client.decryptEventIfNeeded(event));
-
-        await Promise.allSettled(decryptionPromises);
-    }
-
     /**
      * Gets the creator of the room
      * @returns The creator of the room, or null if it could not be determined
@@ -2062,7 +2015,6 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                 return threadAMetadata.latest_event.origin_server_ts - threadBMetadata.latest_event.origin_server_ts;
             });
 
-            let latestMyThreadsRootEvent: MatrixEvent | undefined;
             const roomState = this.getLiveTimeline().getState(EventTimeline.FORWARDS);
             for (const rootEvent of threadRoots) {
                 const opts = {
@@ -2077,16 +2029,10 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                 );
                 if (threadRelationship?.current_user_participated) {
                     this.threadsTimelineSets[1]?.addLiveEvent(rootEvent, opts);
-                    latestMyThreadsRootEvent = rootEvent;
                 }
             }
 
             this.processThreadRoots(threadRoots, true);
-
-            this.client.decryptEventIfNeeded(threadRoots[threadRoots.length - 1]);
-            if (latestMyThreadsRootEvent) {
-                this.client.decryptEventIfNeeded(latestMyThreadsRootEvent);
-            }
         }
 
         this.on(ThreadEvent.NewReply, this.onThreadReply);
@@ -2110,7 +2056,6 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
                  * Try to decrypt the event. Promise resolution does not guarantee a successful decryption.
                  * Retry is handled in {@link processPollEvent}.
                  */
-                await this.client.decryptEventIfNeeded(event);
                 this.processPollEvent(event);
             } catch (err) {
                 logger.warn("Error processing poll event", event.getId(), err);
@@ -2129,13 +2074,6 @@ export class Room extends ReadReceipt<RoomEmittedEvents, RoomEventHandlerMap> {
      * @param event - Event that could be a poll event
      */
     private async processPollEvent(event: MatrixEvent): Promise<void> {
-        if (event.isDecryptionFailure()) {
-            event.once(MatrixEventEvent.Decrypted, (maybeDecryptedEvent: MatrixEvent) => {
-                this.processPollEvent(maybeDecryptedEvent);
-            });
-            return;
-        }
-
         if (M_POLL_START.matches(event.getType())) {
             try {
                 const poll = new Poll(event, this.client, this);

package/src/models/thread.ts

@@ -372,7 +372,6 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
         if (!Thread.hasServerSideSupport) {
             // When there's no server-side support, just add it to the end of the timeline.
             this.addEventToTimeline(event, toStartOfTimeline);
-            this.client.decryptEventIfNeeded(event);
         } else if (event.isRelation(RelationType.Annotation) || event.isRelation(RelationType.Replace)) {
             this.addRelatedThreadEvent(event, toStartOfTimeline);
             return;

package/src/sliding-sync-sdk.ts

@@ -14,7 +14,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import type { SyncCryptoCallbacks } from "./common-crypto/CryptoBackend.ts";
 import { NotificationCountType, Room, RoomEvent } from "./models/room.ts";
 import { logger } from "./logger.ts";
 import { promiseMapSeries } from "./utils.ts";
@@ -24,13 +23,10 @@ import {
     ISyncStateData,
     SyncState,
     _createAndReEmitRoom,
-    SyncApiOptions,
     defaultClientOpts,
-    defaultSyncApiOpts,
     SetPresence,
 } from "./sync.ts";
 import { MatrixEvent } from "./models/event.ts";
-import { Crypto } from "./crypto/index.ts";
 import { IMinimalEvent, IRoomEvent, IStateEvent, IStrippedState, ISyncResponse } from "./sync-accumulator.ts";
 import { MatrixError } from "./http-api/index.ts";
 import {
@@ -53,54 +49,6 @@ import { KnownMembership } from "./@types/membership.ts";
 // keepAlive is successful but the server /sync fails.
 const FAILED_SYNC_ERROR_THRESHOLD = 3;
 
-type ExtensionE2EERequest = {
-    enabled: boolean;
-};
-
-type ExtensionE2EEResponse = Pick<
-    ISyncResponse,
-    | "device_lists"
-    | "device_one_time_keys_count"
-    | "device_unused_fallback_key_types"
-    | "org.matrix.msc2732.device_unused_fallback_key_types"
->;
-
-class ExtensionE2EE implements Extension<ExtensionE2EERequest, ExtensionE2EEResponse> {
-    public constructor(private readonly crypto: Crypto) {}
-
-    public name(): string {
-        return "e2ee";
-    }
-
-    public when(): ExtensionState {
-        return ExtensionState.PreProcess;
-    }
-
-    public onRequest(isInitial: boolean): ExtensionE2EERequest | undefined {
-        if (!isInitial) {
-            return undefined;
-        }
-        return {
-            enabled: true, // this is sticky so only send it on the initial request
-        };
-    }
-
-    public async onResponse(data: ExtensionE2EEResponse): Promise<void> {
-        // Handle device list updates
-        if (data.device_lists) {
-            await this.crypto.processDeviceLists(data.device_lists);
-        }
-
-        // Handle one_time_keys_count and unused_fallback_key_types
-        await this.crypto.processKeyCounts(
-            data.device_one_time_keys_count,
-            data["device_unused_fallback_key_types"] || data["org.matrix.msc2732.device_unused_fallback_key_types"],
-        );
-
-        this.crypto.onSyncCompleted({});
-    }
-}
-
 type ExtensionToDeviceRequest = {
     since?: string;
     limit?: number;
@@ -117,7 +65,6 @@ class ExtensionToDevice implements Extension<ExtensionToDeviceRequest, Extension
 
     public constructor(
         private readonly client: MatrixClient,
-        private readonly cryptoCallbacks?: SyncCryptoCallbacks,
     ) {}
 
     public name(): string {
@@ -141,10 +88,7 @@ class ExtensionToDevice implements Extension<ExtensionToDeviceRequest, Extension
 
     public async onResponse(data: ExtensionToDeviceResponse): Promise<void> {
         const cancelledKeyVerificationTxns: string[] = [];
-        let events = data["events"] || [];
-        if (events.length > 0 && this.cryptoCallbacks) {
-            events = await this.cryptoCallbacks.preprocessToDeviceMessages(events);
-        }
+        const events = data["events"] || [];
         events
             .map(this.client.getEventMapper())
             .map((toDeviceEvent) => {
@@ -345,7 +289,6 @@ class ExtensionReceipts implements Extension<ExtensionReceiptsRequest, Extension
  */
 export class SlidingSyncSdk {
     private readonly opts: IStoredClientOpts;
-    private readonly syncOpts: SyncApiOptions;
     private syncState: SyncState | null = null;
     private syncStateData?: ISyncStateData;
     private lastPos: string | null = null;
@@ -356,10 +299,8 @@ export class SlidingSyncSdk {
         private readonly slidingSync: SlidingSync,
         private readonly client: MatrixClient,
         opts?: IStoredClientOpts,
-        syncOpts?: SyncApiOptions,
     ) {
         this.opts = defaultClientOpts(opts);
-        this.syncOpts = defaultSyncApiOpts(syncOpts);
 
         if (client.getNotifTimelineSet()) {
             client.reEmitter.reEmit(client.getNotifTimelineSet()!, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
@@ -368,14 +309,11 @@ export class SlidingSyncSdk {
         this.slidingSync.on(SlidingSyncEvent.Lifecycle, this.onLifecycle.bind(this));
         this.slidingSync.on(SlidingSyncEvent.RoomData, this.onRoomData.bind(this));
         const extensions: Extension<any, any>[] = [
-            new ExtensionToDevice(this.client, this.syncOpts.cryptoCallbacks),
+            new ExtensionToDevice(this.client),
             new ExtensionAccountData(this.client),
             new ExtensionTyping(this.client),
             new ExtensionReceipts(this.client),
         ];
-        if (this.syncOpts.crypto) {
-            extensions.push(new ExtensionE2EE(this.syncOpts.crypto));
-        }
         extensions.forEach((ext) => {
             this.slidingSync.registerExtension(ext);
         });
@@ -734,9 +672,6 @@ export class SlidingSyncSdk {
 
         const processRoomEvent = async (e: MatrixEvent): Promise<void> => {
             client.emit(ClientEvent.Event, e);
-            if (e.isState() && e.getType() == EventType.RoomEncryption && this.syncOpts.cryptoCallbacks) {
-                await this.syncOpts.cryptoCallbacks.onCryptoEvent(room, e);
-            }
         };
 
         await promiseMapSeries(stateEvents, processRoomEvent);
@@ -744,11 +679,6 @@ export class SlidingSyncSdk {
         ephemeralEvents.forEach(function (e) {
             client.emit(ClientEvent.Event, e);
         });
-
-        // Decrypt only the last message in all rooms to make sure we can generate a preview
-        // And decrypt all events after the recorded read receipt to ensure an accurate
-        // notification count
-        room.decryptCriticalEvents();
     }
 
     /**

package/src/sync.ts

@@ -25,7 +25,6 @@ limitations under the License.
 
 import { Optional } from "matrix-events-sdk";
 
-import type { SyncCryptoCallbacks } from "./common-crypto/CryptoBackend.ts";
 import { User } from "./models/user.ts";
 import { NotificationCountType, Room, RoomEvent } from "./models/room.ts";
 import { deepCopy, defer, IDeferred, noUnsafeEventProps, promiseMapSeries, unsafeProp } from "./utils.ts";
@@ -59,7 +58,6 @@ import { BeaconEvent } from "./models/beacon.ts";
 import { IEventsResponse } from "./@types/requests.ts";
 import { UNREAD_THREAD_NOTIFICATIONS } from "./@types/sync.ts";
 import { Feature, ServerSupport } from "./feature.ts";
-import { Crypto } from "./crypto/index.ts";
 import { KnownMembership } from "./@types/membership.ts";
 
 const DEBUG = true;
@@ -116,18 +114,6 @@ function debuglog(...params: any[]): void {
  * Options passed into the constructor of SyncApi by MatrixClient
  */
 export interface SyncApiOptions {
-    /**
-     * Crypto manager
-     *
-     * @deprecated in favour of cryptoCallbacks
-     */
-    crypto?: Crypto;
-
-    /**
-     * If crypto is enabled on our client, callbacks into the crypto module
-     */
-    cryptoCallbacks?: SyncCryptoCallbacks;
-
     /**
      * A function which is called
      * with a room ID and returns a boolean. It should return 'true' if the SDK can
@@ -642,9 +628,6 @@ export class SyncApi {
             }
             this.opts.filter.setLazyLoadMembers(true);
         }
-        if (this.opts.lazyLoadMembers) {
-            this.syncOpts.crypto?.enableLazyLoading();
-        }
     };
 
     private storeClientOptions = async (): Promise<void> => {
@@ -880,12 +863,6 @@ export class SyncApi {
                 catchingUp: this.catchingUp,
             };
 
-            if (this.syncOpts.crypto) {
-                // tell the crypto module we're about to process a sync
-                // response
-                await this.syncOpts.crypto.onSyncWillProcess(syncEventData);
-            }
-
             try {
                 await this.processSyncResponse(syncEventData, data);
             } catch (e) {
@@ -910,25 +887,10 @@ export class SyncApi {
                 syncOptions.hasSyncedBefore = true;
             }
 
-            // tell the crypto module to do its processing. It may block (to do a
-            // /keys/changes request).
-            if (this.syncOpts.cryptoCallbacks) {
-                await this.syncOpts.cryptoCallbacks.onSyncCompleted(syncEventData);
-            }
-
             // keep emitting SYNCING -> SYNCING for clients who want to do bulk updates
             this.updateSyncState(SyncState.Syncing, syncEventData);
 
             if (this.client.store.wantsSave()) {
-                // We always save the device list (if it's dirty) before saving the sync data:
-                // this means we know the saved device list data is at least as fresh as the
-                // stored sync data which means we don't have to worry that we may have missed
-                // device changes. We can also skip the delay since we're not calling this very
-                // frequently (and we don't really want to delay the sync for it).
-                if (this.syncOpts.crypto) {
-                    await this.syncOpts.crypto.saveDeviceList(0);
-                }
-
                 // tell databases that everything is now in a consistent state and can be saved.
                 await this.client.store.save();
             }
@@ -1160,11 +1122,7 @@ export class SyncApi {
 
         // handle to-device events
         if (data.to_device && Array.isArray(data.to_device.events) && data.to_device.events.length > 0) {
-            let toDeviceMessages: IToDeviceEvent[] = data.to_device.events.filter(noUnsafeEventProps);
-
-            if (this.syncOpts.cryptoCallbacks) {
-                toDeviceMessages = await this.syncOpts.cryptoCallbacks.preprocessToDeviceMessages(toDeviceMessages);
-            }
+            const toDeviceMessages: IToDeviceEvent[] = data.to_device.events.filter(noUnsafeEventProps);
 
             const cancelledKeyVerificationTxns: string[] = [];
             toDeviceMessages
@@ -1244,27 +1202,6 @@ export class SyncApi {
 
             await this.injectRoomEvents(room, stateEvents);
 
-            const inviter = room.currentState.getStateEvents(EventType.RoomMember, client.getUserId()!)?.getSender();
-
-            const crypto = client.crypto;
-            if (crypto) {
-                const parkedHistory = await crypto.cryptoStore.takeParkedSharedHistory(room.roomId);
-                for (const parked of parkedHistory) {
-                    if (parked.senderId === inviter) {
-                        await crypto.olmDevice.addInboundGroupSession(
-                            room.roomId,
-                            parked.senderKey,
-                            parked.forwardingCurve25519KeyChain,
-                            parked.sessionId,
-                            parked.sessionKey,
-                            parked.keysClaimed,
-                            true,
-                            { sharedHistory: true, untrusted: true },
-                        );
-                    }
-                }
-            }
-
             if (inviteObj.isBrandNewRoom) {
                 room.recalculate();
                 client.store.storeRoom(room);
@@ -1415,18 +1352,6 @@ export class SyncApi {
                 }
             }
 
-            // process any crypto events *before* emitting the RoomStateEvent events. This
-            // avoids a race condition if the application tries to send a message after the
-            // state event is processed, but before crypto is enabled, which then causes the
-            // crypto layer to complain.
-            if (this.syncOpts.cryptoCallbacks) {
-                for (const e of stateEvents.concat(events)) {
-                    if (e.isState() && e.getType() === EventType.RoomEncryption && e.getStateKey() === "") {
-                        await this.syncOpts.cryptoCallbacks.onCryptoEvent(room, e);
-                    }
-                }
-            }
-
             try {
                 await this.injectRoomEvents(room, stateEvents, events, syncEventData.fromCache);
             } catch (e) {
@@ -1459,11 +1384,6 @@ export class SyncApi {
             events.forEach(emitEvent);
             ephemeralEvents.forEach(emitEvent);
             accountDataEvents.forEach(emitEvent);
-
-            // Decrypt only the last message in all rooms to make sure we can generate a preview
-            // And decrypt all events after the recorded read receipt to ensure an accurate
-            // notification count
-            room.decryptCriticalEvents();
         });
 
         // Handle leaves (e.g. kicked rooms)
@@ -1528,23 +1448,6 @@ export class SyncApi {
                 client.getNotifTimelineSet()?.addLiveEvent(event);
             });
         }
-
-        // Handle device list updates
-        if (data.device_lists) {
-            if (this.syncOpts.cryptoCallbacks) {
-                await this.syncOpts.cryptoCallbacks.processDeviceLists(data.device_lists);
-            } else {
-                // FIXME if we *don't* have a crypto module, we still need to
-                // invalidate the device lists. But that would require a
-                // substantial bit of rework :/.
-            }
-        }
-
-        // Handle one_time_keys_count and unused fallback keys
-        await this.syncOpts.cryptoCallbacks?.processKeyCounts(
-            data.device_one_time_keys_count,
-            data.device_unused_fallback_key_types ?? data["org.matrix.msc2732.device_unused_fallback_key_types"],
-        );
     }
 
     /**

package/src/testing.ts

@@ -25,9 +25,6 @@ limitations under the License.
 import { IContent, IEvent, IUnsigned, MatrixEvent } from "./models/event.ts";
 import { RoomMember } from "./models/room-member.ts";
 import { EventType } from "./@types/event.ts";
-import { DecryptionError } from "./crypto/algorithms/index.ts";
-import { DecryptionFailureCode } from "./crypto-api/index.ts";
-import { EventDecryptionResult } from "./common-crypto/CryptoBackend.ts";
 
 /**
  * Create a {@link MatrixEvent}.
@@ -84,108 +81,3 @@ export function mkMatrixEvent(opts: {
     } as unknown as RoomMember;
     return mxEvent;
 }
-
-/**
- * Create a `MatrixEvent` representing a successfully-decrypted `m.room.encrypted` event.
- *
- * @param opts - Values for the event.
- */
-export async function mkEncryptedMatrixEvent(opts: {
-    /** Room ID of the event. */
-    roomId: string;
-
-    /** The sender of the event. */
-    sender: string;
-
-    /** The type the event will have, once it has been decrypted. */
-    plainType: EventType | string;
-
-    /** The content the event will have, once it has been decrypted. */
-    plainContent: IContent;
-
-    /** Optional `event_id` for the event. If provided will be used as event ID; else an ID is generated. */
-    eventId?: string;
-}): Promise<MatrixEvent> {
-    const mxEvent = mkMatrixEvent({
-        type: EventType.RoomMessageEncrypted,
-        roomId: opts.roomId,
-        sender: opts.sender,
-        content: { algorithm: "m.megolm.v1.aes-sha2" },
-        eventId: opts.eventId,
-    });
-
-    await decryptExistingEvent(mxEvent, { plainType: opts.plainType, plainContent: opts.plainContent });
-    return mxEvent;
-}
-
-/**
- * Create a `MatrixEvent` representing a `m.room.encrypted` event which could not be decrypted.
- *
- * @param opts - Values for the event.
- */
-export async function mkDecryptionFailureMatrixEvent(opts: {
-    /** Room ID of the event. */
-    roomId: string;
-
-    /** The sender of the event. */
-    sender: string;
-
-    /** The reason code for the failure */
-    code: DecryptionFailureCode;
-
-    /** A textual reason for the failure */
-    msg: string;
-
-    /** Optional `event_id` for the event. If provided will be used as event ID; else an ID is generated. */
-    eventId?: string;
-}): Promise<MatrixEvent> {
-    const mxEvent = mkMatrixEvent({
-        type: EventType.RoomMessageEncrypted,
-        roomId: opts.roomId,
-        sender: opts.sender,
-        content: { algorithm: "m.megolm.v1.aes-sha2" },
-        eventId: opts.eventId,
-    });
-
-    const mockCrypto = {
-        decryptEvent: async (_ev): Promise<EventDecryptionResult> => {
-            throw new DecryptionError(opts.code, opts.msg);
-        },
-    } as Parameters<MatrixEvent["attemptDecryption"]>[0];
-    await mxEvent.attemptDecryption(mockCrypto);
-    return mxEvent;
-}
-
-/**
- * Given an event previously returned by {@link mkDecryptionFailureMatrixEvent}, simulate a successful re-decryption
- * attempt.
- *
- * @param mxEvent - The event that will be decrypted.
- * @param opts - New data for the successful decryption.
- */
-export async function decryptExistingEvent(
-    mxEvent: MatrixEvent,
-    opts: {
-        /** The type the event will have, once it has been decrypted. */
-        plainType: EventType | string;
-
-        /** The content the event will have, once it has been decrypted. */
-        plainContent: IContent;
-    },
-): Promise<void> {
-    const decryptionResult: EventDecryptionResult = {
-        claimedEd25519Key: "",
-        clearEvent: {
-            type: opts.plainType,
-            content: opts.plainContent,
-        },
-        forwardingCurve25519KeyChain: [],
-        senderCurve25519Key: "",
-        untrusted: false,
-    };
-
-    const mockCrypto = {
-        decryptEvent: async (_ev): Promise<EventDecryptionResult> => decryptionResult,
-    } as Parameters<MatrixEvent["attemptDecryption"]>[0];
-    await mxEvent.attemptDecryption(mockCrypto);
-}