Remove gmsl.HeaderedEvent (#3068)

Replaced with types.HeaderedEvent _for now_. In reality we want to move
them all to gmsl.Event and only use HeaderedEvent when we _need_ to
bundle the version/event ID with the event (seriailsation boundaries,
and even then only when we don't have the room version).

Requires https://github.com/matrix-org/gomatrixserverlib/pull/373

federationapi/api/api.go

@@ -11,6 +11,7 @@ import (
 	"github.com/matrix-org/gomatrixserverlib/spec"
 
 	"github.com/matrix-org/dendrite/federationapi/types"
+	rstypes "github.com/matrix-org/dendrite/roomserver/types"
 )
 
 // FederationInternalAPI is used to query information from the federation sender.
@@ -189,13 +190,13 @@ type PerformLeaveResponse struct {
 }
 
 type PerformInviteRequest struct {
-	RoomVersion     gomatrixserverlib.RoomVersion    `json:"room_version"`
-	Event           *gomatrixserverlib.HeaderedEvent `json:"event"`
-	InviteRoomState []fclient.InviteV2StrippedState  `json:"invite_room_state"`
+	RoomVersion     gomatrixserverlib.RoomVersion   `json:"room_version"`
+	Event           *rstypes.HeaderedEvent          `json:"event"`
+	InviteRoomState []fclient.InviteV2StrippedState `json:"invite_room_state"`
 }
 
 type PerformInviteResponse struct {
-	Event *gomatrixserverlib.HeaderedEvent `json:"event"`
+	Event *rstypes.HeaderedEvent `json:"event"`
 }
 
 // QueryJoinedHostServerNamesInRoomRequest is a request to QueryJoinedHostServerNames

federationapi/consumers/roomserver.go

@@ -187,7 +187,12 @@ func (s *OutputRoomEventConsumer) processMessage(ore api.OutputNewRoomEvent, rew
 		addsStateEvents = append(addsStateEvents, eventsRes.Events...)
 	}
 
-	addsJoinedHosts, err := JoinedHostsFromEvents(gomatrixserverlib.UnwrapEventHeaders(addsStateEvents))
+	evs := make([]*gomatrixserverlib.Event, len(addsStateEvents))
+	for i := range evs {
+		evs[i] = addsStateEvents[i].Event
+	}
+
+	addsJoinedHosts, err := JoinedHostsFromEvents(evs)
 	if err != nil {
 		return err
 	}

federationapi/federationapi_test.go

@@ -23,6 +23,7 @@ import (
 	"github.com/matrix-org/dendrite/federationapi/api"
 	"github.com/matrix-org/dendrite/federationapi/internal"
 	rsapi "github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/setup/jetstream"
 	"github.com/matrix-org/dendrite/test"
 	"github.com/matrix-org/dendrite/test/testrig"
@@ -137,10 +138,10 @@ func (f *fedClient) SendJoin(ctx context.Context, origin, s spec.ServerName, eve
 	defer f.fedClientMutex.Unlock()
 	for _, r := range f.allowJoins {
 		if r.ID == event.RoomID() {
-			r.InsertEvent(f.t, event.Headered(r.Version))
+			r.InsertEvent(f.t, &types.HeaderedEvent{Event: event})
 			f.t.Logf("Join event: %v", event.EventID())
-			res.StateEvents = gomatrixserverlib.NewEventJSONsFromHeaderedEvents(r.CurrentState())
-			res.AuthEvents = gomatrixserverlib.NewEventJSONsFromHeaderedEvents(r.Events())
+			res.StateEvents = types.NewEventJSONsFromHeaderedEvents(r.CurrentState())
+			res.AuthEvents = types.NewEventJSONsFromHeaderedEvents(r.Events())
 		}
 	}
 	return
@@ -327,8 +328,7 @@ func TestRoomsV3URLEscapeDoNot404(t *testing.T) {
 		if err != nil {
 			t.Errorf("failed to parse event: %s", err)
 		}
-		he := ev.Headered(tc.roomVer)
-		invReq, err := fclient.NewInviteV2Request(he, nil)
+		invReq, err := fclient.NewInviteV2Request(ev, nil)
 		if err != nil {
 			t.Errorf("failed to create invite v2 request: %s", err)
 			continue

federationapi/internal/perform.go

@@ -18,6 +18,7 @@ import (
 	"github.com/matrix-org/dendrite/federationapi/consumers"
 	"github.com/matrix-org/dendrite/federationapi/statistics"
 	roomserverAPI "github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/roomserver/version"
 )
 
@@ -199,7 +200,7 @@ func (r *FederationInternalAPI) performJoinUsingServer(
 		user.Domain(),
 		roomserverAPI.KindNew,
 		response.StateSnapshot,
-		response.JoinEvent.Headered(response.JoinEvent.Version()),
+		&types.HeaderedEvent{Event: response.JoinEvent},
 		serverName,
 		nil,
 		false,
@@ -384,7 +385,7 @@ func (r *FederationInternalAPI) performOutboundPeekUsingServer(
 			StateEvents: gomatrixserverlib.NewEventJSONsFromEvents(stateEvents),
 			AuthEvents:  gomatrixserverlib.NewEventJSONsFromEvents(authEvents),
 		},
-		respPeek.LatestEvent.Headered(respPeek.RoomVersion),
+		&types.HeaderedEvent{Event: respPeek.LatestEvent},
 		serverName,
 		nil,
 		false,
@@ -531,7 +532,7 @@ func (r *FederationInternalAPI) PerformInvite(
 		"destination":  destination,
 	}).Info("Sending invite")
 
-	inviteReq, err := fclient.NewInviteV2Request(request.Event, request.InviteRoomState)
+	inviteReq, err := fclient.NewInviteV2Request(request.Event.Event, request.InviteRoomState)
 	if err != nil {
 		return fmt.Errorf("gomatrixserverlib.NewInviteV2Request: %w", err)
 	}
@@ -549,7 +550,7 @@ func (r *FederationInternalAPI) PerformInvite(
 	if err != nil {
 		return fmt.Errorf("r.federation.SendInviteV2 failed to decode event response: %w", err)
 	}
-	response.Event = inviteEvent.Headered(request.RoomVersion)
+	response.Event = &types.HeaderedEvent{Event: inviteEvent}
 	return nil
 }
 

federationapi/queue/destinationqueue.go

@@ -32,6 +32,7 @@ import (
 	"github.com/matrix-org/dendrite/federationapi/storage"
 	"github.com/matrix-org/dendrite/federationapi/storage/shared/receipt"
 	"github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/setup/process"
 )
 
@@ -71,7 +72,7 @@ type destinationQueue struct {
 // Send event adds the event to the pending queue for the destination.
 // If the queue is empty then it starts a background goroutine to
 // start sending events to that destination.
-func (oq *destinationQueue) sendEvent(event *gomatrixserverlib.HeaderedEvent, dbReceipt *receipt.Receipt) {
+func (oq *destinationQueue) sendEvent(event *types.HeaderedEvent, dbReceipt *receipt.Receipt) {
 	if event == nil {
 		logrus.Errorf("attempt to send nil PDU with destination %q", oq.destination)
 		return

federationapi/queue/queue.go

@@ -33,6 +33,7 @@ import (
 	"github.com/matrix-org/dendrite/federationapi/storage"
 	"github.com/matrix-org/dendrite/federationapi/storage/shared/receipt"
 	"github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/setup/process"
 )
 
@@ -140,7 +141,7 @@ func NewOutgoingQueues(
 
 type queuedPDU struct {
 	dbReceipt *receipt.Receipt
-	pdu       *gomatrixserverlib.HeaderedEvent
+	pdu       *types.HeaderedEvent
 }
 
 type queuedEDU struct {
@@ -187,7 +188,7 @@ func (oqs *OutgoingQueues) clearQueue(oq *destinationQueue) {
 
 // SendEvent sends an event to the destinations
 func (oqs *OutgoingQueues) SendEvent(
-	ev *gomatrixserverlib.HeaderedEvent, origin spec.ServerName,
+	ev *types.HeaderedEvent, origin spec.ServerName,
 	destinations []spec.ServerName,
 ) error {
 	if oqs.disabled {

federationapi/queue/queue_test.go

@@ -35,6 +35,7 @@ import (
 	"github.com/matrix-org/dendrite/federationapi/statistics"
 	"github.com/matrix-org/dendrite/federationapi/storage"
 	rsapi "github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/setup/config"
 	"github.com/matrix-org/dendrite/setup/process"
 	"github.com/matrix-org/dendrite/test"
@@ -101,14 +102,14 @@ func (f *stubFederationClient) P2PSendTransactionToRelay(ctx context.Context, u
 	return fclient.EmptyResp{}, result
 }
 
-func mustCreatePDU(t *testing.T) *gomatrixserverlib.HeaderedEvent {
+func mustCreatePDU(t *testing.T) *types.HeaderedEvent {
 	t.Helper()
 	content := `{"type":"m.room.message"}`
 	ev, err := gomatrixserverlib.MustGetRoomVersion(gomatrixserverlib.RoomVersionV10).NewEventFromTrustedJSON([]byte(content), false)
 	if err != nil {
 		t.Fatalf("failed to create event: %v", err)
 	}
-	return ev.Headered(gomatrixserverlib.RoomVersionV10)
+	return &types.HeaderedEvent{Event: ev}
 }
 
 func mustCreateEDU(t *testing.T) *gomatrixserverlib.EDU {

federationapi/routing/backfill.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/setup/config"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/gomatrixserverlib/fclient"
@@ -104,7 +105,7 @@ func Backfill(
 	// Filter any event that's not from the requested room out.
 	evs := make([]*gomatrixserverlib.Event, 0)
 
-	var ev *gomatrixserverlib.HeaderedEvent
+	var ev *types.HeaderedEvent
 	for _, ev = range res.Events {
 		if ev.RoomID() == roomID {
 			evs = append(evs, ev.Event)

federationapi/routing/eventauth.go

@@ -18,7 +18,7 @@ import (
 
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/roomserver/api"
-	"github.com/matrix-org/gomatrixserverlib"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/gomatrixserverlib/fclient"
 	"github.com/matrix-org/util"
 )
@@ -72,7 +72,7 @@ func GetEventAuth(
 	return util.JSONResponse{
 		Code: http.StatusOK,
 		JSON: fclient.RespEventAuth{
-			AuthEvents: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(response.AuthChainEvents),
+			AuthEvents: types.NewEventJSONsFromHeaderedEvents(response.AuthChainEvents),
 		},
 	}
 }

federationapi/routing/invite.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/setup/config"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/gomatrixserverlib/fclient"
@@ -196,11 +197,11 @@ func processInvite(
 	)
 
 	// Add the invite event to the roomserver.
-	inviteEvent := signedEvent.Headered(roomVer)
+	inviteEvent := &types.HeaderedEvent{Event: &signedEvent}
 	request := &api.PerformInviteRequest{
 		Event:           inviteEvent,
 		InviteRoomState: strippedState,
-		RoomVersion:     inviteEvent.RoomVersion,
+		RoomVersion:     inviteEvent.Version(),
 		SendAsServer:    string(api.DoNotSendToOtherServers),
 		TransactionID:   nil,
 	}

federationapi/routing/join.go

@@ -30,6 +30,7 @@ import (
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/internal/eventutil"
 	"github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/setup/config"
 )
 
@@ -413,7 +414,7 @@ func SendJoin(
 			InputRoomEvents: []api.InputRoomEvent{
 				{
 					Kind:          api.KindNew,
-					Event:         signed.Headered(stateAndAuthChainResponse.RoomVersion),
+					Event:         &types.HeaderedEvent{Event: &signed},
 					SendAsServer:  string(cfg.Matrix.ServerName),
 					TransactionID: nil,
 				},
@@ -443,8 +444,8 @@ func SendJoin(
 	return util.JSONResponse{
 		Code: http.StatusOK,
 		JSON: fclient.RespSendJoin{
-			StateEvents: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(stateAndAuthChainResponse.StateEvents),
-			AuthEvents:  gomatrixserverlib.NewEventJSONsFromHeaderedEvents(stateAndAuthChainResponse.AuthChainEvents),
+			StateEvents: types.NewEventJSONsFromHeaderedEvents(stateAndAuthChainResponse.StateEvents),
+			AuthEvents:  types.NewEventJSONsFromHeaderedEvents(stateAndAuthChainResponse.AuthChainEvents),
 			Origin:      cfg.Matrix.ServerName,
 			Event:       signed.JSON(),
 		},
@@ -519,7 +520,7 @@ func checkRestrictedJoin(
 	}
 }
 
-type eventsByDepth []*gomatrixserverlib.HeaderedEvent
+type eventsByDepth []*types.HeaderedEvent
 
 func (e eventsByDepth) Len() int {
 	return len(e)

federationapi/routing/leave.go

@@ -20,6 +20,7 @@ import (
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/internal/eventutil"
 	"github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/setup/config"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/gomatrixserverlib/fclient"
@@ -101,7 +102,7 @@ func MakeLeave(
 			return util.JSONResponse{
 				Code: http.StatusOK,
 				JSON: map[string]interface{}{
-					"room_version": event.RoomVersion,
+					"room_version": event.Version(),
 					"event":        state,
 				},
 			}
@@ -124,7 +125,7 @@ func MakeLeave(
 	return util.JSONResponse{
 		Code: http.StatusOK,
 		JSON: map[string]interface{}{
-			"room_version": event.RoomVersion,
+			"room_version": event.Version(),
 			"event":        builder,
 		},
 	}
@@ -312,7 +313,7 @@ func SendLeave(
 		InputRoomEvents: []api.InputRoomEvent{
 			{
 				Kind:          api.KindNew,
-				Event:         event.Headered(roomVersion),
+				Event:         &types.HeaderedEvent{Event: event},
 				SendAsServer:  string(cfg.Matrix.ServerName),
 				TransactionID: nil,
 			},

federationapi/routing/missingevents.go

@@ -18,7 +18,7 @@ import (
 
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/roomserver/api"
-	"github.com/matrix-org/gomatrixserverlib"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/gomatrixserverlib/fclient"
 	"github.com/matrix-org/util"
 )
@@ -69,7 +69,7 @@ func GetMissingEvents(
 	eventsResponse.Events = filterEvents(eventsResponse.Events, roomID)
 
 	resp := fclient.RespMissingEvents{
-		Events: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(eventsResponse.Events),
+		Events: types.NewEventJSONsFromHeaderedEvents(eventsResponse.Events),
 	}
 
 	return util.JSONResponse{
@@ -80,8 +80,8 @@ func GetMissingEvents(
 
 // filterEvents returns only those events with matching roomID
 func filterEvents(
-	events []*gomatrixserverlib.HeaderedEvent, roomID string,
-) []*gomatrixserverlib.HeaderedEvent {
+	events []*types.HeaderedEvent, roomID string,
+) []*types.HeaderedEvent {
 	ref := events[:0]
 	for _, ev := range events {
 		if ev.RoomID() == roomID {

federationapi/routing/peek.go

@@ -19,6 +19,7 @@ import (
 
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/setup/config"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/gomatrixserverlib/fclient"
@@ -87,10 +88,10 @@ func Peek(
 	}
 
 	respPeek := fclient.RespPeek{
-		StateEvents:     gomatrixserverlib.NewEventJSONsFromHeaderedEvents(response.StateEvents),
-		AuthEvents:      gomatrixserverlib.NewEventJSONsFromHeaderedEvents(response.AuthChainEvents),
+		StateEvents:     types.NewEventJSONsFromHeaderedEvents(response.StateEvents),
+		AuthEvents:      types.NewEventJSONsFromHeaderedEvents(response.AuthChainEvents),
 		RoomVersion:     response.RoomVersion,
-		LatestEvent:     response.LatestEvent.Unwrap(),
+		LatestEvent:     response.LatestEvent.Event,
 		RenewalInterval: renewalInterval,
 	}
 

federationapi/routing/state.go

@@ -19,7 +19,7 @@ import (
 
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/roomserver/api"
-	"github.com/matrix-org/gomatrixserverlib"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/gomatrixserverlib/fclient"
 	"github.com/matrix-org/util"
 )
@@ -42,8 +42,8 @@ func GetState(
 	}
 
 	return util.JSONResponse{Code: http.StatusOK, JSON: &fclient.RespState{
-		AuthEvents:  gomatrixserverlib.NewEventJSONsFromHeaderedEvents(authChain),
-		StateEvents: gomatrixserverlib.NewEventJSONsFromHeaderedEvents(stateEvents),
+		AuthEvents:  types.NewEventJSONsFromHeaderedEvents(authChain),
+		StateEvents: types.NewEventJSONsFromHeaderedEvents(stateEvents),
 	}}
 }
 
@@ -101,7 +101,7 @@ func getState(
 	rsAPI api.FederationRoomserverAPI,
 	roomID string,
 	eventID string,
-) (stateEvents, authEvents []*gomatrixserverlib.HeaderedEvent, errRes *util.JSONResponse) {
+) (stateEvents, authEvents []*types.HeaderedEvent, errRes *util.JSONResponse) {
 	// If we don't think we belong to this room then don't waste the effort
 	// responding to expensive requests for it.
 	if err := ErrorIfLocalServerNotInRoom(ctx, rsAPI, roomID); err != nil {
@@ -157,7 +157,7 @@ func getState(
 	return response.StateEvents, response.AuthChainEvents, nil
 }
 
-func getIDsFromEvent(events []*gomatrixserverlib.HeaderedEvent) []string {
+func getIDsFromEvent(events []*types.HeaderedEvent) []string {
 	IDs := make([]string, len(events))
 	for i := range events {
 		IDs[i] = events[i].EventID()

federationapi/routing/threepid.go

@@ -24,6 +24,7 @@ import (
 	"github.com/matrix-org/dendrite/clientapi/httputil"
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/roomserver/api"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/dendrite/setup/config"
 	userapi "github.com/matrix-org/dendrite/userapi/api"
 	"github.com/matrix-org/gomatrixserverlib/fclient"
@@ -67,9 +68,9 @@ func CreateInvitesFrom3PIDInvites(
 		return *reqErr
 	}
 
-	evs := []*gomatrixserverlib.HeaderedEvent{}
+	evs := []*types.HeaderedEvent{}
 	for _, inv := range body.Invites {
-		roomVersion, err := rsAPI.QueryRoomVersionForRoom(req.Context(), inv.RoomID)
+		_, err := rsAPI.QueryRoomVersionForRoom(req.Context(), inv.RoomID)
 		if err != nil {
 			return util.JSONResponse{
 				Code: http.StatusBadRequest,
@@ -85,7 +86,7 @@ func CreateInvitesFrom3PIDInvites(
 			return jsonerror.InternalServerError()
 		}
 		if event != nil {
-			evs = append(evs, event.Headered(roomVersion))
+			evs = append(evs, &types.HeaderedEvent{Event: event})
 		}
 	}
 
@@ -183,7 +184,7 @@ func ExchangeThirdPartyInvite(
 
 	// Ask the requesting server to sign the newly created event so we know it
 	// acknowledged it
-	inviteReq, err := fclient.NewInviteV2Request(event.Headered(roomVersion), nil)
+	inviteReq, err := fclient.NewInviteV2Request(event, nil)
 	if err != nil {
 		util.GetLogger(httpReq.Context()).WithError(err).Error("failed to make invite v2 request")
 		return jsonerror.InternalServerError()
@@ -208,8 +209,8 @@ func ExchangeThirdPartyInvite(
 	if err = api.SendEvents(
 		httpReq.Context(), rsAPI,
 		api.KindNew,
-		[]*gomatrixserverlib.HeaderedEvent{
-			inviteEvent.Headered(roomVersion),
+		[]*types.HeaderedEvent{
+			{Event: inviteEvent},
 		},
 		request.Destination(),
 		request.Origin(),

federationapi/storage/interface.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/matrix-org/dendrite/federationapi/storage/shared/receipt"
 	"github.com/matrix-org/dendrite/federationapi/types"
+	rstypes "github.com/matrix-org/dendrite/roomserver/types"
 )
 
 type Database interface {
@@ -38,7 +39,7 @@ type Database interface {
 
 	StoreJSON(ctx context.Context, js string) (*receipt.Receipt, error)
 
-	GetPendingPDUs(ctx context.Context, serverName spec.ServerName, limit int) (pdus map[*receipt.Receipt]*gomatrixserverlib.HeaderedEvent, err error)
+	GetPendingPDUs(ctx context.Context, serverName spec.ServerName, limit int) (pdus map[*receipt.Receipt]*rstypes.HeaderedEvent, err error)
 	GetPendingEDUs(ctx context.Context, serverName spec.ServerName, limit int) (edus map[*receipt.Receipt]*gomatrixserverlib.EDU, err error)
 
 	AssociatePDUWithDestinations(ctx context.Context, destinations map[spec.ServerName]struct{}, dbReceipt *receipt.Receipt) error

federationapi/storage/shared/storage_pdus.go

@@ -22,7 +22,7 @@ import (
 	"fmt"
 
 	"github.com/matrix-org/dendrite/federationapi/storage/shared/receipt"
-	"github.com/matrix-org/gomatrixserverlib"
+	"github.com/matrix-org/dendrite/roomserver/types"
 	"github.com/matrix-org/gomatrixserverlib/spec"
 )
 
@@ -56,7 +56,7 @@ func (d *Database) GetPendingPDUs(
 	serverName spec.ServerName,
 	limit int,
 ) (
-	events map[*receipt.Receipt]*gomatrixserverlib.HeaderedEvent,
+	events map[*receipt.Receipt]*types.HeaderedEvent,
 	err error,
 ) {
 	// Strictly speaking this doesn't need to be using the writer
@@ -64,7 +64,7 @@ func (d *Database) GetPendingPDUs(
 	// a guarantee of transactional isolation, it's actually useful
 	// to know in SQLite mode that nothing else is trying to modify
 	// the database.
-	events = make(map[*receipt.Receipt]*gomatrixserverlib.HeaderedEvent)
+	events = make(map[*receipt.Receipt]*types.HeaderedEvent)
 	err = d.Writer.Do(d.DB, nil, func(txn *sql.Tx) error {
 		nids, err := d.FederationQueuePDUs.SelectQueuePDUs(ctx, txn, serverName, limit)
 		if err != nil {
@@ -87,7 +87,7 @@ func (d *Database) GetPendingPDUs(
 		}
 
 		for nid, blob := range blobs {
-			var event gomatrixserverlib.HeaderedEvent
+			var event types.HeaderedEvent
 			if err := json.Unmarshal(blob, &event); err != nil {
 				return fmt.Errorf("json.Unmarshal: %w", err)
 			}