diff --git a/vendor/manifest b/vendor/manifest
index 61f8d20aa..bc0297d6c 100644
--- a/vendor/manifest
+++ b/vendor/manifest
@@ -92,7 +92,7 @@
 		{
 			"importpath": "github.com/matrix-org/gomatrixserverlib",
 			"repository": "https://github.com/matrix-org/gomatrixserverlib",
-			"revision": "775bc0b4341689c9fbb573008c3095495738f092",
+			"revision": "e757e4f7f675c7356d4b2953059718f1b4598a08",
 			"branch": "master"
 		},
 		{
@@ -206,4 +206,4 @@
 			"branch": "master"
 		}
 	]
-}
\ No newline at end of file
+}
diff --git a/vendor/src/github.com/matrix-org/gomatrixserverlib/event.go b/vendor/src/github.com/matrix-org/gomatrixserverlib/event.go
index 439642a31..126830307 100644
--- a/vendor/src/github.com/matrix-org/gomatrixserverlib/event.go
+++ b/vendor/src/github.com/matrix-org/gomatrixserverlib/event.go
@@ -22,6 +22,18 @@ import (
 	"time"
 )
 
+// A StateKeyTuple is the combination of an event type and an event state key.
+// It is often used as a key in maps.
+type StateKeyTuple struct {
+	// The "type" key of a matrix event.
+	EventType string
+	// The "state_key" of a matrix event.
+	// The empty string is a legitimate value for the "state_key" in matrix
+	// so take care to initialise this field lest you accidentally request a
+	// "state_key" with the go default of the empty string.
+	StateKey string
+}
+
 // An EventReference is a reference to a matrix event.
 type EventReference struct {
 	// The event ID of the event.
diff --git a/vendor/src/github.com/matrix-org/gomatrixserverlib/eventauth.go b/vendor/src/github.com/matrix-org/gomatrixserverlib/eventauth.go
index 523c0c939..e7d5c5156 100644
--- a/vendor/src/github.com/matrix-org/gomatrixserverlib/eventauth.go
+++ b/vendor/src/github.com/matrix-org/gomatrixserverlib/eventauth.go
@@ -44,6 +44,69 @@ type StateNeeded struct {
 	ThirdPartyInvite []string
 }
 
+// Tuples returns the needed state key tuples for performing auth on an event.
+func (s StateNeeded) Tuples() (res []StateKeyTuple) {
+	if s.Create {
+		res = append(res, StateKeyTuple{"m.room.create", ""})
+	}
+	if s.JoinRules {
+		res = append(res, StateKeyTuple{"m.room.join_rules", ""})
+	}
+	if s.PowerLevels {
+		res = append(res, StateKeyTuple{"m.room.power_levels", ""})
+	}
+	for _, userID := range s.Member {
+		res = append(res, StateKeyTuple{"m.room.member", userID})
+	}
+	for _, token := range s.ThirdPartyInvite {
+		res = append(res, StateKeyTuple{"m.room.third_party_invite", token})
+	}
+	return
+}
+
+// AuthEventReferences returns the auth_events references for the StateNeeded. Returns an error if the
+// provider returns an error. If an event is missing from the provider but is required in StateNeeded, it
+// is skipped over: no error is returned.
+func (s StateNeeded) AuthEventReferences(provider AuthEventProvider) (refs []EventReference, err error) {
+	var e *Event
+	if s.Create {
+		if e, err = provider.Create(); err != nil {
+			return
+		} else if e != nil {
+			refs = append(refs, e.EventReference())
+		}
+	}
+	if s.JoinRules {
+		if e, err = provider.JoinRules(); err != nil {
+			return
+		} else if e != nil {
+			refs = append(refs, e.EventReference())
+		}
+	}
+	if s.PowerLevels {
+		if e, err = provider.PowerLevels(); err != nil {
+			return
+		} else if e != nil {
+			refs = append(refs, e.EventReference())
+		}
+	}
+	for _, userID := range s.Member {
+		if e, err = provider.Member(userID); err != nil {
+			return
+		} else if e != nil {
+			refs = append(refs, e.EventReference())
+		}
+	}
+	for _, token := range s.ThirdPartyInvite {
+		if e, err = provider.ThirdPartyInvite(token); err != nil {
+			return
+		} else if e != nil {
+			refs = append(refs, e.EventReference())
+		}
+	}
+	return
+}
+
 // StateNeededForEventBuilder returns the event types and state_keys needed to authenticate the
 // event being built. These events should be put under 'auth_events' for the event being built.
 // Returns an error if the state needed could not be calculated with the given builder, e.g
@@ -175,14 +238,9 @@ type AuthEventProvider interface {
 	ThirdPartyInvite(stateKey string) (*Event, error)
 }
 
-type stateKeyTuple struct {
-	Type     string
-	StateKey string
-}
-
 // AuthEvents is an implementation of AuthEventProvider backed by a map.
 type AuthEvents struct {
-	events map[stateKeyTuple]*Event
+	events map[StateKeyTuple]*Event
 }
 
 // AddEvent adds an event to the provider. If an event already existed for the (type, state_key) then
@@ -191,39 +249,39 @@ func (a *AuthEvents) AddEvent(event *Event) error {
 	if event.StateKey() == nil {
 		return fmt.Errorf("AddEvent: event %s does not have a state key", event.Type())
 	}
-	a.events[stateKeyTuple{event.Type(), *event.StateKey()}] = event
+	a.events[StateKeyTuple{event.Type(), *event.StateKey()}] = event
 	return nil
 }
 
 // Create implements AuthEventProvider
 func (a *AuthEvents) Create() (*Event, error) {
-	return a.events[stateKeyTuple{"m.room.create", ""}], nil
+	return a.events[StateKeyTuple{"m.room.create", ""}], nil
 }
 
 // JoinRules implements AuthEventProvider
 func (a *AuthEvents) JoinRules() (*Event, error) {
-	return a.events[stateKeyTuple{"m.room.join_rules", ""}], nil
+	return a.events[StateKeyTuple{"m.room.join_rules", ""}], nil
 }
 
 // PowerLevels implements AuthEventProvider
 func (a *AuthEvents) PowerLevels() (*Event, error) {
-	return a.events[stateKeyTuple{"m.room.power_levels", ""}], nil
+	return a.events[StateKeyTuple{"m.room.power_levels", ""}], nil
 }
 
 // Member implements AuthEventProvider
 func (a *AuthEvents) Member(stateKey string) (*Event, error) {
-	return a.events[stateKeyTuple{"m.room.member", stateKey}], nil
+	return a.events[StateKeyTuple{"m.room.member", stateKey}], nil
 }
 
 // ThirdPartyInvite implements AuthEventProvider
 func (a *AuthEvents) ThirdPartyInvite(stateKey string) (*Event, error) {
-	return a.events[stateKeyTuple{"m.room.third_party_invite", stateKey}], nil
+	return a.events[StateKeyTuple{"m.room.third_party_invite", stateKey}], nil
 }
 
 // NewAuthEvents returns an AuthEventProvider backed by the given events. New events can be added by
 // calling AddEvent().
 func NewAuthEvents(events []*Event) AuthEvents {
-	a := AuthEvents{make(map[stateKeyTuple]*Event)}
+	a := AuthEvents{make(map[StateKeyTuple]*Event)}
 	for _, e := range events {
 		a.AddEvent(e)
 	}