MSC4311: Use full PDU's in stripped state (like invite_room_state) over federation and always include m.room.create event

changelog.d/19723.bugfix

@@ -0,0 +1 @@
+Remove flawed [MSC4311](https://github.com/matrix-org/matrix-spec-proposals/pull/4311) partial implementation: Client-side API's like `/sync` should still use stripped events.

synapse/events/utils.py

@@ -1019,15 +1019,6 @@ def strip_event(event: EventBase) -> JsonDict:
     Stripped state events can only have the `sender`, `type`, `state_key` and `content`
     properties present.
     """
-    # MSC4311: Ensure the create event is available on invites and knocks.
-    # TODO: Implement the rest of MSC4311
-    if (
-        event.room_version.msc4291_room_ids_as_hashes
-        and event.type == EventTypes.Create
-        and event.get_state_key() == ""
-    ):
-        return event.get_pdu_json()
-
     return {
         "type": event.type,
         "state_key": event.state_key,

synapse/federation/federation_client.py

@@ -60,6 +60,8 @@
     RoomVersions,
 )
 from synapse.events import EventBase, builder, make_event_from_dict
+from synapse.events.snapshot import EventContext
+from synapse.events.utils import parse_stripped_state_event
 from synapse.federation.federation_base import (
     FederationBase,
     InvalidEventSignatureError,
@@ -71,7 +73,13 @@
 from synapse.http.types import QueryParams
 from synapse.logging.opentracing import SynapseTags, log_kv, set_tag, tag_args, trace
 from synapse.metrics import SERVER_NAME_LABEL
-from synapse.types import JsonDict, StrCollection, UserID, get_domain_from_id
+from synapse.types import (
+    JsonDict,
+    StrCollection,
+    UserID,
+    get_domain_from_id,
+)
+from synapse.types.state import StateFilter
 from synapse.util.async_helpers import concurrently_execute
 from synapse.util.caches.expiringcache import ExpiringCache
 from synapse.util.duration import Duration
@@ -1309,12 +1317,12 @@ async def send_invite(
         self,
         destination: str,
         room_id: str,
-        event_id: str,
         pdu: EventBase,
+        context: EventContext,
     ) -> EventBase:
         room_version = await self.store.get_room_version(room_id)
 
-        content = await self._do_send_invite(destination, pdu, room_version)
+        content = await self._do_send_invite(destination, pdu, context, room_version)
 
         pdu_dict = content["event"]
 
@@ -1335,7 +1343,11 @@ async def send_invite(
         return pdu
 
     async def _do_send_invite(
-        self, destination: str, pdu: EventBase, room_version: RoomVersion
+        self,
+        destination: str,
+        pdu: EventBase,
+        context: EventContext,
+        room_version: RoomVersion,
     ) -> JsonDict:
         """Actually sends the invite, first trying v2 API and falling back to
         v1 API if necessary.
@@ -1350,6 +1362,34 @@ async def _do_send_invite(
         """
         time_now = self._clock.time_msec()
 
+        # MSC4311: For the federation API, format events in `invite_room_state` as full
+        # PDU's
+        #
+        # First get all of the expected stripped state events that should be included.
+        # We will derive these from the `unsigned` part of the PDU but this doesn't
+        # include any event ID information so we need to look it up based on the state
+        # at the time of the invite.
+        stripped_state_types = []
+        for raw_stripped_event in pdu.unsigned.get("invite_room_state", []):
+            stripped_state_event = parse_stripped_state_event(raw_stripped_event)
+            # Since this is our own invite, it should always be well-formed
+            assert stripped_state_event is not None, (
+                "Unable to parse one of the evnts from the `invite_room_state` as a stripped state event"
+            )
+            stripped_state_types.append(
+                (stripped_state_event.type, stripped_state_event.state_key)
+            )
+
+        # Find the full events based on the state at the time of the invite
+        state_filter = StateFilter.from_types(stripped_state_types)
+        state_ids = await self.store.get_stripped_room_state_ids_from_event_context(
+            context, state_filter
+        )
+        state_events = await self.store.get_events(state_ids)
+        assert set(state_ids) == set(state_events.keys()), (
+            "We should have all events available that were set as stripped state."
+        )
+
         try:
             return await self.transport_layer.send_invite_v2(
                 destination=destination,
@@ -1358,7 +1398,10 @@ async def _do_send_invite(
                 content={
                     "event": pdu.get_pdu_json(time_now),
                     "room_version": room_version.identifier,
-                    "invite_room_state": pdu.unsigned.get("invite_room_state", []),
+                    "invite_room_state": [
+                        state_event.get_pdu_json(time_now)
+                        for state_event in state_events.values()
+                    ],
                 },
             )
         except HttpResponseException as e:

synapse/federation/federation_server.py

@@ -965,6 +965,7 @@ async def on_send_knock_request(
         # server. This will allow the remote server's clients to display information
         # related to the room while the knock request is pending.
         stripped_room_state = (
+            # TODO: Implement MSC4311 and use full PDUs here
             await self.store.get_stripped_room_state_from_event_context(
                 context, self._room_prejoin_state_types
             )

synapse/handlers/federation.py

@@ -554,7 +554,9 @@ async def try_backfill(domains: StrCollection) -> bool:
 
         return False
 
-    async def send_invite(self, target_host: str, event: EventBase) -> EventBase:
+    async def send_invite(
+        self, target_host: str, event: EventBase, context: EventContext
+    ) -> EventBase:
         """Sends the invite to the remote server for signing.
 
         Invites must be signed by the invitee's server before distribution.
@@ -563,8 +565,8 @@ async def send_invite(self, target_host: str, event: EventBase) -> EventBase:
             pdu = await self.federation_client.send_invite(
                 destination=target_host,
                 room_id=event.room_id,
-                event_id=event.event_id,
                 pdu=event,
+                context=context,
             )
         except RequestSendFailed:
             raise SynapseError(502, f"Can't connect to server {target_host}")

synapse/handlers/message.py

@@ -2087,7 +2087,7 @@ async def persist_and_notify_client_events(
                         # to get them to sign the event.
 
                         returned_invite = await federation_handler.send_invite(
-                            invitee.domain, event
+                            invitee.domain, event, context
                         )
                         event.unsigned.pop("room_state", None)
 

synapse/storage/databases/main/events_worker.py

@@ -1137,19 +1137,46 @@ async def get_stripped_room_state_from_event_context(
             filter = StateFilter.from_types(types)
         else:
             filter = state_keys_to_include
-        selected_state_ids = await context.get_current_state_ids(filter)
+
+        selected_state_ids = await self.get_stripped_room_state_ids_from_event_context(
+            context, filter
+        )
+
+        state_to_include = await self.get_events(selected_state_ids)
+
+        return [strip_event(e) for e in state_to_include.values()]
+
+    async def get_stripped_room_state_ids_from_event_context(
+        self,
+        context: EventContext,
+        state_keys_to_include: StateFilter,
+    ) -> list[str]:
+        """
+        Retrieve the stripped state IDs for an event, given an event context to retrieve state
+        from as well as the state types to include. Optionally, include the membership
+        events from a specific user.
+
+        "Stripped" state means that only the `type`, `state_key`, `content` and `sender` keys
+        are included from each state event.
+
+        Args:
+            context: The event context to retrieve state of the room from.
+            state_keys_to_include: The state events to include, for each event type.
+
+        Returns:
+            A list of event_ids, each representing the stripped state event to include for this event
+        """
+        selected_state_ids = await context.get_current_state_ids(state_keys_to_include)
 
         # We know this event is not an outlier, so this must be
         # non-None.
         assert selected_state_ids is not None
 
-        # Confusingly, get_current_state_events may return events that are discarded by
-        # the filter, if they're in context._state_delta_due_to_event. Strip these away.
-        selected_state_ids = filter.filter_state(selected_state_ids)
-
-        state_to_include = await self.get_events(selected_state_ids.values())
+        # Confusingly, `get_current_state_ids` may return events that are discarded by
+        # the filter, if they're in `context._state_delta_due_to_event`. Strip these away.
+        selected_state_ids = state_keys_to_include.filter_state(selected_state_ids)
 
-        return [strip_event(e) for e in state_to_include.values()]
+        return list(selected_state_ids.values())
 
     def _maybe_start_fetch_thread(self) -> None:
         """Starts an event fetch thread if we are not yet at the maximum number."""