Add support for creator power

tulir · tulir · commit 829bee53bbc7 · 2025-07-11T14:18:07.000+03:00
diff --git a/mautrix/appservice/api/intent.py b/mautrix/appservice/api/intent.py
@@ -710,6 +710,8 @@ async def _ensure_has_power_level_for(
         if not await self.state_store.has_power_levels_cached(room_id):
             # TODO add option to not try to fetch power levels from server
             await self.get_power_levels(room_id, ignore_cache=True, ensure_joined=False)
+        if not await self.state_store.has_create_cached(room_id):
+            await self.get_state_event(room_id, EventType.ROOM_CREATE, format="event")
         if not await self.state_store.has_power_level(room_id, self.mxid, event_type):
             # TODO implement something better
             raise IntentError(
diff --git a/mautrix/client/api/events.py b/mautrix/client/api/events.py
@@ -5,7 +5,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from __future__ import annotations
 
-from typing import Awaitable
+from typing import Awaitable, Literal, overload
 import json
 
 from mautrix.api import Method, Path
@@ -168,12 +168,41 @@ async def get_event_context(
         )
         return EventContext.deserialize(resp)
 
+    @overload
     async def get_state_event(
         self,
         room_id: RoomID,
         event_type: EventType,
         state_key: str = "",
-    ) -> StateEventContent:
+        *,
+        format: Literal["content"] = "content",
+    ) -> StateEventContent: ...
+    @overload
+    async def get_state_event(
+        self,
+        room_id: RoomID,
+        event_type: EventType,
+        state_key: str = "",
+        *,
+        format: Literal["event"],
+    ) -> StateEvent: ...
+    @overload
+    async def get_state_event(
+        self,
+        room_id: RoomID,
+        event_type: EventType,
+        state_key: str = "",
+        *,
+        format: str = "content",
+    ) -> StateEventContent | StateEvent: ...
+    async def get_state_event(
+        self,
+        room_id: RoomID,
+        event_type: EventType,
+        state_key: str = "",
+        *,
+        format: str = "content",
+    ) -> StateEventContent | StateEvent:
         """
         Looks up the contents of a state event in a room. If the user is joined to the room then the
         state is taken from the current state of the room. If the user has left the room then the
@@ -185,18 +214,27 @@ async def get_state_event(
             room_id: The ID of the room to look up the state in.
             event_type: The type of state to look up.
             state_key: The key of the state to look up. Defaults to empty string.
+            format: The format of the state event to return. Defaults to "content", which only returns
+                the content of the state event. If set to "event", the full event is returned.
+                See https://github.com/matrix-org/matrix-spec/issues/1047 for more info.
 
         Returns:
             The state event.
         """
         content = await self.api.request(
             Method.GET,
             Path.v3.rooms[room_id].state[event_type][state_key],
+            query_params={"format": format} if format != "content" else None,
             metrics_method="getStateEvent",
         )
         content["__mautrix_event_type"] = event_type
         try:
-            return StateEvent.deserialize_content(content)
+            if format == "content":
+                return StateEvent.deserialize_content(content)
+            elif format == "event":
+                return StateEvent.deserialize(content)
+            else:
+                return content
         except SerializerError as e:
             raise MatrixResponseError("Invalid state event in response") from e
 
diff --git a/mautrix/client/state_store/abstract.py b/mautrix/client/state_store/abstract.py
@@ -121,6 +121,18 @@ async def set_power_levels(
     ) -> None:
         pass
 
+    @abstractmethod
+    async def has_create_cached(self, room_id: RoomID) -> bool:
+        pass
+
+    @abstractmethod
+    async def get_create(self, room_id: RoomID) -> StateEvent | None:
+        pass
+
+    @abstractmethod
+    async def set_create(self, event: StateEvent) -> None:
+        pass
+
     @abstractmethod
     async def has_encryption_info_cached(self, room_id: RoomID) -> bool:
         pass
@@ -135,7 +147,7 @@ async def get_encryption_info(self, room_id: RoomID) -> RoomEncryptionStateEvent
 
     @abstractmethod
     async def set_encryption_info(
-        self, room_id: RoomID, content: RoomEncryptionStateEventContent | dict[str, any]
+        self, room_id: RoomID, content: RoomEncryptionStateEventContent | dict[str, Any]
     ) -> None:
         pass
 
@@ -149,6 +161,8 @@ async def update_state(self, evt: StateEvent) -> None:
             await self.set_member(evt.room_id, UserID(evt.state_key), evt.content)
         elif evt.type == EventType.ROOM_ENCRYPTION:
             await self.set_encryption_info(evt.room_id, evt.content)
+        elif evt.type == EventType.ROOM_CREATE and evt.sender:
+            await self.set_create(evt)
 
     async def get_membership(self, room_id: RoomID, user_id: UserID) -> Membership:
         member = await self.get_member(room_id, user_id)
@@ -172,4 +186,7 @@ async def has_power_level(
         room_levels = await self.get_power_levels(room_id)
         if not room_levels:
             return None
-        return room_levels.get_user_level(user_id) >= room_levels.get_event_level(event_type)
+        create_event = await self.get_create(room_id)
+        return room_levels.get_user_level(user_id, create_event) >= room_levels.get_event_level(
+            event_type
+        )
diff --git a/mautrix/client/state_store/asyncpg/store.py b/mautrix/client/state_store/asyncpg/store.py
@@ -16,6 +16,7 @@
     RoomEncryptionStateEventContent,
     RoomID,
     Serializable,
+    StateEvent,
     UserID,
 )
 from mautrix.util.async_db import Database, Scheme
@@ -223,6 +224,29 @@ async def set_power_levels(
             json.dumps(content.serialize() if isinstance(content, Serializable) else content),
         )
 
+    async def has_create_cached(self, room_id: RoomID) -> bool:
+        return bool(
+            await self.db.fetchval(
+                "SELECT create_event IS NOT NULL FROM mx_room_state WHERE room_id=$1", room_id
+            )
+        )
+
+    async def get_create(self, room_id: RoomID) -> StateEvent | None:
+        create_event_json = await self.db.fetchval(
+            "SELECT create_event FROM mx_room_state WHERE room_id=$1", room_id
+        )
+        if create_event_json is None:
+            return None
+        return StateEvent.parse_json(create_event_json)
+
+    async def set_create(self, event: StateEvent) -> None:
+        await self.db.execute(
+            "INSERT INTO mx_room_state (room_id, create_event) VALUES ($1, $2) "
+            "ON CONFLICT (room_id) DO UPDATE SET create_event=$2",
+            event.room_id,
+            json.dumps(event.serialize() if isinstance(event, Serializable) else event),
+        )
+
     async def has_encryption_info_cached(self, room_id: RoomID) -> bool:
         return bool(
             await self.db.fetchval(
diff --git a/mautrix/client/state_store/asyncpg/upgrade.py b/mautrix/client/state_store/asyncpg/upgrade.py
@@ -14,15 +14,16 @@
 )
 
 
-@upgrade_table.register(description="Latest revision", upgrades_to=3)
-async def upgrade_blank_to_v3(conn: Connection, scheme: Scheme) -> None:
+@upgrade_table.register(description="Latest revision", upgrades_to=4)
+async def upgrade_blank_to_v4(conn: Connection, scheme: Scheme) -> None:
     await conn.execute(
         """CREATE TABLE mx_room_state (
             room_id              TEXT PRIMARY KEY,
             is_encrypted         BOOLEAN,
             has_full_member_list BOOLEAN,
             encryption           TEXT,
-            power_levels         TEXT
+            power_levels         TEXT,
+            create_event         TEXT,
         )"""
     )
     membership_check = ""
@@ -69,3 +70,8 @@ async def upgrade_v3(conn: Connection) -> None:
                 WHERE mx_room_state.encryption IS NULL
             """
         )
+
+
+@upgrade_table.register(description="Add create event to room state cache")
+async def upgrade_v4(conn: Connection) -> None:
+    await conn.execute("ALTER TABLE mx_room_state ADD COLUMN create_event TYPE TEXT")
diff --git a/mautrix/client/state_store/file.py b/mautrix/client/state_store/file.py
@@ -15,6 +15,7 @@
     PowerLevelStateEventContent,
     RoomEncryptionStateEventContent,
     RoomID,
+    StateEvent,
     UserID,
 )
 from mautrix.util.file_store import Filer, FileStore
@@ -65,3 +66,7 @@ async def set_power_levels(
     ) -> None:
         await super().set_power_levels(room_id, content)
         self._time_limited_flush()
+
+    async def set_create(self, event: StateEvent) -> None:
+        await super().set_create(event)
+        self._time_limited_flush()
diff --git a/mautrix/client/state_store/memory.py b/mautrix/client/state_store/memory.py
@@ -14,6 +14,7 @@
     PowerLevelStateEventContent,
     RoomEncryptionStateEventContent,
     RoomID,
+    StateEvent,
     UserID,
 )
 
@@ -25,19 +26,22 @@ class SerializedStateStore(TypedDict):
     full_member_list: dict[RoomID, bool]
     power_levels: dict[RoomID, Any]
     encryption: dict[RoomID, Any]
+    create: dict[RoomID, Any]
 
 
 class MemoryStateStore(StateStore):
     members: dict[RoomID, dict[UserID, Member]]
     full_member_list: dict[RoomID, bool]
     power_levels: dict[RoomID, PowerLevelStateEventContent]
     encryption: dict[RoomID, RoomEncryptionStateEventContent | None]
+    create: dict[RoomID, StateEvent]
 
     def __init__(self) -> None:
         self.members = {}
         self.full_member_list = {}
         self.power_levels = {}
         self.encryption = {}
+        self.create = {}
 
     def serialize(self) -> SerializedStateStore:
         """
@@ -58,6 +62,7 @@ def serialize(self) -> SerializedStateStore:
                 room_id: (content.serialize() if content is not None else None)
                 for room_id, content in self.encryption.items()
             },
+            "create": {room_id: evt.serialize() for room_id, evt in self.create.items()},
         }
 
     def deserialize(self, data: SerializedStateStore) -> None:
@@ -84,6 +89,9 @@ def deserialize(self, data: SerializedStateStore) -> None:
             )
             for room_id, content in data["encryption"].items()
         }
+        self.create = {
+            room_id: StateEvent.deserialize(evt) for room_id, evt in data["create"].items()
+        }
 
     async def get_member(self, room_id: RoomID, user_id: UserID) -> Member | None:
         try:
@@ -176,6 +184,17 @@ async def set_power_levels(
             content = PowerLevelStateEventContent.deserialize(content)
         self.power_levels[room_id] = content
 
+    async def has_create_cached(self, room_id: RoomID) -> bool:
+        return room_id in self.create
+
+    async def get_create(self, room_id: RoomID) -> StateEvent | None:
+        return self.create.get(room_id)
+
+    async def set_create(self, event: StateEvent | dict[str, Any]) -> None:
+        if not isinstance(event, StateEvent):
+            event = StateEvent.deserialize(event)
+        self.create[event.room_id] = event
+
     async def has_encryption_info_cached(self, room_id: RoomID) -> bool:
         return room_id in self.encryption
 
diff --git a/mautrix/client/store_updater.py b/mautrix/client/store_updater.py
@@ -5,6 +5,7 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from __future__ import annotations
 
+from typing import Literal
 import asyncio
 
 from mautrix.errors import MForbidden, MNotFound
@@ -196,20 +197,28 @@ async def send_state_event(
         return event_id
 
     async def get_state_event(
-        self, room_id: RoomID, event_type: EventType, state_key: str = ""
-    ) -> StateEventContent:
-        event = await super().get_state_event(room_id, event_type, state_key)
+        self,
+        room_id: RoomID,
+        event_type: EventType,
+        state_key: str = "",
+        *,
+        format: str = "content",
+    ) -> StateEventContent | StateEvent:
+        event = await super().get_state_event(room_id, event_type, state_key, format=format)
         if self.state_store:
-            fake_event = StateEvent(
-                type=event_type,
-                room_id=room_id,
-                event_id=EventID(""),
-                sender=UserID(""),
-                state_key=state_key,
-                timestamp=0,
-                content=event,
-            )
-            await self.state_store.update_state(fake_event)
+            if isinstance(event, StateEvent):
+                await self.state_store.update_state(event)
+            else:
+                fake_event = StateEvent(
+                    type=event_type,
+                    room_id=room_id,
+                    event_id=EventID(""),
+                    sender=UserID(""),
+                    state_key=state_key,
+                    timestamp=0,
+                    content=event,
+                )
+                await self.state_store.update_state(fake_event)
         return event
 
     async def get_joined_members(self, room_id: RoomID) -> dict[UserID, Member]:
diff --git a/mautrix/types/event/state.py b/mautrix/types/event/state.py
@@ -41,7 +41,19 @@ class PowerLevelStateEventContent(SerializableAttrs):
     ban: int = 50
     redact: int = 50
 
-    def get_user_level(self, user_id: UserID) -> int:
+    def get_user_level(
+        self,
+        user_id: UserID,
+        create: Optional["StateEvent"] = None,
+    ) -> int:
+        if (
+            create
+            and create.content.supports_creator_power
+            and (user_id == create.sender or user_id in (create.content.additional_creators or []))
+        ):
+            # This is really meant to be infinity, but involving floats would be annoying,
+            # so we use an integer larger than the maximum power level (2^53-1) instead.
+            return 2**60 - 1
         return int(self.users.get(user_id, self.users_default))
 
     def set_user_level(self, user_id: UserID, level: int) -> None:
@@ -50,7 +62,16 @@ def set_user_level(self, user_id: UserID, level: int) -> None:
         else:
             self.users[user_id] = level
 
-    def ensure_user_level(self, user_id: UserID, level: int) -> bool:
+    def ensure_user_level(
+        self, user_id: UserID, level: int, create: Optional["StateEvent"] = None
+    ) -> bool:
+        if (
+            create
+            and create.content.supports_creator_power
+            and (user_id == create.sender or user_id in (create.content.additional_creators or []))
+        ):
+            # Don't try to set creator power levels
+            return False
         if self.get_user_level(user_id) != level:
             self.set_user_level(user_id, level)
             return True
@@ -193,6 +214,24 @@ class RoomCreateStateEventContent(SerializableAttrs):
     federate: bool = field(json="m.federate", omit_default=True, default=True)
     predecessor: Optional[RoomPredecessor] = None
     type: Optional[RoomType] = None
+    additional_creators: Optional[List[UserID]] = None
+
+    @property
+    def supports_creator_power(self) -> bool:
+        return self.room_version not in (
+            "",
+            "1",
+            "2",
+            "3",
+            "4",
+            "5",
+            "6",
+            "7",
+            "8",
+            "9",
+            "10",
+            "11",
+        )
 
 
 @dataclass
