diff --git a/src/api/client/membership/invite.rs b/src/api/client/membership/invite.rs
index 1d8a3f2a5..fd44c68f0 100644
--- a/src/api/client/membership/invite.rs
+++ b/src/api/client/membership/invite.rs
@@ -163,15 +163,7 @@ pub(crate) async fn invite_helper(
 				)
 				.await?;
 
-			#[allow(deprecated)]
-			let invite_room_state = services
-				.rooms
-				.state
-				.summary_stripped(&pdu, room_id)
-				.await
-				.into_iter()
-				.map(|event| RawStrippedState::Stripped(event))
-				.collect();
+			let invite_room_state = services.rooms.state.summary_stripped(&pdu, room_id).await;
 
 			drop(state_lock);
 
diff --git a/src/api/router.rs b/src/api/router.rs
index d14a04709..d8fad39b4 100644
--- a/src/api/router.rs
+++ b/src/api/router.rs
@@ -210,8 +210,9 @@ pub fn build(router: Router<State>, server: &Server) -> Router<State> {
 			.ruma_route(&server::get_room_state_ids_route)
 			.ruma_route(&server::create_leave_event_template_route)
 			.ruma_route(&server::create_knock_event_template_route)
-			.ruma_route(&server::create_leave_event_v2_route)
 			.ruma_route(&server::create_join_event_template_route)
+			.ruma_route(&server::create_leave_event_v2_route)
+			.ruma_route(&server::create_knock_event_v1_route)
 			.ruma_route(&server::create_join_event_v2_route)
 			.ruma_route(&server::create_invite_route)
 			.ruma_route(&server::get_devices_route)
diff --git a/src/api/server/send_knock.rs b/src/api/server/send_knock.rs
index a93c581f2..8d55e0748 100644
--- a/src/api/server/send_knock.rs
+++ b/src/api/server/send_knock.rs
@@ -7,8 +7,7 @@
 use futures::FutureExt;
 use ruma::{
 	OwnedUserId,
-	RoomVersionId::*,
-	api::federation::knock::send_knock,
+	api::federation::membership::create_knock_event,
 	events::{
 		StateEventType,
 		room::member::{MembershipState, RoomMemberEventContent},
@@ -23,8 +22,8 @@
 /// Submits a signed knock event.
 pub(crate) async fn create_knock_event_v1_route(
 	State(services): State<crate::State>,
-	body: Ruma<send_knock::v1::Request>,
-) -> Result<send_knock::v1::Response> {
+	body: Ruma<create_knock_event::v1::Request>,
+) -> Result<create_knock_event::v1::Response> {
 	if services
 		.moderation
 		.is_remote_server_forbidden(body.origin())
@@ -74,13 +73,15 @@ pub(crate) async fn create_knock_event_v1_route(
 		.acl_check(body.origin(), &body.room_id)
 		.await?;
 
-	let room_version_id = services.rooms.state.get_room_version(&body.room_id).await?;
+	let room_version = services.rooms.state.get_room_version(&body.room_id).await?;
+	let room_version_rules = room_version.rules().unwrap();
 
-	if matches!(room_version_id, V1 | V2 | V3 | V4 | V5 | V6) {
+	if !room_version_rules.authorization.knocking {
 		return Err!(Request(Forbidden("Room version does not support knocking.")));
 	}
 
-	let Ok((event_id, value)) = gen_event_id_canonical_json(&body.pdu, &room_version_id) else {
+	let Ok((event_id, value)) = gen_event_id_canonical_json(&body.pdu, &room_version_rules)
+	else {
 		// Event could not be converted to canonical json
 		return Err!(Request(InvalidParam("Could not convert event to canonical json.")));
 	};
@@ -161,7 +162,7 @@ pub(crate) async fn create_knock_event_v1_route(
 		.rooms
 		.event_handler
 		.mutex_federation
-		.lock(&body.room_id)
+		.lock(body.room_id.as_str())
 		.await;
 
 	let pdu_id = services
@@ -185,5 +186,5 @@ pub(crate) async fn create_knock_event_v1_route(
 		.summary_stripped(&pdu, &body.room_id)
 		.await;
 
-	Ok(send_knock::v1::Response { knock_room_state })
+	Ok(create_knock_event::v1::Response::new(knock_room_state))
 }
diff --git a/src/service/rooms/state/mod.rs b/src/service/rooms/state/mod.rs
index d89ca5604..9309977f0 100644
--- a/src/service/rooms/state/mod.rs
+++ b/src/service/rooms/state/mod.rs
@@ -1,4 +1,4 @@
-use std::{collections::HashMap, fmt::Write, iter::once, sync::Arc};
+use std::{collections::HashMap, fmt::Write, sync::Arc};
 
 use async_trait::async_trait;
 use conduwuit::debug;
@@ -18,12 +18,9 @@
 };
 use ruma::{
 	EventId, OwnedEventId, OwnedRoomId, RoomId, RoomVersionId, UserId,
-	events::{
-		AnyStrippedStateEvent, StateEventType, TimelineEventType,
-		room::create::RoomCreateEventContent,
-	},
+	api::federation::membership::RawStrippedState,
+	events::{StateEventType, TimelineEventType, room::create::RoomCreateEventContent},
 	room_version_rules::RoomVersionRules,
-	serde::Raw,
 };
 
 use crate::{
@@ -303,7 +300,7 @@ pub async fn summary_stripped<'a, E>(
 		&self,
 		event: &'a E,
 		room_id: &RoomId,
-	) -> Vec<Raw<AnyStrippedStateEvent>>
+	) -> Vec<RawStrippedState>
 	where
 		E: Event + Send + Sync,
 		&'a E: Event + Send,
@@ -329,8 +326,7 @@ pub async fn summary_stripped<'a, E>(
 			.await
 			.into_iter()
 			.filter_map(Result::ok)
-			.map(Event::into_format)
-			.chain(once(event.to_format()))
+			.map(|pdu| RawStrippedState::Pdu(pdu.content))
 			.collect()
 	}
 
diff --git a/src/service/rooms/state_cache/update.rs b/src/service/rooms/state_cache/update.rs
index ae842c526..fafcd32bd 100644
--- a/src/service/rooms/state_cache/update.rs
+++ b/src/service/rooms/state_cache/update.rs
@@ -119,15 +119,7 @@ pub async fn update_membership(
 			self.mark_as_joined(user_id, room_id);
 		},
 		| MembershipState::Invite => {
-			#[allow(deprecated)]
-			let last_state = self
-				.services
-				.state
-				.summary_stripped(pdu, room_id)
-				.await
-				.into_iter()
-				.map(RawStrippedState::Stripped)
-				.collect();
+			let last_state = self.services.state.summary_stripped(pdu, room_id).await;
 
 			self.mark_as_invited(user_id, room_id, pdu.sender(), last_state, None)
 				.await?;