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

package/src/embedded.ts

@@ -30,14 +30,14 @@ import {
     IWidgetApiResponseData,
 } from "matrix-widget-api";
 
-import { MatrixEvent, IEvent, IContent, EventStatus } from "./models/event.ts";
+import { MatrixEvent, IEvent, IContent } from "./models/event.ts";
 import {
     ISendEventResponse,
     SendDelayedEventRequestOpts,
     SendDelayedEventResponse,
     UpdateDelayedEventAction,
 } from "./@types/requests.ts";
-import { EventType, StateEvents } from "./@types/event.ts";
+import { StateEvents } from "./@types/event.ts";
 import { logger } from "./logger.ts";
 import {
     MatrixClient,
@@ -54,8 +54,6 @@ import { MatrixError } from "./http-api/errors.ts";
 import { User } from "./models/user.ts";
 import { Room } from "./models/room.ts";
 import { ToDeviceBatch, ToDevicePayload } from "./models/ToDeviceMessage.ts";
-import { DeviceInfo } from "./crypto/deviceinfo.ts";
-import { IOlmDevice } from "./crypto/algorithms/megolm.ts";
 import { MapWithDefault, recursiveMapToObject } from "./utils.ts";
 import { TypedEventEmitter } from "./matrix.ts";
 
@@ -266,7 +264,7 @@ export class RoomWidgetClient extends MatrixClient {
         // still has some valuable helper methods that we make use of, so we
         // instantiate it anyways
         if (opts.slidingSync) {
-            this.syncApi = new SlidingSyncSdk(opts.slidingSync, this, opts, this.buildSyncApiOptions());
+            this.syncApi = new SlidingSyncSdk(opts.slidingSync, this, opts);
         } else {
             this.syncApi = new SyncApi(this, opts, this.buildSyncApiOptions());
         }
@@ -301,11 +299,6 @@ export class RoomWidgetClient extends MatrixClient {
 
         this.setSyncState(SyncState.Syncing);
         logger.info("Finished backfilling events");
-
-        this.matrixRTC.start();
-
-        // Watch for TURN servers, if requested
-        if (this.capabilities.turnServers) this.watchTurnServers();
     }
 
     public stopClient(): void {
@@ -321,60 +314,6 @@ export class RoomWidgetClient extends MatrixClient {
         throw new Error(`Unknown room: ${roomIdOrAlias}`);
     }
 
-    protected async encryptAndSendEvent(room: Room, event: MatrixEvent): Promise<ISendEventResponse>;
-    protected async encryptAndSendEvent(
-        room: Room,
-        event: MatrixEvent,
-        delayOpts: SendDelayedEventRequestOpts,
-    ): Promise<SendDelayedEventResponse>;
-    protected async encryptAndSendEvent(
-        room: Room,
-        event: MatrixEvent,
-        delayOpts?: SendDelayedEventRequestOpts,
-    ): Promise<ISendEventResponse | SendDelayedEventResponse> {
-        // We need to extend the content with the redacts parameter
-        // The js sdk uses event.redacts but the widget api uses event.content.redacts
-        // This will be converted back to event.redacts in the widget driver.
-        const content = event.event.redacts
-            ? { ...event.getContent(), redacts: event.event.redacts }
-            : event.getContent();
-
-        // Delayed event special case.
-        if (delayOpts) {
-            // TODO: updatePendingEvent for delayed events?
-            const response = await this.widgetApi.sendRoomEvent(
-                event.getType(),
-                content,
-                room.roomId,
-                "delay" in delayOpts ? delayOpts.delay : undefined,
-                "parent_delay_id" in delayOpts ? delayOpts.parent_delay_id : undefined,
-            );
-            return this.validateSendDelayedEventResponse(response);
-        }
-
-        const txId = event.getTxnId();
-        // Add the txnId to the pending list (still with unknown evID)
-        if (txId) this.pendingSendingEventsTxId.push({ type: event.getType(), id: undefined, txId });
-
-        let response: ISendEventFromWidgetResponseData;
-        try {
-            response = await this.widgetApi.sendRoomEvent(event.getType(), content, room.roomId);
-        } catch (e) {
-            this.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);
-            throw e;
-        }
-        // This also checks for an event id on the response
-        room.updatePendingEvent(event, EventStatus.SENT, response.event_id);
-
-        // Update the pending events list with the eventId
-        this.pendingSendingEventsTxId.forEach((p) => {
-            if (p.txId === txId) p.id = response.event_id;
-        });
-        this.eventEmitter.emit(RoomWidgetClientEvent.PendingEventsChanged);
-
-        return { event_id: response.event_id! };
-    }
-
     public async sendStateEvent(
         roomId: string,
         eventType: string,
@@ -460,46 +399,6 @@ export class RoomWidgetClient extends MatrixClient {
         await this.widgetApi.sendToDevice(eventType, false, recursiveMapToObject(contentMap));
     }
 
-    public async encryptAndSendToDevices(userDeviceInfoArr: IOlmDevice<DeviceInfo>[], payload: object): Promise<void> {
-        // map: user Id → device Id → payload
-        const contentMap: MapWithDefault<string, Map<string, object>> = new MapWithDefault(() => new Map());
-        for (const {
-            userId,
-            deviceInfo: { deviceId },
-        } of userDeviceInfoArr) {
-            contentMap.getOrCreate(userId).set(deviceId, payload);
-        }
-
-        await this.widgetApi.sendToDevice((payload as { type: string }).type, true, recursiveMapToObject(contentMap));
-    }
-
-    /**
-     * Send an event to a specific list of devices via the widget API. Optionally encrypts the event.
-     *
-     * If you are using a full MatrixClient you would be calling {@link MatrixClient.getCrypto().encryptToDeviceMessages()} followed
-     * by {@link MatrixClient.queueToDevice}.
-     *
-     * However, this is combined into a single step when running as an embedded widget client. So, we expose this method for those
-     * that need it.
-     *
-     * @param eventType - Type of the event to send.
-     * @param encrypted - Whether the event should be encrypted.
-     * @param contentMap - The content to send. Map from user_id to device_id to content object.
-     */
-    public async sendToDeviceViaWidgetApi(
-        eventType: string,
-        encrypted: boolean,
-        contentMap: SendToDeviceContentMap,
-    ): Promise<void> {
-        await this.widgetApi.sendToDevice(eventType, encrypted, recursiveMapToObject(contentMap));
-    }
-
-    // Overridden since we get TURN servers automatically over the widget API,
-    // and this method would otherwise complain about missing an access token
-    public async checkTurnServers(): Promise<boolean> {
-        return this.turnServers.length > 0;
-    }
-
     // Overridden since we 'sync' manually without the sync API
     public getSyncState(): SyncState | null {
         return this.syncState;
@@ -587,39 +486,11 @@ export class RoomWidgetClient extends MatrixClient {
             sender: ev.detail.data.sender,
             content: ev.detail.data.content as IContent,
         });
-        // Mark the event as encrypted if it was, using fake contents and keys since those are unknown to us
-        if (ev.detail.data.encrypted) event.makeEncrypted(EventType.RoomMessageEncrypted, {}, "", "");
 
         this.emit(ClientEvent.ToDeviceEvent, event);
         this.setSyncState(SyncState.Syncing);
         await this.ack(ev);
     };
-
-    private async watchTurnServers(): Promise<void> {
-        const servers = this.widgetApi.getTurnServers();
-        const onClientStopped = (): void => {
-            servers.return(undefined);
-        };
-        this.lifecycle!.signal.addEventListener("abort", onClientStopped);
-
-        try {
-            for await (const server of servers) {
-                this.turnServers = [
-                    {
-                        urls: server.uris,
-                        username: server.username,
-                        credential: server.password,
-                    },
-                ];
-                this.emit(ClientEvent.TurnServers, this.turnServers);
-                logger.log(`Received TURN server: ${server.uris}`);
-            }
-        } catch (e) {
-            logger.warn("Error watching TURN servers", e);
-        } finally {
-            this.lifecycle!.signal.removeEventListener("abort", onClientStopped);
-        }
-    }
 }
 
 function processAndThrow(error: unknown): never {

package/src/event-mapper.ts

@@ -31,7 +31,6 @@ export interface MapperOpts {
 
 export function eventMapperFor(client: MatrixClient, options: MapperOpts): EventMapper {
     let preventReEmit = Boolean(options.preventReEmit);
-    const decrypt = options.decrypt !== false;
 
     function mapper(plainOldJsObject: Partial<IEvent>): MatrixEvent {
         if (options.toDevice) {
@@ -81,9 +80,6 @@ export function eventMapperFor(client: MatrixClient, options: MapperOpts): Event
             if (!preventReEmit) {
                 client.reEmitter.reEmit(event, [MatrixEventEvent.Decrypted]);
             }
-            if (decrypt) {
-                client.decryptEventIfNeeded(event);
-            }
         }
 
         if (!preventReEmit) {

package/src/matrix.ts

@@ -16,12 +16,10 @@ limitations under the License.
 
 import { WidgetApi } from "matrix-widget-api";
 
-import { MemoryCryptoStore } from "./crypto/store/memory-crypto-store.ts";
 import { MemoryStore } from "./store/memory.ts";
 import { MatrixScheduler } from "./scheduler.ts";
 import { MatrixClient, ICreateClientOpts } from "./client.ts";
 import { RoomWidgetClient, ICapabilities } from "./embedded.ts";
-import { CryptoStore } from "./crypto/store/base.ts";
 
 export * from "./client.ts";
 export * from "./serverCapabilities.ts";
@@ -52,10 +50,6 @@ export * from "./interactive-auth.ts";
 export * from "./service-types.ts";
 export * from "./store/memory.ts";
 export * from "./store/indexeddb.ts";
-export * from "./crypto/store/memory-crypto-store.ts";
-export * from "./crypto/store/localStorage-crypto-store.ts";
-export * from "./crypto/store/indexeddb-crypto-store.ts";
-export type { OutgoingRoomKeyRequest } from "./crypto/store/base.ts";
 export * from "./content-repo.ts";
 export type * from "./@types/common.ts";
 export type * from "./@types/uia.ts";
@@ -73,7 +67,6 @@ export * from "./@types/polls.ts";
 export type * from "./@types/local_notifications.ts";
 export type * from "./@types/registration.ts";
 export * from "./@types/read_receipts.ts";
-export type * from "./@types/crypto.ts";
 export * from "./@types/extensible_events.ts";
 export type * from "./@types/IIdentityServerProvider.ts";
 export * from "./@types/membership.ts";
@@ -81,29 +74,10 @@ export * from "./models/room-summary.ts";
 export * from "./models/event-status.ts";
 export type { RoomSummary } from "./client.ts";
 export * as ContentHelpers from "./content-helpers.ts";
-export * as SecretStorage from "./secret-storage.ts";
-export type { ICryptoCallbacks } from "./crypto/index.ts"; // used to be located here
-export { createNewMatrixCall, CallEvent } from "./webrtc/call.ts";
-export type { MatrixCall } from "./webrtc/call.ts";
-export {
-    GroupCall,
-    GroupCallEvent,
-    GroupCallIntent,
-    GroupCallState,
-    GroupCallType,
-    GroupCallStatsReportEvent,
-} from "./webrtc/groupCall.ts";
 
-export {
-    /** @deprecated Use {@link Crypto.CryptoEvent} instead */
-    CryptoEvent,
-} from "./crypto/index.ts";
 export { SyncState, SetPresence } from "./sync.ts";
 export type { ISyncStateData as SyncStateData } from "./sync.ts";
 export { SlidingSyncEvent } from "./sliding-sync.ts";
-export { MediaHandlerEvent } from "./webrtc/mediaHandler.ts";
-export { CallFeedEvent } from "./webrtc/callFeed.ts";
-export { StatsReport } from "./webrtc/stats/statsReport.ts";
 export { Relations, RelationsEvent } from "./models/relations.ts";
 export { TypedEventEmitter } from "./models/typed-event-emitter.ts";
 export { LocalStorageErrors } from "./store/local-storage-events-emitter.ts";
@@ -112,20 +86,6 @@ export type { ISSOFlow as SSOFlow, LoginFlow } from "./@types/auth.ts";
 export type { IHierarchyRelation as HierarchyRelation, IHierarchyRoom as HierarchyRoom } from "./@types/spaces.ts";
 export { LocationAssetType } from "./@types/location.ts";
 
-/** @deprecated Backwards-compatibility re-export. Import from `crypto-api` directly. */
-export * as Crypto from "./crypto-api/index.ts";
-
-let cryptoStoreFactory = (): CryptoStore => new MemoryCryptoStore();
-
-/**
- * Configure a different factory to be used for creating crypto stores
- *
- * @param fac - a function which will return a new `CryptoStore`
- */
-export function setCryptoStoreFactory(fac: () => CryptoStore): void {
-    cryptoStoreFactory = fac;
-}
-
 function amendClientOpts(opts: ICreateClientOpts): ICreateClientOpts {
     opts.store =
         opts.store ??
@@ -133,7 +93,6 @@ function amendClientOpts(opts: ICreateClientOpts): ICreateClientOpts {
             localStorage: globalThis.localStorage,
         });
     opts.scheduler = opts.scheduler ?? new MatrixScheduler();
-    opts.cryptoStore = opts.cryptoStore ?? cryptoStoreFactory();
 
     return opts;
 }

package/src/models/MSC3089Branch.ts

@@ -177,9 +177,6 @@ export class MSC3089Branch {
 
         if (!event) throw new Error("Failed to find event");
 
-        // Sometimes the event isn't decrypted for us, so do that.
-        await this.client.decryptEventIfNeeded(event);
-
         return event;
     }
 

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>;
 
     /**
@@ -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.
@@ -1669,10 +1384,6 @@ export class MatrixEvent extends TypedEventEmitter<MatrixEventEmittedEvents, Mat
         };
     }
 
-    public setVerificationRequest(request: VerificationRequest): void {
-        this.verificationRequest = request;
-    }
-
     public setTxnId(txnId: string): void {
         this.txnId = txnId;
     }