Bump ruma

src/database/key_value/globals.rs

@@ -5,7 +5,8 @@ use futures_util::{stream::FuturesUnordered, StreamExt};
 use ruma::{
     api::federation::discovery::{ServerSigningKeys, VerifyKey},
     signatures::Ed25519KeyPair,
-    DeviceId, MilliSecondsSinceUnixEpoch, ServerName, ServerSigningKeyId, UserId,
+    DeviceId, MilliSecondsSinceUnixEpoch, OwnedServerSigningKeyId, ServerName, ServerSigningKeyId,
+    UserId,
 };
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
@@ -163,7 +164,7 @@ impl service::globals::Data for KeyValueDatabase {
         &self,
         origin: &ServerName,
         new_keys: ServerSigningKeys,
-    ) -> Result<BTreeMap<Box<ServerSigningKeyId>, VerifyKey>> {
+    ) -> Result<BTreeMap<OwnedServerSigningKeyId, VerifyKey>> {
         // Not atomic, but this is not critical
         let signingkeys = self.server_signingkeys.get(origin.as_bytes())?;
 
@@ -202,7 +203,7 @@ impl service::globals::Data for KeyValueDatabase {
     fn signing_keys_for(
         &self,
         origin: &ServerName,
-    ) -> Result<BTreeMap<Box<ServerSigningKeyId>, VerifyKey>> {
+    ) -> Result<BTreeMap<OwnedServerSigningKeyId, VerifyKey>> {
         let signingkeys = self
             .server_signingkeys
             .get(origin.as_bytes())?

src/database/key_value/key_backups.rs

@@ -6,7 +6,7 @@ use ruma::{
         error::ErrorKind,
     },
     serde::Raw,
-    RoomId, UserId,
+    OwnedRoomId, RoomId, UserId,
 };
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
@@ -198,13 +198,13 @@ impl service::key_backups::Data for KeyValueDatabase {
         &self,
         user_id: &UserId,
         version: &str,
-    ) -> Result<BTreeMap<Box<RoomId>, RoomKeyBackup>> {
+    ) -> Result<BTreeMap<OwnedRoomId, RoomKeyBackup>> {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
         prefix.extend_from_slice(version.as_bytes());
         prefix.push(0xff);
 
-        let mut rooms = BTreeMap::<Box<RoomId>, RoomKeyBackup>::new();
+        let mut rooms = BTreeMap::<OwnedRoomId, RoomKeyBackup>::new();
 
         for result in self
             .backupkeyid_backup

src/database/key_value/rooms/alias.rs

@@ -1,4 +1,4 @@
-use ruma::{api::client::error::ErrorKind, RoomAliasId, RoomId};
+use ruma::{api::client::error::ErrorKind, OwnedRoomAliasId, OwnedRoomId, RoomAliasId, RoomId};
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
@@ -31,7 +31,7 @@ impl service::rooms::alias::Data for KeyValueDatabase {
         Ok(())
     }
 
-    fn resolve_local_alias(&self, alias: &RoomAliasId) -> Result<Option<Box<RoomId>>> {
+    fn resolve_local_alias(&self, alias: &RoomAliasId) -> Result<Option<OwnedRoomId>> {
         self.alias_roomid
             .get(alias.alias().as_bytes())?
             .map(|bytes| {
@@ -46,7 +46,7 @@ impl service::rooms::alias::Data for KeyValueDatabase {
     fn local_aliases_for_room<'a>(
         &'a self,
         room_id: &RoomId,
-    ) -> Box<dyn Iterator<Item = Result<Box<RoomAliasId>>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<OwnedRoomAliasId>> + 'a> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 

src/database/key_value/rooms/directory.rs

@@ -1,4 +1,4 @@
-use ruma::RoomId;
+use ruma::{OwnedRoomId, RoomId};
 
 use crate::{database::KeyValueDatabase, service, utils, Error, Result};
 
@@ -15,7 +15,7 @@ impl service::rooms::directory::Data for KeyValueDatabase {
         Ok(self.publicroomids.get(room_id.as_bytes())?.is_some())
     }
 
-    fn public_rooms<'a>(&'a self) -> Box<dyn Iterator<Item = Result<Box<RoomId>>> + 'a> {
+    fn public_rooms<'a>(&'a self) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a> {
         Box::new(self.publicroomids.iter().map(|(bytes, _)| {
             RoomId::parse(
                 utils::string_from_bytes(&bytes).map_err(|_| {

src/database/key_value/rooms/edus/presence.rs

@@ -1,6 +1,8 @@
 use std::collections::HashMap;
 
-use ruma::{events::presence::PresenceEvent, presence::PresenceState, RoomId, UInt, UserId};
+use ruma::{
+    events::presence::PresenceEvent, presence::PresenceState, OwnedUserId, RoomId, UInt, UserId,
+};
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
@@ -76,7 +78,7 @@ impl service::rooms::edus::presence::Data for KeyValueDatabase {
         &self,
         room_id: &RoomId,
         since: u64,
-    ) -> Result<HashMap<Box<UserId>, PresenceEvent>> {
+    ) -> Result<HashMap<OwnedUserId, PresenceEvent>> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 

src/database/key_value/rooms/edus/read_receipt.rs

@@ -1,7 +1,7 @@
 use std::mem;
 
 use ruma::{
-    events::receipt::ReceiptEvent, serde::Raw, signatures::CanonicalJsonObject, RoomId, UserId,
+    events::receipt::ReceiptEvent, serde::Raw, CanonicalJsonObject, OwnedUserId, RoomId, UserId,
 };
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
@@ -55,7 +55,7 @@ impl service::rooms::edus::read_receipt::Data for KeyValueDatabase {
     ) -> Box<
         dyn Iterator<
                 Item = Result<(
-                    Box<UserId>,
+                    OwnedUserId,
                     u64,
                     Raw<ruma::events::AnySyncEphemeralRoomEvent>,
                 )>,

src/database/key_value/rooms/edus/typing.rs

@@ -1,6 +1,6 @@
 use std::collections::HashSet;
 
-use ruma::{RoomId, UserId};
+use ruma::{OwnedUserId, RoomId, UserId};
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
@@ -66,7 +66,7 @@ impl service::rooms::edus::typing::Data for KeyValueDatabase {
             .unwrap_or(0))
     }
 
-    fn typings_all(&self, room_id: &RoomId) -> Result<HashSet<Box<UserId>>> {
+    fn typings_all(&self, room_id: &RoomId) -> Result<HashSet<OwnedUserId>> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 

src/database/key_value/rooms/metadata.rs

@@ -1,4 +1,4 @@
-use ruma::RoomId;
+use ruma::{OwnedRoomId, RoomId};
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
@@ -18,7 +18,7 @@ impl service::rooms::metadata::Data for KeyValueDatabase {
             .is_some())
     }
 
-    fn iter_ids<'a>(&'a self) -> Box<dyn Iterator<Item = Result<Box<RoomId>>> + 'a> {
+    fn iter_ids<'a>(&'a self) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a> {
         Box::new(self.roomid_shortroomid.iter().map(|(bytes, _)| {
             RoomId::parse(
                 utils::string_from_bytes(&bytes).map_err(|_| {

src/database/key_value/rooms/outlier.rs

@@ -1,4 +1,4 @@
-use ruma::{signatures::CanonicalJsonObject, EventId};
+use ruma::{CanonicalJsonObject, EventId};
 
 use crate::{database::KeyValueDatabase, service, Error, PduEvent, Result};
 

src/database/key_value/rooms/state.rs

@@ -1,4 +1,4 @@
-use ruma::{EventId, RoomId};
+use ruma::{EventId, OwnedEventId, RoomId};
 use std::collections::HashSet;
 
 use std::sync::Arc;
@@ -52,7 +52,7 @@ impl service::rooms::state::Data for KeyValueDatabase {
     fn set_forward_extremities<'a>(
         &self,
         room_id: &RoomId,
-        event_ids: Vec<Box<EventId>>,
+        event_ids: Vec<OwnedEventId>,
         _mutex_lock: &MutexGuard<'_, ()>, // Take mutex guard to make sure users get the room state mutex
     ) -> Result<()> {
         let mut prefix = room_id.as_bytes().to_vec();

src/database/key_value/rooms/state_cache.rs

@@ -4,7 +4,7 @@ use regex::Regex;
 use ruma::{
     events::{AnyStrippedStateEvent, AnySyncStateEvent},
     serde::Raw,
-    RoomId, ServerName, UserId,
+    OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, ServerName, UserId,
 };
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
@@ -163,7 +163,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     }
 
     #[tracing::instrument(skip(self, room_id))]
-    fn get_our_real_users(&self, room_id: &RoomId) -> Result<Arc<HashSet<Box<UserId>>>> {
+    fn get_our_real_users(&self, room_id: &RoomId) -> Result<Arc<HashSet<OwnedUserId>>> {
         let maybe = self
             .our_real_users_cache
             .read()
@@ -262,7 +262,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     fn room_servers<'a>(
         &'a self,
         room_id: &RoomId,
-    ) -> Box<dyn Iterator<Item = Result<Box<ServerName>>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<OwnedServerName>> + 'a> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -295,7 +295,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     fn server_rooms<'a>(
         &'a self,
         server: &ServerName,
-    ) -> Box<dyn Iterator<Item = Result<Box<RoomId>>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a> {
         let mut prefix = server.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -317,7 +317,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     fn room_members<'a>(
         &'a self,
         room_id: &RoomId,
-    ) -> Box<dyn Iterator<Item = Result<Box<UserId>>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<OwnedUserId>> + 'a> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -363,7 +363,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     fn room_useroncejoined<'a>(
         &'a self,
         room_id: &RoomId,
-    ) -> Box<dyn Iterator<Item = Result<Box<UserId>>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<OwnedUserId>> + 'a> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -393,7 +393,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     fn room_members_invited<'a>(
         &'a self,
         room_id: &RoomId,
-    ) -> Box<dyn Iterator<Item = Result<Box<UserId>>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<OwnedUserId>> + 'a> {
         let mut prefix = room_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -451,7 +451,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     fn rooms_joined<'a>(
         &'a self,
         user_id: &UserId,
-    ) -> Box<dyn Iterator<Item = Result<Box<RoomId>>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a> {
         Box::new(
             self.userroomid_joined
                 .scan_prefix(user_id.as_bytes().to_vec())
@@ -476,7 +476,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     fn rooms_invited<'a>(
         &'a self,
         user_id: &UserId,
-    ) -> Box<dyn Iterator<Item = Result<(Box<RoomId>, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a> {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
 
@@ -554,7 +554,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     fn rooms_left<'a>(
         &'a self,
         user_id: &UserId,
-    ) -> Box<dyn Iterator<Item = Result<(Box<RoomId>, Vec<Raw<AnySyncStateEvent>>)>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnySyncStateEvent>>)>> + 'a> {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
 

src/database/key_value/rooms/timeline.rs

@@ -1,7 +1,7 @@
 use std::{collections::hash_map, mem::size_of, sync::Arc};
 
 use ruma::{
-    api::client::error::ErrorKind, signatures::CanonicalJsonObject, EventId, RoomId, UserId,
+    api::client::error::ErrorKind, CanonicalJsonObject, EventId, OwnedUserId, RoomId, UserId,
 };
 use tracing::error;
 
@@ -344,8 +344,8 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
     fn increment_notification_counts(
         &self,
         room_id: &RoomId,
-        notifies: Vec<Box<UserId>>,
-        highlights: Vec<Box<UserId>>,
+        notifies: Vec<OwnedUserId>,
+        highlights: Vec<OwnedUserId>,
     ) -> Result<()> {
         let mut notifies_batch = Vec::new();
         let mut highlights_batch = Vec::new();

src/database/key_value/rooms/user.rs

@@ -1,4 +1,4 @@
-use ruma::{RoomId, UserId};
+use ruma::{OwnedRoomId, OwnedUserId, RoomId, UserId};
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
@@ -85,8 +85,8 @@ impl service::rooms::user::Data for KeyValueDatabase {
 
     fn get_shared_rooms<'a>(
         &'a self,
-        users: Vec<Box<UserId>>,
-    ) -> Result<Box<dyn Iterator<Item = Result<Box<RoomId>>> + 'a>> {
+        users: Vec<OwnedUserId>,
+    ) -> Result<Box<dyn Iterator<Item = Result<OwnedRoomId>> + 'a>> {
         let iterators = users.into_iter().map(move |user_id| {
             let mut prefix = user_id.as_bytes().to_vec();
             prefix.push(0xff);
@@ -110,7 +110,7 @@ impl service::rooms::user::Data for KeyValueDatabase {
         });
 
         // We use the default compare function because keys are sorted correctly (not reversed)
-        Ok(Box::new(Box::new(
+        Ok(Box::new(
             utils::common_elements(iterators, Ord::cmp)
                 .expect("users is not empty")
                 .map(|bytes| {
@@ -119,6 +119,6 @@ impl service::rooms::user::Data for KeyValueDatabase {
                     })?)
                     .map_err(|_| Error::bad_database("Invalid RoomId in userroomid_joined."))
                 }),
-        )))
+        ))
     }
 }

src/database/key_value/uiaa.rs

@@ -1,7 +1,6 @@
 use ruma::{
     api::client::{error::ErrorKind, uiaa::UiaaInfo},
-    signatures::CanonicalJsonValue,
-    DeviceId, UserId,
+    CanonicalJsonValue, DeviceId, UserId,
 };
 
 use crate::{database::KeyValueDatabase, service, Error, Result};

src/database/key_value/users.rs

@@ -5,8 +5,10 @@ use ruma::{
     encryption::{CrossSigningKey, DeviceKeys, OneTimeKey},
     events::{AnyToDeviceEvent, StateEventType},
     serde::Raw,
-    DeviceId, DeviceKeyAlgorithm, DeviceKeyId, MilliSecondsSinceUnixEpoch, MxcUri, UInt, UserId,
+    DeviceId, DeviceKeyAlgorithm, DeviceKeyId, MilliSecondsSinceUnixEpoch, MxcUri, OwnedUserId,
+    UInt, UserId,
 };
+use ruma::{OwnedDeviceId, OwnedDeviceKeyId, OwnedMxcUri};
 use tracing::warn;
 
 use crate::{
@@ -39,7 +41,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Find out which user an access token belongs to.
-    fn find_from_token(&self, token: &str) -> Result<Option<(Box<UserId>, String)>> {
+    fn find_from_token(&self, token: &str) -> Result<Option<(OwnedUserId, String)>> {
         self.token_userdeviceid
             .get(token.as_bytes())?
             .map_or(Ok(None), |bytes| {
@@ -66,7 +68,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Returns an iterator over all users on this homeserver.
-    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = Result<Box<UserId>>> + 'a> {
+    fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = Result<OwnedUserId>> + 'a> {
         Box::new(self.userid_password.iter().map(|(bytes, _)| {
             UserId::parse(utils::string_from_bytes(&bytes).map_err(|_| {
                 Error::bad_database("User ID in userid_password is invalid unicode.")
@@ -141,7 +143,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Get the avatar_url of a user.
-    fn avatar_url(&self, user_id: &UserId) -> Result<Option<Box<MxcUri>>> {
+    fn avatar_url(&self, user_id: &UserId) -> Result<Option<OwnedMxcUri>> {
         self.userid_avatarurl
             .get(user_id.as_bytes())?
             .map(|bytes| {
@@ -154,7 +156,7 @@ impl service::users::Data for KeyValueDatabase {
     }
 
     /// Sets a new avatar_url or removes it if avatar_url is None.
-    fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option<Box<MxcUri>>) -> Result<()> {
+    fn set_avatar_url(&self, user_id: &UserId, avatar_url: Option<OwnedMxcUri>) -> Result<()> {
         if let Some(avatar_url) = avatar_url {
             self.userid_avatarurl
                 .insert(user_id.as_bytes(), avatar_url.to_string().as_bytes())?;
@@ -258,7 +260,7 @@ impl service::users::Data for KeyValueDatabase {
     fn all_device_ids<'a>(
         &'a self,
         user_id: &UserId,
-    ) -> Box<dyn Iterator<Item = Result<Box<DeviceId>>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<OwnedDeviceId>> + 'a> {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
         // All devices have metadata
@@ -356,7 +358,7 @@ impl service::users::Data for KeyValueDatabase {
         user_id: &UserId,
         device_id: &DeviceId,
         key_algorithm: &DeviceKeyAlgorithm,
-    ) -> Result<Option<(Box<DeviceKeyId>, Raw<OneTimeKey>)>> {
+    ) -> Result<Option<(OwnedDeviceKeyId, Raw<OneTimeKey>)>> {
         let mut prefix = user_id.as_bytes().to_vec();
         prefix.push(0xff);
         prefix.extend_from_slice(device_id.as_bytes());
@@ -407,7 +409,7 @@ impl service::users::Data for KeyValueDatabase {
                 .scan_prefix(userdeviceid)
                 .map(|(bytes, _)| {
                     Ok::<_, Error>(
-                        serde_json::from_slice::<Box<DeviceKeyId>>(
+                        serde_json::from_slice::<OwnedDeviceKeyId>(
                             &*bytes.rsplit(|&b| b == 0xff).next().ok_or_else(|| {
                                 Error::bad_database("OneTimeKey ID in db is invalid.")
                             })?,
@@ -579,7 +581,7 @@ impl service::users::Data for KeyValueDatabase {
             .ok_or_else(|| Error::bad_database("key in keyid_key has no signatures field."))?
             .as_object_mut()
             .ok_or_else(|| Error::bad_database("key in keyid_key has invalid signatures field."))?
-            .entry(sender_id.to_owned())
+            .entry(sender_id.to_string())
             .or_insert_with(|| serde_json::Map::new().into());
 
         signatures
@@ -603,7 +605,7 @@ impl service::users::Data for KeyValueDatabase {
         user_or_room_id: &str,
         from: u64,
         to: Option<u64>,
-    ) -> Box<dyn Iterator<Item = Result<Box<UserId>>> + 'a> {
+    ) -> Box<dyn Iterator<Item = Result<OwnedUserId>> + 'a> {
         let mut prefix = user_or_room_id.as_bytes().to_vec();
         prefix.push(0xff);
 

src/database/mod.rs

@@ -6,13 +6,17 @@ use abstraction::KeyValueDatabaseEngine;
 use abstraction::KvTree;
 use directories::ProjectDirs;
 use lru_cache::LruCache;
+use ruma::CanonicalJsonValue;
+use ruma::OwnedDeviceId;
+use ruma::OwnedEventId;
+use ruma::OwnedRoomId;
+use ruma::OwnedUserId;
 use ruma::{
     events::{
         push_rules::PushRulesEventContent, room::message::RoomMessageEventContent,
         GlobalAccountDataEvent, GlobalAccountDataEventType, StateEventType,
     },
     push::Ruleset,
-    signatures::CanonicalJsonValue,
     DeviceId, EventId, RoomId, UserId,
 };
 use std::{
@@ -58,7 +62,7 @@ pub struct KeyValueDatabase {
     //pub uiaa: uiaa::Uiaa,
     pub(super) userdevicesessionid_uiaainfo: Arc<dyn KvTree>, // User-interactive authentication
     pub(super) userdevicesessionid_uiaarequest:
-        RwLock<BTreeMap<(Box<UserId>, Box<DeviceId>, String), CanonicalJsonValue>>,
+        RwLock<BTreeMap<(OwnedUserId, OwnedDeviceId, String), CanonicalJsonValue>>,
 
     //pub edus: RoomEdus,
     pub(super) readreceiptid_readreceipt: Arc<dyn KvTree>, // ReadReceiptId = RoomId + Count + UserId
@@ -152,15 +156,15 @@ pub struct KeyValueDatabase {
     pub(super) senderkey_pusher: Arc<dyn KvTree>,
 
     pub(super) cached_registrations: Arc<RwLock<HashMap<String, serde_yaml::Value>>>,
-    pub(super) pdu_cache: Mutex<LruCache<Box<EventId>, Arc<PduEvent>>>,
+    pub(super) pdu_cache: Mutex<LruCache<OwnedEventId, Arc<PduEvent>>>,
     pub(super) shorteventid_cache: Mutex<LruCache<u64, Arc<EventId>>>,
     pub(super) auth_chain_cache: Mutex<LruCache<Vec<u64>, Arc<HashSet<u64>>>>,
-    pub(super) eventidshort_cache: Mutex<LruCache<Box<EventId>, u64>>,
+    pub(super) eventidshort_cache: Mutex<LruCache<OwnedEventId, u64>>,
     pub(super) statekeyshort_cache: Mutex<LruCache<(StateEventType, String), u64>>,
     pub(super) shortstatekey_cache: Mutex<LruCache<u64, (StateEventType, String)>>,
-    pub(super) our_real_users_cache: RwLock<HashMap<Box<RoomId>, Arc<HashSet<Box<UserId>>>>>,
-    pub(super) appservice_in_room_cache: RwLock<HashMap<Box<RoomId>, HashMap<String, bool>>>,
-    pub(super) lasttimelinecount_cache: Mutex<HashMap<Box<RoomId>, u64>>,
+    pub(super) our_real_users_cache: RwLock<HashMap<OwnedRoomId, Arc<HashSet<OwnedUserId>>>>,
+    pub(super) appservice_in_room_cache: RwLock<HashMap<OwnedRoomId, HashMap<String, bool>>>,
+    pub(super) lasttimelinecount_cache: Mutex<HashMap<OwnedRoomId, u64>>,
 }
 
 impl KeyValueDatabase {
@@ -531,7 +535,7 @@ impl KeyValueDatabase {
 
             if services().globals.database_version()? < 7 {
                 // Upgrade state store
-                let mut last_roomstates: HashMap<Box<RoomId>, u64> = HashMap::new();
+                let mut last_roomstates: HashMap<OwnedRoomId, u64> = HashMap::new();
                 let mut current_sstatehash: Option<u64> = None;
                 let mut current_room = None;
                 let mut current_state = HashSet::new();