Hoist room_version query to callers of get_auth_chain.

Signed-off-by: Jason Volk <jason@zemos.net>

src/api/server/event_auth.rs

@@ -46,22 +46,18 @@ pub(crate) async fn get_event_authorization_route(
 	let room_id = <&RoomId>::try_from(room_id_str)
 		.map_err(|_| Error::bad_database("Invalid room_id in event in database."))?;
 
-	let room_version = services
-		.state
-		.get_room_version(room_id)
-		.await
-		.ok();
+	let room_version = services.state.get_room_version(room_id).await?;
 
 	let auth_chain = services
 		.auth_chain
-		.event_ids_iter(room_id, once(body.event_id.borrow()))
+		.event_ids_iter(room_id, &room_version, once(body.event_id.borrow()))
 		.ready_filter_map(Result::ok)
 		.broad_filter_map(async |id| {
 			let pdu = services.timeline.get_pdu_json(&id).await.ok()?;
 
 			let pdu = services
 				.federation
-				.format_pdu_into(pdu, room_version.as_ref())
+				.format_pdu_into(pdu, Some(&room_version))
 				.await;
 
 			Some(pdu)

src/api/server/send_join.rs

@@ -50,9 +50,9 @@ async fn create_join_event(
 
 	// We do not add the event_id field to the pdu here because of signature and
 	// hashes checks
-	let room_version_id = services.state.get_room_version(room_id).await?;
+	let room_version = services.state.get_room_version(room_id).await?;
 
-	let Ok((event_id, mut value)) = gen_event_id_canonical_json(pdu, &room_version_id) else {
+	let Ok((event_id, mut value)) = gen_event_id_canonical_json(pdu, &room_version) else {
 		// Event could not be converted to canonical json
 		return Err!(Request(BadJson("Could not convert event to canonical json.")));
 	};
@@ -136,9 +136,9 @@ async fn create_join_event(
 	if let Some(authorising_user) = content.join_authorized_via_users_server {
 		use ruma::RoomVersionId::*;
 
-		if matches!(room_version_id, V1 | V2 | V3 | V4 | V5 | V6 | V7) {
+		if matches!(room_version, V1 | V2 | V3 | V4 | V5 | V6 | V7) {
 			return Err!(Request(InvalidParam(
-				"Room version {room_version_id} does not support restricted rooms but \
+				"Room version {room_version} does not support restricted rooms but \
 				 join_authorised_via_users_server ({authorising_user}) was found in the event."
 			)));
 		}
@@ -161,13 +161,8 @@ async fn create_join_event(
 			)));
 		}
 
-		if !super::user_can_perform_restricted_join(
-			services,
-			&state_key,
-			room_id,
-			&room_version_id,
-		)
-		.await?
+		if !super::user_can_perform_restricted_join(services, &state_key, room_id, &room_version)
+			.await?
 		{
 			return Err!(Request(UnableToAuthorizeJoin(
 				"Joining user did not pass restricted room's rules."
@@ -177,7 +172,7 @@ async fn create_join_event(
 
 	services
 		.server_keys
-		.hash_and_sign_event(&mut value, &room_version_id)
+		.hash_and_sign_event(&mut value, &room_version)
 		.map_err(|e| err!(Request(InvalidParam(warn!("Failed to sign send_join event: {e}")))))?;
 
 	let origin: OwnedServerName = serde_json::from_value(
@@ -216,7 +211,7 @@ async fn create_join_event(
 	// Join event for new server.
 	let event = services
 		.federation
-		.format_pdu_into(value, Some(&room_version_id))
+		.format_pdu_into(value, Some(&room_version))
 		.map(Some)
 		.map(Ok);
 
@@ -229,13 +224,13 @@ async fn create_join_event(
 	let into_federation_format = |pdu| {
 		services
 			.federation
-			.format_pdu_into(pdu, Some(&room_version_id))
+			.format_pdu_into(pdu, Some(&room_version))
 			.map(Ok)
 	};
 
 	let auth_chain = services
 		.auth_chain
-		.event_ids_iter(room_id, auth_heads)
+		.event_ids_iter(room_id, &room_version, auth_heads)
 		.broad_and_then(async |event_id| {
 			services
 				.timeline

src/api/server/state.rs

@@ -1,17 +1,11 @@
 use std::{borrow::Borrow, iter::once};
 
 use axum::extract::State;
-use futures::{
-	FutureExt, StreamExt, TryFutureExt, TryStreamExt,
-	future::{join, try_join},
-};
+use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, future::try_join};
 use ruma::{OwnedEventId, api::federation::event::get_room_state};
 use tuwunel_core::{
 	Result, at, err,
-	utils::{
-		future::TryExtExt,
-		stream::{IterStream, TryBroadbandExt},
-	},
+	utils::stream::{IterStream, TryBroadbandExt},
 };
 
 use super::AccessCheck;
@@ -43,25 +37,23 @@ pub(crate) async fn get_room_state_route(
 		.state_accessor
 		.state_full_ids(shortstatehash)
 		.map(at!(1))
-		.collect::<Vec<OwnedEventId>>();
+		.collect::<Vec<OwnedEventId>>()
+		.map(Ok);
 
-	let room_version = services
-		.state
-		.get_room_version(&body.room_id)
-		.ok();
+	let room_version = services.state.get_room_version(&body.room_id);
 
-	let (room_version, state_ids) = join(room_version, state_ids).await;
+	let (room_version, state_ids) = try_join(room_version, state_ids).await?;
 
 	let into_federation_format = |pdu| {
 		services
 			.federation
-			.format_pdu_into(pdu, room_version.as_ref())
+			.format_pdu_into(pdu, Some(&room_version))
 			.map(Ok)
 	};
 
 	let auth_chain = services
 		.auth_chain
-		.event_ids_iter(&body.room_id, once(body.event_id.borrow()))
+		.event_ids_iter(&body.room_id, &room_version, once(body.event_id.borrow()))
 		.broad_and_then(async |id| {
 			services
 				.timeline

src/api/server/state_ids.rs

@@ -1,7 +1,7 @@
 use std::{borrow::Borrow, iter::once};
 
 use axum::extract::State;
-use futures::{FutureExt, StreamExt, TryStreamExt, future::try_join};
+use futures::{FutureExt, StreamExt, TryFutureExt, TryStreamExt, future::try_join};
 use ruma::{OwnedEventId, api::federation::event::get_room_state_ids};
 use tuwunel_core::{Result, at, err};
 
@@ -28,12 +28,15 @@ pub(crate) async fn get_room_state_ids_route(
 	let shortstatehash = services
 		.state
 		.pdu_shortstatehash(&body.event_id)
-		.await
-		.map_err(|_| err!(Request(NotFound("Pdu state not found."))))?;
+		.map_err(|_| err!(Request(NotFound("Pdu state not found."))));
+
+	let room_version = services.state.get_room_version(&body.room_id);
+
+	let (shortstatehash, room_version) = try_join(shortstatehash, room_version).await?;
 
 	let auth_chain_ids = services
 		.auth_chain
-		.event_ids_iter(&body.room_id, once(body.event_id.borrow()))
+		.event_ids_iter(&body.room_id, &room_version, once(body.event_id.borrow()))
 		.try_collect();
 
 	let pdu_ids = services