@unwanted/matrix-sdk-mini 34.12.0 → 36.0.0

package/src/digest.ts

@@ -18,11 +18,11 @@ limitations under the License.
  * Computes a SHA-256 hash of a string (after utf-8 encoding) and returns it as an ArrayBuffer.
  *
  * @param plaintext The string to hash
- * @returns An ArrayBuffer containing the SHA-256 hash of the input string
+ * @returns An Uint8Array containing the SHA-256 hash of the input string
  * @throws If the subtle crypto API is not available, for example if the code is running
  *         in a web page with an insecure context (eg. served over plain HTTP).
  */
-export async function sha256(plaintext: string): Promise<ArrayBuffer> {
+export async function sha256(plaintext: string): Promise<Uint8Array> {
     if (!globalThis.crypto.subtle) {
         throw new Error("Crypto.subtle is not available: insecure context?");
     }
@@ -30,5 +30,5 @@ export async function sha256(plaintext: string): Promise<ArrayBuffer> {
 
     const digest = await globalThis.crypto.subtle.digest("SHA-256", utf8);
 
-    return digest;
+    return new Uint8Array(digest);
 }

package/src/embedded.ts

@@ -28,16 +28,17 @@ import {
     WidgetApiAction,
     IWidgetApiResponse,
     IWidgetApiResponseData,
+    IUpdateStateToWidgetActionRequest,
 } 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 +55,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";
 
@@ -136,6 +135,7 @@ export type EventHandlerMap = { [RoomWidgetClientEvent.PendingEventsChanged]: ()
 export class RoomWidgetClient extends MatrixClient {
     private room?: Room;
     private readonly widgetApiReady: Promise<void>;
+    private readonly roomStateSynced: Promise<void>;
     private lifecycle?: AbortController;
     private syncState: SyncState | null = null;
 
@@ -154,7 +154,7 @@ export class RoomWidgetClient extends MatrixClient {
      */
     public constructor(
         private readonly widgetApi: WidgetApi,
-        private readonly capabilities: ICapabilities,
+        /*private readonly */capabilities: ICapabilities,
         private readonly roomId: string,
         opts: IMatrixClientCreateOpts,
         sendContentLoaded: boolean,
@@ -189,6 +189,11 @@ export class RoomWidgetClient extends MatrixClient {
         };
 
         this.widgetApiReady = new Promise<void>((resolve) => this.widgetApi.once("ready", resolve));
+        this.roomStateSynced = capabilities.receiveState?.length
+            ? new Promise<void>((resolve) =>
+                  this.widgetApi.once(`action:${WidgetApiToWidgetAction.UpdateState}`, resolve),
+              )
+            : Promise.resolve();
 
         // Request capabilities for the functionality this client needs to support
         if (
@@ -241,6 +246,7 @@ export class RoomWidgetClient extends MatrixClient {
 
         widgetApi.on(`action:${WidgetApiToWidgetAction.SendEvent}`, this.onEvent);
         widgetApi.on(`action:${WidgetApiToWidgetAction.SendToDevice}`, this.onToDevice);
+        widgetApi.on(`action:${WidgetApiToWidgetAction.UpdateState}`, this.onStateUpdate);
 
         // Open communication with the host
         widgetApi.start();
@@ -266,7 +272,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());
         }
@@ -276,22 +282,6 @@ export class RoomWidgetClient extends MatrixClient {
 
         await this.widgetApiReady;
 
-        // Backfill the requested events
-        // We only get the most recent event for every type + state key combo,
-        // so it doesn't really matter what order we inject them in
-        await Promise.all(
-            this.capabilities.receiveState?.map(async ({ eventType, stateKey }) => {
-                const rawEvents = await this.widgetApi.readStateEvents(eventType, undefined, stateKey, [this.roomId]);
-                const events = rawEvents.map((rawEvent) => new MatrixEvent(rawEvent as Partial<IEvent>));
-
-                await this.syncApi!.injectRoomEvents(this.room!, [], events);
-                events.forEach((event) => {
-                    this.emit(ClientEvent.Event, event);
-                    logger.info(`Backfilled event ${event.getId()} ${event.getType()} ${event.getStateKey()}`);
-                });
-            }) ?? [],
-        );
-
         if (opts.clientWellKnownPollPeriod !== undefined) {
             this.clientWellKnownIntervalID = setInterval(() => {
                 this.fetchClientWellKnown();
@@ -299,18 +289,15 @@ export class RoomWidgetClient extends MatrixClient {
             this.fetchClientWellKnown();
         }
 
+        await this.roomStateSynced;
         this.setSyncState(SyncState.Syncing);
-        logger.info("Finished backfilling events");
-
-        this.matrixRTC.start();
-
-        // Watch for TURN servers, if requested
-        if (this.capabilities.turnServers) this.watchTurnServers();
+        logger.info("Finished initial sync");
     }
 
     public stopClient(): void {
         this.widgetApi.off(`action:${WidgetApiToWidgetAction.SendEvent}`, this.onEvent);
         this.widgetApi.off(`action:${WidgetApiToWidgetAction.SendToDevice}`, this.onToDevice);
+        this.widgetApi.off(`action:${WidgetApiToWidgetAction.UpdateState}`, this.onStateUpdate);
 
         super.stopClient();
         this.lifecycle!.abort(); // Signal to other async tasks that the client has stopped
@@ -321,60 +308,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 +393,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;
@@ -567,10 +460,16 @@ export class RoomWidgetClient extends MatrixClient {
 
             // Only inject once we have update the txId
             await this.updateTxId(event);
-            await this.syncApi!.injectRoomEvents(this.room!, [], [event]);
+            
+            if (this.syncApi instanceof SyncApi) {
+                await this.syncApi.injectRoomEvents(this.room!, undefined, [], [event]);
+            } else {
+                // Sliding Sync
+                await this.syncApi!.injectRoomEvents(this.room!, [], [event]);
+            }
             this.emit(ClientEvent.Event, event);
             this.setSyncState(SyncState.Syncing);
-            logger.info(`Received event ${event.getId()} ${event.getType()} ${event.getStateKey()}`);
+            logger.info(`Received event ${event.getId()} ${event.getType()}`);
         } else {
             const { event_id: eventId, room_id: roomId } = ev.detail.data;
             logger.info(`Received event ${eventId} for a different room ${roomId}; discarding`);
@@ -587,39 +486,34 @@ 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}`);
+    private onStateUpdate = async (ev: CustomEvent<IUpdateStateToWidgetActionRequest>): Promise<void> => {
+        ev.preventDefault();
+        for (const rawEvent of ev.detail.data.state) {
+            // Verify the room ID matches, since it's possible for the client to
+            // send us state updates from other rooms if this widget is always
+            // on screen
+            if (rawEvent.room_id === this.roomId) {
+                const event = new MatrixEvent(rawEvent as Partial<IEvent>);
+                if (this.syncApi instanceof SyncApi) {
+                    await this.syncApi.injectRoomEvents(this.room!, undefined, [event]);
+                } else {
+                    // Sliding Sync
+                    await this.syncApi!.injectRoomEvents(this.room!, [event]);
+                }
+                logger.info(`Updated state entry ${event.getType()} ${event.getStateKey()} to ${event.getId()}`);
+            } else {
+                const { event_id: eventId, room_id: roomId } = ev.detail.data;
+                logger.info(`Received state entry ${eventId} for a different room ${roomId}; discarding`);
             }
-        } catch (e) {
-            logger.warn("Error watching TURN servers", e);
-        } finally {
-            this.lifecycle!.signal.removeEventListener("abort", onClientStopped);
         }
-    }
+        await this.ack(ev);
+    };
 }
 
 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/feature.ts

@@ -60,6 +60,7 @@ const featureSupportResolver: Record<string, FeatureSupportCondition> = {
     },
     [Feature.RelationsRecursion]: {
         unstablePrefixes: ["org.matrix.msc3981"],
+        matrixVersion: "v1.10",
     },
     [Feature.IntentionalMentions]: {
         unstablePrefixes: ["org.matrix.msc3952_intentional_mentions"],

package/src/http-api/errors.ts

@@ -167,9 +167,9 @@ export class MatrixError extends HTTPError {
 }
 
 /**
- * @returns The recommended delay in milliseconds to wait before retrying
- * the request that triggered {@link error}, or {@link defaultMs} if the
- * error was not due to rate-limiting or if no valid delay is recommended.
+ * @returns The recommended delay in milliseconds to wait before retrying the request.
+ * @param error - The error to check for a retry delay.
+ * @param defaultMs - The delay to use if the error was not due to rate-limiting or if no valid delay is recommended.
  */
 export function safeGetRetryAfterMs(error: unknown, defaultMs: number): number {
     if (!(error instanceof HTTPError) || !error.isRateLimitError()) {

package/src/http-api/utils.ts

@@ -180,8 +180,8 @@ export function calculateRetryBackoff(err: any, attempts: number, retryConnectio
         return -1;
     }
 
-    if (err.httpStatus && (err.httpStatus === 400 || err.httpStatus === 403 || err.httpStatus === 401)) {
-        // client error; no amount of retrying will save you now.
+    if (err.httpStatus && Math.floor(err.httpStatus / 100) === 4 && err.httpStatus !== 429) {
+        // client error; no amount of retrying will save you now (except for rate limiting which is handled below)
         return -1;
     }
 

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-timeline-set.ts

@@ -58,13 +58,13 @@ export interface IRoomTimelineData {
 }
 
 export interface IAddEventToTimelineOptions
-    extends Pick<IAddEventOptions, "toStartOfTimeline" | "roomState" | "timelineWasEmpty"> {
+    extends Pick<IAddEventOptions, "toStartOfTimeline" | "roomState" | "timelineWasEmpty" | "addToState"> {
     /** Whether the sync response came from cache */
     fromCache?: boolean;
 }
 
 export interface IAddLiveEventOptions
-    extends Pick<IAddEventToTimelineOptions, "fromCache" | "roomState" | "timelineWasEmpty"> {
+    extends Pick<IAddEventToTimelineOptions, "fromCache" | "roomState" | "timelineWasEmpty" | "addToState"> {
     /** Applies to events in the timeline only. If this is 'replace' then if a
      * duplicate is encountered, the event passed to this function will replace
      * the existing event in the timeline. If this is not specified, or is
@@ -391,6 +391,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     public addEventsToTimeline(
         events: MatrixEvent[],
         toStartOfTimeline: boolean,
+        addToState: boolean,
         timeline: EventTimeline,
         paginationToken?: string | null,
     ): void {
@@ -495,6 +496,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
                 // we don't know about this event yet. Just add it to the timeline.
                 this.addEventToTimeline(event, timeline, {
                     toStartOfTimeline,
+                    addToState,
                 });
                 lastEventWasNew = true;
                 didUpdate = true;
@@ -592,7 +594,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      */
     public addLiveEvent(
         event: MatrixEvent,
-        { duplicateStrategy, fromCache, roomState, timelineWasEmpty }: IAddLiveEventOptions = {},
+        { duplicateStrategy, fromCache, roomState, timelineWasEmpty, addToState }: IAddLiveEventOptions,
     ): void {
         if (this.filter) {
             const events = this.filter.filterRoomTimeline([event]);
@@ -630,6 +632,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
             fromCache,
             roomState,
             timelineWasEmpty,
+            addToState
         });
     }
 
@@ -649,40 +652,8 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
     public addEventToTimeline(
         event: MatrixEvent,
         timeline: EventTimeline,
-        { toStartOfTimeline, fromCache, roomState, timelineWasEmpty }: IAddEventToTimelineOptions,
-    ): void;
-    /**
-     * @deprecated In favor of the overload with `IAddEventToTimelineOptions`
-     */
-    public addEventToTimeline(
-        event: MatrixEvent,
-        timeline: EventTimeline,
-        toStartOfTimeline: boolean,
-        fromCache?: boolean,
-        roomState?: RoomState,
-    ): void;
-    public addEventToTimeline(
-        event: MatrixEvent,
-        timeline: EventTimeline,
-        toStartOfTimelineOrOpts: boolean | IAddEventToTimelineOptions,
-        fromCache = false,
-        roomState?: RoomState,
+        { toStartOfTimeline, fromCache = false, roomState, timelineWasEmpty, addToState }: IAddEventToTimelineOptions,
     ): void {
-        let toStartOfTimeline = !!toStartOfTimelineOrOpts;
-        let timelineWasEmpty: boolean | undefined;
-        if (typeof toStartOfTimelineOrOpts === "object") {
-            ({ toStartOfTimeline, fromCache = false, roomState, timelineWasEmpty } = toStartOfTimelineOrOpts);
-        } else if (toStartOfTimelineOrOpts !== undefined) {
-            // Deprecation warning
-            // FIXME: Remove after 2023-06-01 (technical debt)
-            logger.warn(
-                "Overload deprecated: " +
-                    "`EventTimelineSet.addEventToTimeline(event, timeline, toStartOfTimeline, fromCache?, roomState?)` " +
-                    "is deprecated in favor of the overload with " +
-                    "`EventTimelineSet.addEventToTimeline(event, timeline, IAddEventToTimelineOptions)`",
-            );
-        }
-
         if (timeline.getTimelineSet() !== this) {
             throw new Error(`EventTimelineSet.addEventToTimeline: Timeline=${timeline.toString()} does not belong " +
                 "in timelineSet(threadId=${this.thread?.id})`);
@@ -713,6 +684,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
             toStartOfTimeline,
             roomState,
             timelineWasEmpty,
+            addToState,
         });
         this._eventIdToTimeline.set(eventId, timeline);
 
@@ -741,7 +713,12 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
      * @remarks
      * Fires {@link RoomEvent.Timeline}
      */
-    public insertEventIntoTimeline(event: MatrixEvent, timeline: EventTimeline, roomState: RoomState): void {
+    public insertEventIntoTimeline(
+        event: MatrixEvent,
+        timeline: EventTimeline,
+        roomState: RoomState,
+        addToState: boolean,
+    ): void {
         if (timeline.getTimelineSet() !== this) {
             throw new Error(`EventTimelineSet.insertEventIntoTimeline: Timeline=${timeline.toString()} does not belong " +
                 "in timelineSet(threadId=${this.thread?.id})`);
@@ -777,6 +754,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
                 fromCache: false,
                 timelineWasEmpty: false,
                 roomState,
+                addToState,
             });
             return;
         }
@@ -799,7 +777,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
         // If we got to the end of the loop, insertIndex points at the end of
         // the list.
 
-        timeline.insertEvent(event, insertIndex, roomState);
+        timeline.insertEvent(event, insertIndex, roomState, addToState);
         this._eventIdToTimeline.set(eventId, timeline);
 
         const data: IRoomTimelineData = {
@@ -832,6 +810,7 @@ export class EventTimelineSet extends TypedEventEmitter<EmittedEvents, EventTime
         } else if (!this.filter || this.filter.filterRoomTimeline([localEvent]).length) {
             this.addEventToTimeline(localEvent, this.liveTimeline, {
                 toStartOfTimeline: false,
+                addToState: false,
             });
         }
     }