Make senderID query use only roomID

appservice/consumers/roomserver.go

@@ -181,8 +181,8 @@ func (s *OutputRoomEventConsumer) sendEvents(
 	// Create the transaction body.
 	transaction, err := json.Marshal(
 		ApplicationServiceTransaction{
-			Events: synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(events), synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			Events: synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(events), synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-				return s.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+				return s.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 			}),
 		},
 	)

clientapi/routing/directory.go

@@ -189,7 +189,7 @@ func SetLocalAlias(
 		}
 	}
 
-	deviceSenderID, err := rsAPI.QuerySenderIDForUser(req.Context(), alias, *userID)
+	deviceSenderID, err := rsAPI.QuerySenderIDForUser(req.Context(), r.RoomID, *userID)
 	if err != nil {
 		return util.JSONResponse{
 			Code: http.StatusInternalServerError,
@@ -238,7 +238,17 @@ func RemoveLocalAlias(
 		}
 	}
 
-	deviceSenderID, err := rsAPI.QuerySenderIDForUser(req.Context(), alias, *userID)
+	roomIDReq := roomserverAPI.GetRoomIDForAliasRequest{Alias: alias}
+	roomIDRes := roomserverAPI.GetRoomIDForAliasResponse{}
+	err = rsAPI.GetRoomIDForAlias(req.Context(), &roomIDReq, &roomIDRes)
+	if err != nil {
+		return util.JSONResponse{
+			Code: http.StatusNotFound,
+			JSON: spec.NotFound("The alias does not exist."),
+		}
+	}
+
+	deviceSenderID, err := rsAPI.QuerySenderIDForUser(req.Context(), roomIDRes.RoomID, *userID)
 	if err != nil {
 		return util.JSONResponse{
 			Code: http.StatusInternalServerError,

clientapi/routing/sendevent.go

@@ -331,8 +331,8 @@ func generateSendEvent(
 		stateEvents[i] = queryRes.StateEvents[i].PDU
 	}
 	provider := gomatrixserverlib.NewAuthEvents(gomatrixserverlib.ToPDUs(stateEvents))
-	if err = gomatrixserverlib.Allowed(e.PDU, &provider, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	if err = gomatrixserverlib.Allowed(e.PDU, &provider, func(roomID, senderID string) (*spec.UserID, error) {
-		return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+		return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 	}); err != nil {
 		return nil, &util.JSONResponse{
 			Code: http.StatusForbidden,

clientapi/routing/state.go

@@ -142,8 +142,8 @@ func OnIncomingStateRequest(ctx context.Context, device *userapi.Device, rsAPI a
 		for _, ev := range stateRes.StateEvents {
 			stateEvents = append(
 				stateEvents,
-				synctypes.ToClientEvent(ev, synctypes.FormatAll, func(roomAliasOrID string, senderID string) (*spec.UserID, error) {
+				synctypes.ToClientEvent(ev, synctypes.FormatAll, func(roomID string, senderID string) (*spec.UserID, error) {
-					return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+					return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 				}),
 			)
 		}
@@ -166,8 +166,8 @@ func OnIncomingStateRequest(ctx context.Context, device *userapi.Device, rsAPI a
 		for _, ev := range stateAfterRes.StateEvents {
 			stateEvents = append(
 				stateEvents,
-				synctypes.ToClientEvent(ev, synctypes.FormatAll, func(roomAliasOrID string, senderID string) (*spec.UserID, error) {
+				synctypes.ToClientEvent(ev, synctypes.FormatAll, func(roomID string, senderID string) (*spec.UserID, error) {
-					return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+					return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 				}),
 			)
 		}
@@ -339,8 +339,8 @@ func OnIncomingStateTypeRequest(
 	}
 
 	stateEvent := stateEventInStateResp{
-		ClientEvent: synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomAliasOrID string, senderID string) (*spec.UserID, error) {
+		ClientEvent: synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomID string, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		}),
 	}
 

cmd/resolve-state/main.go

@@ -183,8 +183,8 @@ func main() {
 	fmt.Println("Resolving state")
 	var resolved Events
 	resolved, err = gomatrixserverlib.ResolveConflicts(
-		gomatrixserverlib.RoomVersion(*roomVersion), events, authEvents, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		gomatrixserverlib.RoomVersion(*roomVersion), events, authEvents, func(roomID, senderID string) (*spec.UserID, error) {
-			return roomserverDB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+			return roomserverDB.GetUserIDForSender(ctx, roomID, senderID)
 		},
 	)
 	if err != nil {

federationapi/federationapi_test.go

@@ -36,7 +36,7 @@ type fedRoomserverAPI struct {
 	queryRoomsForUser func(ctx context.Context, req *rsapi.QueryRoomsForUserRequest, res *rsapi.QueryRoomsForUserResponse) error
 }
 
-func (f *fedRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func (f *fedRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 

federationapi/internal/perform.go

@@ -164,11 +164,11 @@ func (r *FederationInternalAPI) performJoinUsingServer(
 		PrivateKey: r.cfg.Matrix.PrivateKey,
 		KeyID:      r.cfg.Matrix.KeyID,
 		KeyRing:    r.keyRing,
-		EventProvider: federatedEventProvider(ctx, r.federation, r.keyRing, user.Domain(), serverName, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		EventProvider: federatedEventProvider(ctx, r.federation, r.keyRing, user.Domain(), serverName, func(roomID, senderID string) (*spec.UserID, error) {
-			return r.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return r.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		}),
-		UserIDQuerier: func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		UserIDQuerier: func(roomID, senderID string) (*spec.UserID, error) {
-			return r.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return r.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		},
 	}
 	response, joinErr := gomatrixserverlib.PerformJoin(ctx, r, joinInput)
@@ -363,8 +363,8 @@ func (r *FederationInternalAPI) performOutboundPeekUsingServer(
 
 	// authenticate the state returned (check its auth events etc)
 	// the equivalent of CheckSendJoinResponse()
-	userIDProvider := func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	userIDProvider := func(roomID, senderID string) (*spec.UserID, error) {
-		return r.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+		return r.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 	}
 	authEvents, stateEvents, err := gomatrixserverlib.CheckStateResponse(
 		ctx, &respPeek, respPeek.RoomVersion, r.keyRing, federatedEventProvider(ctx, r.federation, r.keyRing, r.cfg.Matrix.ServerName, serverName, userIDProvider), userIDProvider,

federationapi/routing/invite.go

@@ -95,8 +95,8 @@ func InviteV2(
 			StateQuerier:      rsAPI.StateQuerier(),
 			InviteEvent:       inviteReq.Event(),
 			StrippedState:     inviteReq.InviteRoomState(),
-			UserIDQuerier: func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			UserIDQuerier: func(roomID, senderID string) (*spec.UserID, error) {
-				return rsAPI.QueryUserIDForSender(httpReq.Context(), roomAliasOrID, senderID)
+				return rsAPI.QueryUserIDForSender(httpReq.Context(), roomID, senderID)
 			},
 		}
 		event, jsonErr := handleInvite(httpReq.Context(), input, rsAPI)
@@ -188,8 +188,8 @@ func InviteV1(
 		StateQuerier:      rsAPI.StateQuerier(),
 		InviteEvent:       event,
 		StrippedState:     strippedState,
-		UserIDQuerier: func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		UserIDQuerier: func(roomID, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(httpReq.Context(), roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(httpReq.Context(), roomID, senderID)
 		},
 	}
 	event, jsonErr := handleInvite(httpReq.Context(), input, rsAPI)

federationapi/routing/join.go

@@ -156,8 +156,8 @@ func MakeJoin(
 		LocalServerName:   cfg.Matrix.ServerName,
 		LocalServerInRoom: res.RoomExists && res.IsInRoom,
 		RoomQuerier:       &roomQuerier,
-		UserIDQuerier: func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		UserIDQuerier: func(roomID, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(httpReq.Context(), roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(httpReq.Context(), roomID, senderID)
 		},
 		BuildEventTemplate: createJoinTemplate,
 	}
@@ -253,8 +253,8 @@ func SendJoin(
 		PrivateKey:        cfg.Matrix.PrivateKey,
 		Verifier:          keys,
 		MembershipQuerier: &api.MembershipQuerier{Roomserver: rsAPI},
-		UserIDQuerier: func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		UserIDQuerier: func(roomID, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(httpReq.Context(), roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(httpReq.Context(), roomID, senderID)
 		},
 	}
 	response, joinErr := gomatrixserverlib.HandleSendJoin(input)

federationapi/routing/leave.go

@@ -95,8 +95,8 @@ func MakeLeave(
 		LocalServerName:    cfg.Matrix.ServerName,
 		LocalServerInRoom:  res.RoomExists && res.IsInRoom,
 		BuildEventTemplate: createLeaveTemplate,
-		UserIDQuerier: func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		UserIDQuerier: func(roomID, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(httpReq.Context(), roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(httpReq.Context(), roomID, senderID)
 		},
 	}
 

go.mod

@@ -22,7 +22,7 @@ require (
 	github.com/matrix-org/dugong v0.0.0-20210921133753-66e6b1c67e2e
 	github.com/matrix-org/go-sqlite3-js v0.0.0-20220419092513-28aa791a1c91
 	github.com/matrix-org/gomatrix v0.0.0-20220926102614-ceba4d9f7530
-	github.com/matrix-org/gomatrixserverlib v0.0.0-20230606021710-b68a1b0eef30
+	github.com/matrix-org/gomatrixserverlib v0.0.0-20230606154326-77b5ce0c692d
 	github.com/matrix-org/pinecone v0.11.1-0.20230210171230-8c3b24f2649a
 	github.com/matrix-org/util v0.0.0-20221111132719-399730281e66
 	github.com/mattn/go-sqlite3 v1.14.16

go.sum

@@ -325,6 +325,8 @@ github.com/matrix-org/gomatrix v0.0.0-20220926102614-ceba4d9f7530 h1:kHKxCOLcHH8
 github.com/matrix-org/gomatrix v0.0.0-20220926102614-ceba4d9f7530/go.mod h1:/gBX06Kw0exX1HrwmoBibFA98yBk/jxKpGVeyQbff+s=
 github.com/matrix-org/gomatrixserverlib v0.0.0-20230606021710-b68a1b0eef30 h1:G+Do1UoWazY0Fetq+eAX1h1+fimf19NGGyaS86hWg8s=
 github.com/matrix-org/gomatrixserverlib v0.0.0-20230606021710-b68a1b0eef30/go.mod h1:H9V9N3Uqn1bBJqYJNGK1noqtgJTaCEhtTdcH/mp50uU=
+github.com/matrix-org/gomatrixserverlib v0.0.0-20230606154326-77b5ce0c692d h1:AUrJcbgtIPtVYTTfV7DUyarW7hOMgsZQZUuy9r8fMv8=
+github.com/matrix-org/gomatrixserverlib v0.0.0-20230606154326-77b5ce0c692d/go.mod h1:H9V9N3Uqn1bBJqYJNGK1noqtgJTaCEhtTdcH/mp50uU=
 github.com/matrix-org/pinecone v0.11.1-0.20230210171230-8c3b24f2649a h1:awrPDf9LEFySxTLKYBMCiObelNx/cBuv/wzllvCCH3A=
 github.com/matrix-org/pinecone v0.11.1-0.20230210171230-8c3b24f2649a/go.mod h1:HchJX9oKMXaT2xYFs0Ha/6Zs06mxLU8k6F1ODnrGkeQ=
 github.com/matrix-org/util v0.0.0-20221111132719-399730281e66 h1:6z4KxomXSIGWqhHcfzExgkH3Z3UkIXry4ibJS4Aqz2Y=

internal/pushrules/evaluate_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/matrix-org/gomatrixserverlib/spec"
 )
 
-func UserIDForSender(roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func UserIDForSender(roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 

internal/transactionrequest.go

@@ -167,8 +167,8 @@ func (t *TxnReq) ProcessTransaction(ctx context.Context) (*fclient.RespSend, *ut
 			}
 			continue
 		}
-		if err = gomatrixserverlib.VerifyEventSignatures(ctx, event, t.keys, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		if err = gomatrixserverlib.VerifyEventSignatures(ctx, event, t.keys, func(roomID, senderID string) (*spec.UserID, error) {
-			return t.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return t.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		}); err != nil {
 			util.GetLogger(ctx).WithError(err).Debugf("Transaction: Couldn't validate signature of event %q", event.EventID())
 			results[event.EventID()] = fclient.PDUResult{

internal/transactionrequest_test.go

@@ -70,7 +70,7 @@ type FakeRsAPI struct {
 	bannedFromRoom  bool
 }
 
-func (r *FakeRsAPI) QueryUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func (r *FakeRsAPI) QueryUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 
@@ -642,7 +642,7 @@ type testRoomserverAPI struct {
 	queryLatestEventsAndState func(*rsAPI.QueryLatestEventsAndStateRequest) rsAPI.QueryLatestEventsAndStateResponse
 }
 
-func (t *testRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func (t *testRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 

roomserver/api/api.go

@@ -67,9 +67,8 @@ type InputRoomEventsAPI interface {
 }
 
 type QuerySenderIDAPI interface {
-	// Accepts either roomID or alias
+	QuerySenderIDForUser(ctx context.Context, roomID string, userID spec.UserID) (string, error)
-	QuerySenderIDForUser(ctx context.Context, roomAliasOrID string, userID spec.UserID) (string, error)
+	QueryUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error)
-	QueryUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error)
 }
 
 // Query the latest events and state for a room from the room server.

roomserver/internal/helpers/auth.go

@@ -76,8 +76,8 @@ func CheckForSoftFail(
 	}
 
 	// Check if the event is allowed.
-	if err = gomatrixserverlib.Allowed(event.PDU, &authEvents, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	if err = gomatrixserverlib.Allowed(event.PDU, &authEvents, func(roomID, senderID string) (*spec.UserID, error) {
-		return db.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+		return db.GetUserIDForSender(ctx, roomID, senderID)
 	}); err != nil {
 		// return true, nil
 		return true, err

roomserver/internal/input/input_events.go

@@ -276,8 +276,8 @@ func (r *Inputer) processRoomEvent(
 
 	// Check if the event is allowed by its auth events. If it isn't then
 	// we consider the event to be "rejected" — it will still be persisted.
-	if err = gomatrixserverlib.Allowed(event, &authEvents, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	if err = gomatrixserverlib.Allowed(event, &authEvents, func(roomID, senderID string) (*spec.UserID, error) {
-		return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+		return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 	}); err != nil {
 		isRejected = true
 		rejectionErr = err
@@ -581,8 +581,8 @@ func (r *Inputer) processStateBefore(
 	stateBeforeAuth := gomatrixserverlib.NewAuthEvents(
 		gomatrixserverlib.ToPDUs(stateBeforeEvent),
 	)
-	if rejectionErr = gomatrixserverlib.Allowed(event, &stateBeforeAuth, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	if rejectionErr = gomatrixserverlib.Allowed(event, &stateBeforeAuth, func(roomID, senderID string) (*spec.UserID, error) {
-		return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+		return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 	}); rejectionErr != nil {
 		rejectionErr = fmt.Errorf("Allowed() failed for stateBeforeEvent: %w", rejectionErr)
 		return
@@ -694,8 +694,8 @@ nextAuthEvent:
 		// Check the signatures of the event. If this fails then we'll simply
 		// skip it, because gomatrixserverlib.Allowed() will notice a problem
 		// if a critical event is missing anyway.
-		if err := gomatrixserverlib.VerifyEventSignatures(ctx, authEvent, r.FSAPI.KeyRing(), func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		if err := gomatrixserverlib.VerifyEventSignatures(ctx, authEvent, r.FSAPI.KeyRing(), func(roomID, senderID string) (*spec.UserID, error) {
-			return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+			return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 		}); err != nil {
 			continue nextAuthEvent
 		}
@@ -712,8 +712,8 @@ nextAuthEvent:
 		}
 
 		// Check if the auth event should be rejected.
-		err := gomatrixserverlib.Allowed(authEvent, auth, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		err := gomatrixserverlib.Allowed(authEvent, auth, func(roomID, senderID string) (*spec.UserID, error) {
-			return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+			return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 		})
 		if isRejected = err != nil; isRejected {
 			logger.WithError(err).Warnf("Auth event %s rejected", authEvent.EventID())

roomserver/internal/input/input_events_test.go

@@ -58,7 +58,7 @@ func Test_EventAuth(t *testing.T) {
 	}
 
 	// Finally check that the event is NOT allowed
-	if err := gomatrixserverlib.Allowed(ev.PDU, &allower, func(roomAliasOrID, senderID string) (*spec.UserID, error) { return spec.NewUserID(senderID, true) }); err == nil {
+	if err := gomatrixserverlib.Allowed(ev.PDU, &allower, func(roomID, senderID string) (*spec.UserID, error) { return spec.NewUserID(senderID, true) }); err == nil {
 		t.Fatalf("event should not be allowed, but it was")
 	}
 }

roomserver/internal/input/input_missing.go

@@ -473,8 +473,8 @@ func (t *missingStateReq) resolveStatesAndCheck(ctx context.Context, roomVersion
 		stateEventList = append(stateEventList, state.StateEvents...)
 	}
 	resolvedStateEvents, err := gomatrixserverlib.ResolveConflicts(
-		roomVersion, gomatrixserverlib.ToPDUs(stateEventList), gomatrixserverlib.ToPDUs(authEventList), func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		roomVersion, gomatrixserverlib.ToPDUs(stateEventList), gomatrixserverlib.ToPDUs(authEventList), func(roomID, senderID string) (*spec.UserID, error) {
-			return t.db.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+			return t.db.GetUserIDForSender(ctx, roomID, senderID)
 		},
 	)
 	if err != nil {
@@ -482,8 +482,8 @@ func (t *missingStateReq) resolveStatesAndCheck(ctx context.Context, roomVersion
 	}
 	// apply the current event
 retryAllowedState:
-	if err = checkAllowedByState(backwardsExtremity, resolvedStateEvents, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	if err = checkAllowedByState(backwardsExtremity, resolvedStateEvents, func(roomID, senderID string) (*spec.UserID, error) {
-		return t.db.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+		return t.db.GetUserIDForSender(ctx, roomID, senderID)
 	}); err != nil {
 		switch missing := err.(type) {
 		case gomatrixserverlib.MissingAuthEventError:
@@ -569,8 +569,8 @@ func (t *missingStateReq) getMissingEvents(ctx context.Context, e gomatrixserver
 	// will be added and duplicates will be removed.
 	missingEvents := make([]gomatrixserverlib.PDU, 0, len(missingResp.Events))
 	for _, ev := range missingResp.Events.UntrustedEvents(roomVersion) {
-		if err = gomatrixserverlib.VerifyEventSignatures(ctx, ev, t.keys, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		if err = gomatrixserverlib.VerifyEventSignatures(ctx, ev, t.keys, func(roomID, senderID string) (*spec.UserID, error) {
-			return t.db.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+			return t.db.GetUserIDForSender(ctx, roomID, senderID)
 		}); err != nil {
 			continue
 		}
@@ -660,8 +660,8 @@ func (t *missingStateReq) lookupMissingStateViaState(
 	authEvents, stateEvents, err := gomatrixserverlib.CheckStateResponse(ctx, &fclient.RespState{
 		StateEvents: state.GetStateEvents(),
 		AuthEvents:  state.GetAuthEvents(),
-	}, roomVersion, t.keys, nil, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	}, roomVersion, t.keys, nil, func(roomID, senderID string) (*spec.UserID, error) {
-		return t.db.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+		return t.db.GetUserIDForSender(ctx, roomID, senderID)
 	})
 	if err != nil {
 		return nil, err
@@ -897,8 +897,8 @@ func (t *missingStateReq) lookupEvent(ctx context.Context, roomVersion gomatrixs
 		t.log.WithField("missing_event_id", missingEventID).Warnf("Failed to get missing /event for event ID from %d server(s)", len(t.servers))
 		return nil, fmt.Errorf("wasn't able to find event via %d server(s)", len(t.servers))
 	}
-	if err := gomatrixserverlib.VerifyEventSignatures(ctx, event, t.keys, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	if err := gomatrixserverlib.VerifyEventSignatures(ctx, event, t.keys, func(roomID, senderID string) (*spec.UserID, error) {
-		return t.db.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+		return t.db.GetUserIDForSender(ctx, roomID, senderID)
 	}); err != nil {
 		t.log.WithError(err).Warnf("Couldn't validate signature of event %q from /event", event.EventID())
 		return nil, verifySigError{event.EventID(), err}

roomserver/internal/perform/perform_admin.go

@@ -262,16 +262,16 @@ func (r *Admin) PerformAdminDownloadState(
 			return fmt.Errorf("r.Inputer.FSAPI.LookupState (%q): %s", fwdExtremity, err)
 		}
 		for _, authEvent := range state.GetAuthEvents().UntrustedEvents(roomInfo.RoomVersion) {
-			if err = gomatrixserverlib.VerifyEventSignatures(ctx, authEvent, r.Inputer.KeyRing, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			if err = gomatrixserverlib.VerifyEventSignatures(ctx, authEvent, r.Inputer.KeyRing, func(roomID, senderID string) (*spec.UserID, error) {
-				return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+				return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 			}); err != nil {
 				continue
 			}
 			authEventMap[authEvent.EventID()] = authEvent
 		}
 		for _, stateEvent := range state.GetStateEvents().UntrustedEvents(roomInfo.RoomVersion) {
-			if err = gomatrixserverlib.VerifyEventSignatures(ctx, stateEvent, r.Inputer.KeyRing, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			if err = gomatrixserverlib.VerifyEventSignatures(ctx, stateEvent, r.Inputer.KeyRing, func(roomID, senderID string) (*spec.UserID, error) {
-				return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+				return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 			}); err != nil {
 				continue
 			}

roomserver/internal/perform/perform_backfill.go

@@ -121,8 +121,8 @@ func (r *Backfiller) backfillViaFederation(ctx context.Context, req *api.Perform
 	// Specifically the test "Outbound federation can backfill events"
 	events, err := gomatrixserverlib.RequestBackfill(
 		ctx, req.VirtualHost, requester,
-		r.KeyRing, req.RoomID, info.RoomVersion, req.PrevEventIDs(), 100, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		r.KeyRing, req.RoomID, info.RoomVersion, req.PrevEventIDs(), 100, func(roomID, senderID string) (*spec.UserID, error) {
-			return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+			return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 		},
 	)
 	// Only return an error if we really couldn't get any events.
@@ -212,8 +212,8 @@ func (r *Backfiller) fetchAndStoreMissingEvents(ctx context.Context, roomVer gom
 				continue
 			}
 			loader := gomatrixserverlib.NewEventsLoader(roomVer, r.KeyRing, backfillRequester, backfillRequester.ProvideEvents, false)
-			result, err := loader.LoadAndVerify(ctx, res.PDUs, gomatrixserverlib.TopologicalOrderByPrevEvents, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			result, err := loader.LoadAndVerify(ctx, res.PDUs, gomatrixserverlib.TopologicalOrderByPrevEvents, func(roomID, senderID string) (*spec.UserID, error) {
-				return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+				return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 			})
 			if err != nil {
 				logger.WithError(err).Warn("failed to load and verify event")

roomserver/internal/perform/perform_create_room.go

@@ -308,8 +308,8 @@ func (c *Creator) PerformCreateRoom(ctx context.Context, userID spec.UserID, roo
 			}
 		}
 
-		if err = gomatrixserverlib.Allowed(ev, &authEvents, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		if err = gomatrixserverlib.Allowed(ev, &authEvents, func(roomID, senderID string) (*spec.UserID, error) {
-			return c.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+			return c.DB.GetUserIDForSender(ctx, roomID, senderID)
 		}); err != nil {
 			util.GetLogger(ctx).WithError(err).Error("gomatrixserverlib.Allowed failed")
 			return "", &util.JSONResponse{

roomserver/internal/perform/perform_invite.go

@@ -156,8 +156,8 @@ func (r *Inviter) PerformInvite(
 		StrippedState:     req.InviteRoomState,
 		MembershipQuerier: &api.MembershipQuerier{Roomserver: r.RSAPI},
 		StateQuerier:      &QueryState{r.DB},
-		UserIDQuerier: func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		UserIDQuerier: func(roomID, senderID string) (*spec.UserID, error) {
-			return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+			return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 		},
 	}
 	inviteEvent, err := gomatrixserverlib.PerformInvite(ctx, input, r.FSAPI)

roomserver/internal/perform/perform_upgrade.go

@@ -484,8 +484,8 @@ func (r *Upgrader) sendInitialEvents(ctx context.Context, evTime time.Time, user
 
 		}
 
-		if err = gomatrixserverlib.Allowed(event, &authEvents, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		if err = gomatrixserverlib.Allowed(event, &authEvents, func(roomID, senderID string) (*spec.UserID, error) {
-			return r.URSAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return r.URSAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		}); err != nil {
 			return fmt.Errorf("Failed to auth new %q event: %w", builder.Type, err)
 		}
@@ -569,8 +569,8 @@ func (r *Upgrader) makeHeaderedEvent(ctx context.Context, evTime time.Time, user
 		stateEvents[i] = queryRes.StateEvents[i].PDU
 	}
 	provider := gomatrixserverlib.NewAuthEvents(stateEvents)
-	if err = gomatrixserverlib.Allowed(headeredEvent.PDU, &provider, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	if err = gomatrixserverlib.Allowed(headeredEvent.PDU, &provider, func(roomID, senderID string) (*spec.UserID, error) {
-		return r.URSAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+		return r.URSAPI.QueryUserIDForSender(ctx, roomID, senderID)
 	}); err != nil {
 		return nil, api.ErrNotAllowed{Err: fmt.Errorf("failed to auth new %q event: %w", proto.Type, err)} // TODO: Is this error string comprehensible to the client?
 	}

roomserver/internal/query/query.go

@@ -122,8 +122,8 @@ func (r *Queryer) QueryStateAfterEvents(
 		}
 
 		stateEvents, err = gomatrixserverlib.ResolveConflicts(
-			info.RoomVersion, gomatrixserverlib.ToPDUs(stateEvents), gomatrixserverlib.ToPDUs(authEvents), func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			info.RoomVersion, gomatrixserverlib.ToPDUs(stateEvents), gomatrixserverlib.ToPDUs(authEvents), func(roomID, senderID string) (*spec.UserID, error) {
-				return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+				return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 			},
 		)
 		if err != nil {
@@ -351,8 +351,8 @@ func (r *Queryer) QueryMembershipsForRoom(
 			return fmt.Errorf("r.DB.Events: %w", err)
 		}
 		for _, event := range events {
-			clientEvent := synctypes.ToClientEvent(event.PDU, synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			clientEvent := synctypes.ToClientEvent(event.PDU, synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-				return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+				return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 			})
 			response.JoinEvents = append(response.JoinEvents, clientEvent)
 		}
@@ -402,8 +402,8 @@ func (r *Queryer) QueryMembershipsForRoom(
 	}
 
 	for _, event := range events {
-		clientEvent := synctypes.ToClientEvent(event.PDU, synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		clientEvent := synctypes.ToClientEvent(event.PDU, synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-			return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+			return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 		})
 		response.JoinEvents = append(response.JoinEvents, clientEvent)
 	}
@@ -594,8 +594,8 @@ func (r *Queryer) QueryStateAndAuthChain(
 
 	if request.ResolveState {
 		stateEvents, err = gomatrixserverlib.ResolveConflicts(
-			info.RoomVersion, gomatrixserverlib.ToPDUs(stateEvents), gomatrixserverlib.ToPDUs(authEvents), func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			info.RoomVersion, gomatrixserverlib.ToPDUs(stateEvents), gomatrixserverlib.ToPDUs(authEvents), func(roomID, senderID string) (*spec.UserID, error) {
-				return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+				return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 			},
 		)
 		if err != nil {
@@ -1043,10 +1043,10 @@ func (r *Queryer) QueryRestrictedJoinAllowed(ctx context.Context, req *api.Query
 	return nil
 }
 
-func (r *Queryer) QuerySenderIDForUser(ctx context.Context, roomAliasOrID string, userID spec.UserID) (string, error) {
+func (r *Queryer) QuerySenderIDForUser(ctx context.Context, roomID string, userID spec.UserID) (string, error) {
-	return r.DB.GetSenderIDForUser(ctx, roomAliasOrID, userID)
+	return r.DB.GetSenderIDForUser(ctx, roomID, userID)
 }
 
-func (r *Queryer) QueryUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func (r *Queryer) QueryUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error) {
-	return r.DB.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+	return r.DB.GetUserIDForSender(ctx, roomID, senderID)
 }

roomserver/state/state.go

@@ -44,7 +44,7 @@ type StateResolutionStorage interface {
 	AddState(ctx context.Context, roomNID types.RoomNID, stateBlockNIDs []types.StateBlockNID, state []types.StateEntry) (types.StateSnapshotNID, error)
 	Events(ctx context.Context, roomVersion gomatrixserverlib.RoomVersion, eventNIDs []types.EventNID) ([]types.Event, error)
 	EventsFromIDs(ctx context.Context, roomInfo *types.RoomInfo, eventIDs []string) ([]types.Event, error)
-	GetUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error)
+	GetUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error)
 }
 
 type StateResolution struct {
@@ -947,8 +947,8 @@ func (v *StateResolution) resolveConflictsV1(
 	}
 
 	// Resolve the conflicts.
-	resolvedEvents := gomatrixserverlib.ResolveStateConflicts(conflictedEvents, authEvents, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	resolvedEvents := gomatrixserverlib.ResolveStateConflicts(conflictedEvents, authEvents, func(roomID, senderID string) (*spec.UserID, error) {
-		return v.db.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+		return v.db.GetUserIDForSender(ctx, roomID, senderID)
 	})
 
 	// Map from the full events back to numeric state entries.
@@ -1061,8 +1061,8 @@ func (v *StateResolution) resolveConflictsV2(
 			conflictedEvents,
 			nonConflictedEvents,
 			authEvents,
-			func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			func(roomID, senderID string) (*spec.UserID, error) {
-				return v.db.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+				return v.db.GetUserIDForSender(ctx, roomID, senderID)
 			},
 		)
 	}()

roomserver/storage/interface.go

@@ -167,9 +167,9 @@ type Database interface {
 	// GetKnownUsers searches all users that userID knows about.
 	GetKnownUsers(ctx context.Context, userID, searchString string, limit int) ([]string, error)
 	// GetKnownUsers tries to obtain the current mxid for a given user.
-	GetUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error)
+	GetUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error)
 	// GetKnownUsers tries to obtain the current senderID for a given user.
-	GetSenderIDForUser(ctx context.Context, roomAliasOrID string, userID spec.UserID) (string, error)
+	GetSenderIDForUser(ctx context.Context, roomID string, userID spec.UserID) (string, error)
 	// GetKnownRooms returns a list of all rooms we know about.
 	GetKnownRooms(ctx context.Context) ([]string, error)
 	// ForgetRoom sets a flag in the membership table, that the user wishes to forget a specific room
@@ -215,7 +215,7 @@ type RoomDatabase interface {
 	GetOrCreateEventTypeNID(ctx context.Context, eventType string) (eventTypeNID types.EventTypeNID, err error)
 	GetOrCreateEventStateKeyNID(ctx context.Context, eventStateKey *string) (types.EventStateKeyNID, error)
 	GetStateEvent(ctx context.Context, roomID, evType, stateKey string) (*types.HeaderedEvent, error)
-	GetUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error)
+	GetUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error)
 }
 
 type EventDatabase interface {

roomserver/storage/shared/room_updater.go

@@ -252,6 +252,6 @@ func (u *RoomUpdater) MembershipUpdater(targetUserNID types.EventStateKeyNID, ta
 	return u.d.membershipUpdaterTxn(u.ctx, u.txn, u.roomInfo.RoomNID, targetUserNID, targetLocal)
 }
 
-func (u *RoomUpdater) GetUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func (u *RoomUpdater) GetUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error) {
-	return u.d.GetUserIDForSender(ctx, roomAliasOrID, senderID)
+	return u.d.GetUserIDForSender(ctx, roomID, senderID)
 }

roomserver/storage/shared/storage.go

@@ -1524,12 +1524,12 @@ func (d *Database) GetKnownUsers(ctx context.Context, userID, searchString strin
 	return d.MembershipTable.SelectKnownUsers(ctx, nil, stateKeyNID, searchString, limit)
 }
 
-func (d *Database) GetUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func (d *Database) GetUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error) {
 	// TODO: Use real logic once DB for pseudoIDs is in place
 	return spec.NewUserID(senderID, true)
 }
 
-func (d *Database) GetSenderIDForUser(ctx context.Context, roomAliasOrID string, userID spec.UserID) (string, error) {
+func (d *Database) GetSenderIDForUser(ctx context.Context, roomID string, userID spec.UserID) (string, error) {
 	// TODO: Use real logic once DB for pseudoIDs is in place
 	return userID.String(), nil
 }

setup/mscs/msc2836/msc2836.go

@@ -94,8 +94,8 @@ type MSC2836EventRelationshipsResponse struct {
 
 func toClientResponse(ctx context.Context, res *MSC2836EventRelationshipsResponse, rsAPI roomserver.RoomserverInternalAPI) *EventRelationshipResponse {
 	out := &EventRelationshipResponse{
-		Events: synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(res.ParsedEvents), synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		Events: synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(res.ParsedEvents), synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		}),
 		Limited:   res.Limited,
 		NextBatch: res.NextBatch,

setup/mscs/msc2836/msc2836_test.go

@@ -525,7 +525,7 @@ type testRoomserverAPI struct {
 	events            map[string]*types.HeaderedEvent
 }
 
-func (r *testRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func (r *testRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 

syncapi/routing/context.go

@@ -193,19 +193,19 @@ func Context(
 		}
 	}
 
-	eventsBeforeClient := synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(eventsBeforeFiltered), synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	eventsBeforeClient := synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(eventsBeforeFiltered), synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-		return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+		return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 	})
-	eventsAfterClient := synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(eventsAfterFiltered), synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	eventsAfterClient := synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(eventsAfterFiltered), synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-		return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+		return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 	})
 
 	newState := state
 	if filter.LazyLoadMembers {
 		allEvents := append(eventsBeforeFiltered, eventsAfterFiltered...)
 		allEvents = append(allEvents, &requestedEvent)
-		evs := synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(allEvents), synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		evs := synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(allEvents), synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		})
 		newState, err = applyLazyLoadMembers(ctx, device, snapshot, roomID, evs, lazyLoadCache)
 		if err != nil {
@@ -217,15 +217,15 @@ func Context(
 		}
 	}
 
-	ev := synctypes.ToClientEvent(&requestedEvent, synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	ev := synctypes.ToClientEvent(&requestedEvent, synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-		return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+		return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 	})
 	response := ContextRespsonse{
 		Event:        &ev,
 		EventsAfter:  eventsAfterClient,
 		EventsBefore: eventsBeforeClient,
-		State: synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(newState), synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		State: synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(newState), synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		}),
 	}
 

syncapi/routing/getevent.go

@@ -103,8 +103,8 @@ func GetEvent(
 
 	return util.JSONResponse{
 		Code: http.StatusOK,
-		JSON: synctypes.ToClientEvent(events[0], synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		JSON: synctypes.ToClientEvent(events[0], synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(req.Context(), roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(req.Context(), roomID, senderID)
 		}),
 	}
 }

syncapi/routing/memberships.go

@@ -153,8 +153,8 @@ func GetMemberships(
 	}
 	return util.JSONResponse{
 		Code: http.StatusOK,
-		JSON: getMembershipResponse{synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(result), synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		JSON: getMembershipResponse{synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(result), synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(req.Context(), roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(req.Context(), roomID, senderID)
 		})},
 	}
 }

syncapi/routing/messages.go

@@ -273,8 +273,8 @@ func OnIncomingMessagesRequest(
 				JSON: spec.InternalServerError{},
 			}
 		}
-		res.State = append(res.State, synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(membershipEvents), synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		res.State = append(res.State, synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(membershipEvents), synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-			return rsAPI.QueryUserIDForSender(req.Context(), roomAliasOrID, senderID)
+			return rsAPI.QueryUserIDForSender(req.Context(), roomID, senderID)
 		})...)
 	}
 
@@ -385,8 +385,8 @@ func (r *messagesReq) retrieveEvents(ctx context.Context, rsAPI api.SyncRoomserv
 		"events_before": len(events),
 		"events_after":  len(filteredEvents),
 	}).Debug("applied history visibility (messages)")
-	return synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(filteredEvents), synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	return synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(filteredEvents), synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-		return rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+		return rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 	}), start, end, err
 }
 

syncapi/routing/relations.go

@@ -116,8 +116,8 @@ func Relations(
 	for _, event := range filteredEvents {
 		res.Chunk = append(
 			res.Chunk,
-			synctypes.ToClientEvent(event.PDU, synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			synctypes.ToClientEvent(event.PDU, synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-				return rsAPI.QueryUserIDForSender(req.Context(), roomAliasOrID, senderID)
+				return rsAPI.QueryUserIDForSender(req.Context(), roomID, senderID)
 			}),
 		)
 	}

syncapi/routing/search.go

@@ -228,17 +228,17 @@ func Search(req *http.Request, device *api.Device, syncDB storage.Database, fts
 			Context: SearchContextResponse{
 				Start: startToken.String(),
 				End:   endToken.String(),
-				EventsAfter: synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(eventsAfter), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+				EventsAfter: synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(eventsAfter), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-					return rsAPI.QueryUserIDForSender(req.Context(), roomAliasOrID, senderID)
+					return rsAPI.QueryUserIDForSender(req.Context(), roomID, senderID)
 				}),
-				EventsBefore: synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(eventsBefore), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+				EventsBefore: synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(eventsBefore), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-					return rsAPI.QueryUserIDForSender(req.Context(), roomAliasOrID, senderID)
+					return rsAPI.QueryUserIDForSender(req.Context(), roomID, senderID)
 				}),
 				ProfileInfo: profileInfos,
 			},
 			Rank: eventScore[event.EventID()].Score,
-			Result: synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			Result: synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-				return rsAPI.QueryUserIDForSender(req.Context(), roomAliasOrID, senderID)
+				return rsAPI.QueryUserIDForSender(req.Context(), roomID, senderID)
 			}),
 		})
 		roomGroup := groups[event.RoomID()]
@@ -254,8 +254,8 @@ func Search(req *http.Request, device *api.Device, syncDB storage.Database, fts
 					JSON: spec.InternalServerError{},
 				}
 			}
-			stateForRooms[event.RoomID()] = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(state), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+			stateForRooms[event.RoomID()] = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(state), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-				return rsAPI.QueryUserIDForSender(req.Context(), roomAliasOrID, senderID)
+				return rsAPI.QueryUserIDForSender(req.Context(), roomID, senderID)
 			})
 		}
 	}

syncapi/routing/search_test.go

@@ -25,7 +25,7 @@ import (
 
 type FakeSyncRoomserverAPI struct{ rsapi.SyncRoomserverAPI }
 
-func (f *FakeSyncRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func (f *FakeSyncRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 

syncapi/streams/stream_invite.go

@@ -68,8 +68,8 @@ func (p *InviteStreamProvider) IncrementalSync(
 		if _, ok := req.IgnoredUsers.List[inviteEvent.SenderID()]; ok {
 			continue
 		}
-		ir := types.NewInviteResponse(inviteEvent, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		ir := types.NewInviteResponse(inviteEvent, func(roomID, senderID string) (*spec.UserID, error) {
-			return p.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return p.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		})
 		req.Response.Rooms.Invite[roomID] = ir
 	}

syncapi/streams/stream_pdu.go

@@ -376,14 +376,14 @@ func (p *PDUStreamProvider) addRoomDeltaToResponse(
 			}
 		}
 		jr.Timeline.PrevBatch = &prevBatch
-		jr.Timeline.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(events), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		jr.Timeline.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(events), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-			return p.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return p.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		})
 		// If we are limited by the filter AND the history visibility filter
 		// didn't "remove" events, return that the response is limited.
 		jr.Timeline.Limited = (limited && len(events) == len(recentEvents)) || delta.NewlyJoined
-		jr.State.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(delta.StateEvents), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		jr.State.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(delta.StateEvents), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-			return p.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return p.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		})
 		req.Response.Rooms.Join[delta.RoomID] = jr
 
@@ -391,12 +391,12 @@ func (p *PDUStreamProvider) addRoomDeltaToResponse(
 		jr := types.NewJoinResponse()
 		jr.Timeline.PrevBatch = &prevBatch
 		// TODO: Apply history visibility on peeked rooms
-		jr.Timeline.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(recentEvents), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		jr.Timeline.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(recentEvents), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-			return p.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return p.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		})
 		jr.Timeline.Limited = limited
-		jr.State.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(delta.StateEvents), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		jr.State.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(delta.StateEvents), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-			return p.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return p.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		})
 		req.Response.Rooms.Peek[delta.RoomID] = jr
 
@@ -406,14 +406,14 @@ func (p *PDUStreamProvider) addRoomDeltaToResponse(
 	case spec.Ban:
 		lr := types.NewLeaveResponse()
 		lr.Timeline.PrevBatch = &prevBatch
-		lr.Timeline.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(events), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		lr.Timeline.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(events), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-			return p.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return p.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		})
 		// If we are limited by the filter AND the history visibility filter
 		// didn't "remove" events, return that the response is limited.
 		lr.Timeline.Limited = limited && len(events) == len(recentEvents)
-		lr.State.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(delta.StateEvents), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		lr.State.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(delta.StateEvents), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-			return p.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return p.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		})
 		req.Response.Rooms.Leave[delta.RoomID] = lr
 	}
@@ -564,14 +564,14 @@ func (p *PDUStreamProvider) getJoinResponseForCompleteSync(
 	}
 
 	jr.Timeline.PrevBatch = prevBatch
-	jr.Timeline.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(events), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	jr.Timeline.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(events), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-		return p.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+		return p.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 	})
 	// If we are limited by the filter AND the history visibility filter
 	// didn't "remove" events, return that the response is limited.
 	jr.Timeline.Limited = limited && len(events) == len(recentEvents)
-	jr.State.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(stateEvents), synctypes.FormatSync, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	jr.State.Events = synctypes.ToClientEvents(gomatrixserverlib.ToPDUs(stateEvents), synctypes.FormatSync, func(roomID, senderID string) (*spec.UserID, error) {
-		return p.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+		return p.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 	})
 	return jr, nil
 }

syncapi/syncapi_test.go

@@ -40,7 +40,7 @@ type syncRoomserverAPI struct {
 	rooms []*test.Room
 }
 
-func (s *syncRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func (s *syncRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 

syncapi/synctypes/clientevent_test.go

@@ -24,7 +24,7 @@ import (
 	"github.com/matrix-org/gomatrixserverlib/spec"
 )
 
-func UserIDForSender(roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func UserIDForSender(roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 

syncapi/types/types_test.go

@@ -11,7 +11,7 @@ import (
 	"github.com/matrix-org/gomatrixserverlib/spec"
 )
 
-func UserIDForSender(roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func UserIDForSender(roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 

test/room.go

@@ -39,7 +39,7 @@ var (
 	roomIDCounter = int64(0)
 )
 
-func UserIDForSender(roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func UserIDForSender(roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 

userapi/consumers/roomserver.go

@@ -301,8 +301,8 @@ func (s *OutputRoomEventConsumer) processMessage(ctx context.Context, event *rst
 
 	switch {
 	case event.Type() == spec.MRoomMember:
-		cevent := synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+		cevent := synctypes.ToClientEvent(event, synctypes.FormatAll, func(roomID, senderID string) (*spec.UserID, error) {
-			return s.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return s.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		})
 		var member *localMembership
 		member, err = newLocalMembership(&cevent)
@@ -536,8 +536,8 @@ func (s *OutputRoomEventConsumer) notifyLocal(ctx context.Context, event *rstype
 		// UNSPEC: the spec doesn't say this is a ClientEvent, but the
 		// fields seem to match. room_id should be missing, which
 		// matches the behaviour of FormatSync.
-		Event: synctypes.ToClientEvent(event, synctypes.FormatSync, func(roomAliasOrID string, senderID string) (*spec.UserID, error) {
+		Event: synctypes.ToClientEvent(event, synctypes.FormatSync, func(roomID string, senderID string) (*spec.UserID, error) {
-			return s.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+			return s.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 		}),
 		// TODO: this is per-device, but it's not part of the primary
 		// key. So inserting one notification per profile tag doesn't
@@ -659,8 +659,8 @@ func (s *OutputRoomEventConsumer) evaluatePushRules(ctx context.Context, event *
 		roomSize: roomSize,
 	}
 	eval := pushrules.NewRuleSetEvaluator(ec, &ruleSets.Global)
-	rule, err := eval.MatchEvent(event.PDU, func(roomAliasOrID, senderID string) (*spec.UserID, error) {
+	rule, err := eval.MatchEvent(event.PDU, func(roomID, senderID string) (*spec.UserID, error) {
-		return s.rsAPI.QueryUserIDForSender(ctx, roomAliasOrID, senderID)
+		return s.rsAPI.QueryUserIDForSender(ctx, roomID, senderID)
 	})
 	if err != nil {
 		return nil, err

userapi/consumers/roomserver_test.go

@@ -47,7 +47,7 @@ func mustCreateEvent(t *testing.T, content string) *types.HeaderedEvent {
 
 type FakeUserRoomserverAPI struct{ rsapi.UserRoomserverAPI }
 
-func (f *FakeUserRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func (f *FakeUserRoomserverAPI) QueryUserIDForSender(ctx context.Context, roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }
 

userapi/util/notify_test.go

@@ -23,7 +23,7 @@ import (
 	userUtil "github.com/matrix-org/dendrite/userapi/util"
 )
 
-func UserIDForSender(roomAliasOrID string, senderID string) (*spec.UserID, error) {
+func UserIDForSender(roomID string, senderID string) (*spec.UserID, error) {
 	return spec.NewUserID(senderID, true)
 }