[feature] Enable federation in/out of profile PropertyValue fields (#1722)

Co-authored-by: kim <grufwub@gmail.com>
Co-authored-by: kim <89579420+NyaaaWhatsUpDoc@users.noreply.github.com>

10 files changed, 138 insertions, 126 deletions

diff --git a/internal/federation/dereferencing/account.go b/internal/federation/dereferencing/account.go
index 4795db733..b33f1d6fa 100644
--- a/internal/federation/dereferencing/account.go
+++ b/internal/federation/dereferencing/account.go
@@ -38,7 +38,7 @@ import (
 	"github.com/superseriousbusiness/gotosocial/internal/transport"
 )
 
-func (d *deref) GetAccountByURI(ctx context.Context, requestUser string, uri *url.URL, block bool) (*gtsmodel.Account, error) {
+func (d *deref) GetAccountByURI(ctx context.Context, requestUser string, uri *url.URL) (*gtsmodel.Account, error) {
 	var (
 		account *gtsmodel.Account
 		uriStr  = uri.String()
@@ -70,11 +70,11 @@ func (d *deref) GetAccountByURI(ctx context.Context, requestUser string, uri *ur
 			ID:     id.NewULID(),
 			Domain: uri.Host,
 			URI:    uriStr,
-		}, false, true)
+		}, d.defaultFetchLatest, false)
 	}
 
 	// Try to update existing account model
-	enriched, err := d.enrichAccount(ctx, requestUser, uri, account, false, block)
+	enriched, err := d.enrichAccount(ctx, requestUser, uri, account, d.defaultFetchLatest, false)
 	if err != nil {
 		log.Errorf(ctx, "error enriching remote account: %v", err)
 		return account, nil // fall back to returning existing
@@ -83,7 +83,7 @@ func (d *deref) GetAccountByURI(ctx context.Context, requestUser string, uri *ur
 	return enriched, nil
 }
 
-func (d *deref) GetAccountByUsernameDomain(ctx context.Context, requestUser string, username string, domain string, block bool) (*gtsmodel.Account, error) {
+func (d *deref) GetAccountByUsernameDomain(ctx context.Context, requestUser string, username string, domain string) (*gtsmodel.Account, error) {
 	if domain == config.GetHost() || domain == config.GetAccountDomain() {
 		// We do local lookups using an empty domain,
 		// else it will fail the db search below.
@@ -99,19 +99,24 @@ func (d *deref) GetAccountByUsernameDomain(ctx context.Context, requestUser stri
 	if account == nil {
 		// Check for failed local lookup.
 		if domain == "" {
-			return nil, NewErrNotRetrievable(err) // will be db.ErrNoEntries
+			return nil, NewErrNotRetrievable(err) // wrapped err will be db.ErrNoEntries
 		}
 
 		// Create and pass-through a new bare-bones model for dereferencing.
-		return d.enrichAccount(ctx, requestUser, nil, &gtsmodel.Account{
+		account = &gtsmodel.Account{
 			ID:       id.NewULID(),
 			Username: username,
 			Domain:   domain,
-		}, false, true)
+		}
+
+		// There's no known account to fall back on,
+		// so return error if we can't enrich account.
+		return d.enrichAccount(ctx, requestUser, nil, account, d.defaultFetchLatest, false)
 	}
 
-	// Try to update existing account model
-	enriched, err := d.enrichAccount(ctx, requestUser, nil, account, false, block)
+	// We knew about this account already;
+	// try to update existing account model.
+	enriched, err := d.enrichAccount(ctx, requestUser, nil, account, d.defaultFetchLatest, false)
 	if err != nil {
 		log.Errorf(ctx, "error enriching account from remote: %v", err)
 		return account, nil // fall back to returning unchanged existing account model
@@ -120,12 +125,62 @@ func (d *deref) GetAccountByUsernameDomain(ctx context.Context, requestUser stri
 	return enriched, nil
 }
 
-func (d *deref) UpdateAccount(ctx context.Context, requestUser string, account *gtsmodel.Account, force bool) (*gtsmodel.Account, error) {
-	return d.enrichAccount(ctx, requestUser, nil, account, force, false)
+func (d *deref) RefreshAccount(ctx context.Context, requestUser string, accountable ap.Accountable, account *gtsmodel.Account) (*gtsmodel.Account, error) {
+	// To avoid unnecessarily refetching multiple times from remote,
+	// we can just pass in the Accountable object that we received,
+	// if it was defined. If not, fall back to default fetch func.
+	var f fetchLatest
+	if accountable != nil {
+		f = func(
+			_ context.Context,
+			_ transport.Transport,
+			_ *url.URL,
+			_ string,
+		) (ap.Accountable, *gtsmodel.Account, error) {
+			return accountable, account, nil
+		}
+	} else {
+		f = d.defaultFetchLatest
+	}
+
+	// Set 'force' to 'true' to always fetch latest media etc.
+	return d.enrichAccount(ctx, requestUser, nil, account, f, true)
+}
+
+// fetchLatest defines a function for using a transport and uri to fetch the fetchLatest
+// version of an account (and its AP representation) from a remote instance.
+type fetchLatest func(ctx context.Context, transport transport.Transport, uri *url.URL, accountDomain string) (ap.Accountable, *gtsmodel.Account, error)
+
+// defaultFetchLatest deduplicates latest fetching code that is used in several
+// different functions. It simply calls the remote uri using the given transport,
+// parses a returned AP representation into an account, and then returns both.
+func (d *deref) defaultFetchLatest(ctx context.Context, transport transport.Transport, uri *url.URL, accountDomain string) (ap.Accountable, *gtsmodel.Account, error) {
+	// Dereference this account to get the latest available.
+	apubAcc, err := d.dereferenceAccountable(ctx, transport, uri)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error dereferencing account %s: %w", uri, err)
+	}
+
+	// Convert the dereferenced AP account object to our GTS model.
+	latestAcc, err := d.typeConverter.ASRepresentationToAccount(
+		ctx, apubAcc, accountDomain,
+	)
+	if err != nil {
+		return nil, nil, fmt.Errorf("error converting accountable to gts model for account %s: %w", uri, err)
+	}
+
+	return apubAcc, latestAcc, nil
 }
 
 // enrichAccount will ensure the given account is the most up-to-date model of the account, re-webfingering and re-dereferencing if necessary.
-func (d *deref) enrichAccount(ctx context.Context, requestUser string, uri *url.URL, account *gtsmodel.Account, force, block bool) (*gtsmodel.Account, error) {
+func (d *deref) enrichAccount(
+	ctx context.Context,
+	requestUser string,
+	uri *url.URL,
+	account *gtsmodel.Account,
+	f fetchLatest,
+	force bool,
+) (*gtsmodel.Account, error) {
 	if account.IsLocal() {
 		// Can't update local accounts.
 		return account, nil
@@ -205,18 +260,10 @@ func (d *deref) enrichAccount(ctx context.Context, requestUser string, uri *url.
 	d.startHandshake(requestUser, uri)
 	defer d.stopHandshake(requestUser, uri)
 
-	// Dereference this account to get the latest available.
-	apubAcc, err := d.dereferenceAccountable(ctx, transport, uri)
-	if err != nil {
-		return nil, fmt.Errorf("enrichAccount: error dereferencing account %s: %w", uri, err)
-	}
-
-	// Convert the dereferenced AP account object to our GTS model.
-	latestAcc, err := d.typeConverter.ASRepresentationToAccount(
-		ctx, apubAcc, account.Domain,
-	)
+	// Fetch latest version of the account, dereferencing if necessary.
+	apubAcc, latestAcc, err := f(ctx, transport, uri, account.Domain)
 	if err != nil {
-		return nil, fmt.Errorf("enrichAccount: error converting accountable to gts model for account %s: %w", uri, err)
+		return nil, fmt.Errorf("enrichAccount: error calling fetchLatest function: %w", err)
 	}
 
 	if account.Username == "" {
@@ -256,11 +303,11 @@ func (d *deref) enrichAccount(ctx context.Context, requestUser string, uri *url.
 	latestAcc.ID = account.ID
 	latestAcc.FetchedAt = time.Now()
 
-	// Use the existing account media attachments by default.
+	// Reuse the existing account media attachments by default.
 	latestAcc.AvatarMediaAttachmentID = account.AvatarMediaAttachmentID
 	latestAcc.HeaderMediaAttachmentID = account.HeaderMediaAttachmentID
 
-	if latestAcc.AvatarRemoteURL != account.AvatarRemoteURL {
+	if force || (latestAcc.AvatarRemoteURL != account.AvatarRemoteURL) {
 		// Reset the avatar media ID (handles removed).
 		latestAcc.AvatarMediaAttachmentID = ""
 
@@ -281,7 +328,7 @@ func (d *deref) enrichAccount(ctx context.Context, requestUser string, uri *url.
 		}
 	}
 
-	if latestAcc.HeaderRemoteURL != account.HeaderRemoteURL {
+	if force || (latestAcc.HeaderRemoteURL != account.HeaderRemoteURL) {
 		// Reset the header media ID (handles removed).
 		latestAcc.HeaderMediaAttachmentID = ""
 
diff --git a/internal/federation/dereferencing/account_test.go b/internal/federation/dereferencing/account_test.go
index ce399f308..c4b946f5b 100644
--- a/internal/federation/dereferencing/account_test.go
+++ b/internal/federation/dereferencing/account_test.go
@@ -41,7 +41,6 @@ func (suite *AccountTestSuite) TestDereferenceGroup() {
 		context.Background(),
 		fetchingAccount.Username,
 		groupURL,
-		false,
 	)
 	suite.NoError(err)
 	suite.NotNil(group)
@@ -66,7 +65,6 @@ func (suite *AccountTestSuite) TestDereferenceService() {
 		context.Background(),
 		fetchingAccount.Username,
 		serviceURL,
-		false,
 	)
 	suite.NoError(err)
 	suite.NotNil(service)
@@ -99,7 +97,6 @@ func (suite *AccountTestSuite) TestDereferenceLocalAccountAsRemoteURL() {
 		context.Background(),
 		fetchingAccount.Username,
 		testrig.URLMustParse(targetAccount.URI),
-		false,
 	)
 	suite.NoError(err)
 	suite.NotNil(fetchedAccount)
@@ -119,7 +116,6 @@ func (suite *AccountTestSuite) TestDereferenceLocalAccountAsRemoteURLNoSharedInb
 		context.Background(),
 		fetchingAccount.Username,
 		testrig.URLMustParse(targetAccount.URI),
-		false,
 	)
 	suite.NoError(err)
 	suite.NotNil(fetchedAccount)
@@ -134,7 +130,6 @@ func (suite *AccountTestSuite) TestDereferenceLocalAccountAsUsername() {
 		context.Background(),
 		fetchingAccount.Username,
 		testrig.URLMustParse(targetAccount.URI),
-		false,
 	)
 	suite.NoError(err)
 	suite.NotNil(fetchedAccount)
@@ -149,7 +144,6 @@ func (suite *AccountTestSuite) TestDereferenceLocalAccountAsUsernameDomain() {
 		context.Background(),
 		fetchingAccount.Username,
 		testrig.URLMustParse(targetAccount.URI),
-		false,
 	)
 	suite.NoError(err)
 	suite.NotNil(fetchedAccount)
@@ -165,7 +159,6 @@ func (suite *AccountTestSuite) TestDereferenceLocalAccountAsUsernameDomainAndURL
 		fetchingAccount.Username,
 		targetAccount.Username,
 		config.GetHost(),
-		false,
 	)
 	suite.NoError(err)
 	suite.NotNil(fetchedAccount)
@@ -180,7 +173,6 @@ func (suite *AccountTestSuite) TestDereferenceLocalAccountWithUnknownUsername()
 		fetchingAccount.Username,
 		"thisaccountdoesnotexist",
 		config.GetHost(),
-		false,
 	)
 	var errNotRetrievable *dereferencing.ErrNotRetrievable
 	suite.ErrorAs(err, &errNotRetrievable)
@@ -196,7 +188,6 @@ func (suite *AccountTestSuite) TestDereferenceLocalAccountWithUnknownUsernameDom
 		fetchingAccount.Username,
 		"thisaccountdoesnotexist",
 		"localhost:8080",
-		false,
 	)
 	var errNotRetrievable *dereferencing.ErrNotRetrievable
 	suite.ErrorAs(err, &errNotRetrievable)
@@ -211,7 +202,6 @@ func (suite *AccountTestSuite) TestDereferenceLocalAccountWithUnknownUserURI() {
 		context.Background(),
 		fetchingAccount.Username,
 		testrig.URLMustParse("http://localhost:8080/users/thisaccountdoesnotexist"),
-		false,
 	)
 	var errNotRetrievable *dereferencing.ErrNotRetrievable
 	suite.ErrorAs(err, &errNotRetrievable)
diff --git a/internal/federation/dereferencing/dereferencer.go b/internal/federation/dereferencing/dereferencer.go
index 7c00ceec5..181196caa 100644
--- a/internal/federation/dereferencing/dereferencer.go
+++ b/internal/federation/dereferencing/dereferencer.go
@@ -35,14 +35,15 @@ import (
 type Dereferencer interface {
 	// GetAccountByURI will attempt to fetch an account by its URI, first checking the database and in the case of a remote account will either check the
 	// last_fetched (and updating if beyond fetch interval) or dereferencing for the first-time if this remote account has never been encountered before.
-	GetAccountByURI(ctx context.Context, requestUser string, uri *url.URL, block bool) (*gtsmodel.Account, error)
+	GetAccountByURI(ctx context.Context, requestUser string, uri *url.URL) (*gtsmodel.Account, error)
 
 	// GetAccountByUsernameDomain will attempt to fetch an account by username@domain, first checking the database and in the case of a remote account will either
 	// check the last_fetched (and updating if beyond fetch interval) or dereferencing for the first-time if this remote account has never been encountered before.
-	GetAccountByUsernameDomain(ctx context.Context, requestUser string, username string, domain string, block bool) (*gtsmodel.Account, error)
+	GetAccountByUsernameDomain(ctx context.Context, requestUser string, username string, domain string) (*gtsmodel.Account, error)
 
-	// UpdateAccount updates the given account if last_fetched is beyond fetch interval (or if force is set). An updated account model is returned, any media fetching is done async.
-	UpdateAccount(ctx context.Context, requestUser string, account *gtsmodel.Account, force bool) (*gtsmodel.Account, error)
+	// RefreshAccount forces a refresh of the given account by fetching the current/latest state of the account from the remote instance.
+	// An updated account model is returned, but not yet inserted/updated in the database; this is the caller's responsibility.
+	RefreshAccount(ctx context.Context, requestUser string, accountable ap.Accountable, account *gtsmodel.Account) (*gtsmodel.Account, error)
 
 	GetStatus(ctx context.Context, username string, remoteStatusID *url.URL, refetch, includeParent bool) (*gtsmodel.Status, ap.Statusable, error)
 
diff --git a/internal/federation/dereferencing/status.go b/internal/federation/dereferencing/status.go
index fe07be23a..8e130393a 100644
--- a/internal/federation/dereferencing/status.go
+++ b/internal/federation/dereferencing/status.go
@@ -125,7 +125,7 @@ func (d *deref) GetStatus(ctx context.Context, username string, statusURI *url.U
 	}
 
 	// we need to get the author of the status else we can't serialize it properly
-	if _, err = d.GetAccountByURI(ctx, username, accountURI, true); err != nil {
+	if _, err = d.GetAccountByURI(ctx, username, accountURI); err != nil {
 		return nil, nil, newErrOther(fmt.Errorf("GetRemoteStatus: couldn't get status author: %s", err))
 	}
 
@@ -278,7 +278,7 @@ func (d *deref) populateStatusMentions(ctx context.Context, status *gtsmodel.Sta
 		if targetAccount == nil {
 			// we didn't find the account in our database already
 			// check if we can get the account remotely (dereference it)
-			if a, err := d.GetAccountByURI(ctx, requestingUsername, targetAccountURI, false); err != nil {
+			if a, err := d.GetAccountByURI(ctx, requestingUsername, targetAccountURI); err != nil {
 				errs = append(errs, err.Error())
 			} else {
 				log.Debugf(ctx, "got target account %s with id %s through GetRemoteAccount", targetAccountURI, a.ID)
diff --git a/internal/federation/federatingactor.go b/internal/federation/federatingactor.go
index 18cdf2106..33ae38220 100644
--- a/internal/federation/federatingactor.go
+++ b/internal/federation/federatingactor.go
@@ -59,11 +59,11 @@ type federatingActor struct {
 // implements the pub.FederatingActor interface.
 func newFederatingActor(c pub.CommonBehavior, s2s pub.FederatingProtocol, db pub.Database, clock pub.Clock) pub.FederatingActor {
 	sideEffectActor := pub.NewSideEffectActor(c, s2s, nil, db, clock)
-	customActor := pub.NewCustomActor(sideEffectActor, false, true, clock)
+	sideEffectActor.Serialize = ap.Serialize // hook in our own custom Serialize function
 
 	return &federatingActor{
 		sideEffectActor: sideEffectActor,
-		wrapped:         customActor,
+		wrapped:         pub.NewCustomActor(sideEffectActor, false, true, clock),
 	}
 }
 
@@ -165,7 +165,8 @@ func (f *federatingActor) PostInboxScheme(ctx context.Context, w http.ResponseWr
 	// If activity Object is a Statusable, we'll want to replace the
 	// parsed `content` value with the value from the raw JSON instead.
 	// See https://github.com/superseriousbusiness/gotosocial/issues/1661
-	ap.NormalizeActivityObject(activity, rawActivity)
+	// Likewise, if it's an Accountable, we'll normalize some fields on it.
+	ap.NormalizeIncomingActivityObject(activity, rawActivity)
 
 	// Allow server implementations to set context data with a hook.
 	ctx, err = f.sideEffectActor.PostInboxRequestBodyHook(ctx, r, activity)
diff --git a/internal/federation/federatingdb/followers_test.go b/internal/federation/federatingdb/followers_test.go
index fb660d147..f6297ec8c 100644
--- a/internal/federation/federatingdb/followers_test.go
+++ b/internal/federation/federatingdb/followers_test.go
@@ -23,7 +23,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/suite"
-	"github.com/superseriousbusiness/activity/streams"
+	"github.com/superseriousbusiness/gotosocial/internal/ap"
 	"github.com/superseriousbusiness/gotosocial/testrig"
 )
 
@@ -37,7 +37,7 @@ func (suite *FollowersTestSuite) TestGetFollowers() {
 	f, err := suite.federatingDB.Followers(context.Background(), testrig.URLMustParse(testAccount.URI))
 	suite.NoError(err)
 
-	fi, err := streams.Serialize(f)
+	fi, err := ap.Serialize(f)
 	suite.NoError(err)
 
 	fJson, err := json.MarshalIndent(fi, "", "  ")
diff --git a/internal/federation/federatingdb/following_test.go b/internal/federation/federatingdb/following_test.go
index ae616b39f..83d1a72b5 100644
--- a/internal/federation/federatingdb/following_test.go
+++ b/internal/federation/federatingdb/following_test.go
@@ -23,7 +23,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/suite"
-	"github.com/superseriousbusiness/activity/streams"
+	"github.com/superseriousbusiness/gotosocial/internal/ap"
 	"github.com/superseriousbusiness/gotosocial/testrig"
 )
 
@@ -37,7 +37,7 @@ func (suite *FollowingTestSuite) TestGetFollowing() {
 	f, err := suite.federatingDB.Following(context.Background(), testrig.URLMustParse(testAccount.URI))
 	suite.NoError(err)
 
-	fi, err := streams.Serialize(f)
+	fi, err := ap.Serialize(f)
 	suite.NoError(err)
 
 	fJson, err := json.MarshalIndent(fi, "", "  ")
diff --git a/internal/federation/federatingdb/update.go b/internal/federation/federatingdb/update.go
index 5121418e5..5c8785c08 100644
--- a/internal/federation/federatingdb/update.go
+++ b/internal/federation/federatingdb/update.go
@@ -54,96 +54,69 @@ func (f *federatingDB) Update(ctx context.Context, asType vocab.Type) error {
 
 	receivingAccount, _ := extractFromCtx(ctx)
 	if receivingAccount == nil {
-		// If the receiving account wasn't set on the context, that means this request didn't pass
-		// through the API, but came from inside GtS as the result of another activity on this instance. That being so,
-		// we can safely just ignore this activity, since we know we've already processed it elsewhere.
+		// If the receiving account wasn't set on the context, that means
+		// this request didn't pass through the API, but came from inside
+		// GtS as the result of another activity on this instance. As such,
+		// we must have already processed it in order to reach this stage.
 		return nil
 	}
 
 	requestingAcctI := ctx.Value(ap.ContextRequestingAccount)
 	if requestingAcctI == nil {
-		l.Error("UPDATE: requesting account wasn't set on context")
+		return errors.New("Update: requesting account wasn't set on context")
 	}
+
 	requestingAcct, ok := requestingAcctI.(*gtsmodel.Account)
 	if !ok {
-		l.Error("UPDATE: requesting account was set on context but couldn't be parsed")
+		return errors.New("Update: requesting account was set on context but couldn't be parsed")
 	}
 
-	typeName := asType.GetTypeName()
-	if typeName == ap.ActorApplication ||
-		typeName == ap.ActorGroup ||
-		typeName == ap.ActorOrganization ||
-		typeName == ap.ActorPerson ||
-		typeName == ap.ActorService {
-		// it's an UPDATE to some kind of account
-		var accountable ap.Accountable
-		switch typeName {
-		case ap.ActorApplication:
-			l.Debug("got update for APPLICATION")
-			i, ok := asType.(vocab.ActivityStreamsApplication)
-			if !ok {
-				return errors.New("UPDATE: could not convert type to application")
-			}
-			accountable = i
-		case ap.ActorGroup:
-			l.Debug("got update for GROUP")
-			i, ok := asType.(vocab.ActivityStreamsGroup)
-			if !ok {
-				return errors.New("UPDATE: could not convert type to group")
-			}
-			accountable = i
-		case ap.ActorOrganization:
-			l.Debug("got update for ORGANIZATION")
-			i, ok := asType.(vocab.ActivityStreamsOrganization)
-			if !ok {
-				return errors.New("UPDATE: could not convert type to organization")
-			}
-			accountable = i
-		case ap.ActorPerson:
-			l.Debug("got update for PERSON")
-			i, ok := asType.(vocab.ActivityStreamsPerson)
-			if !ok {
-				return errors.New("UPDATE: could not convert type to person")
-			}
-			accountable = i
-		case ap.ActorService:
-			l.Debug("got update for SERVICE")
-			i, ok := asType.(vocab.ActivityStreamsService)
-			if !ok {
-				return errors.New("UPDATE: could not convert type to service")
-			}
-			accountable = i
-		}
+	switch asType.GetTypeName() {
+	case ap.ActorApplication, ap.ActorGroup, ap.ActorOrganization, ap.ActorPerson, ap.ActorService:
+		return f.updateAccountable(ctx, receivingAccount, requestingAcct, asType)
+	}
 
-		updatedAcct, err := f.typeConverter.ASRepresentationToAccount(ctx, accountable, "")
-		if err != nil {
-			return fmt.Errorf("UPDATE: error converting to account: %s", err)
-		}
+	return nil
+}
 
-		if updatedAcct.Domain == config.GetHost() || updatedAcct.Domain == config.GetAccountDomain() {
-			// no need to update local accounts
-			// in fact, if we do this will break the shit out of things so do NOT
-			return nil
-		}
+func (f *federatingDB) updateAccountable(ctx context.Context, receivingAcct *gtsmodel.Account, requestingAcct *gtsmodel.Account, asType vocab.Type) error {
+	accountable, ok := asType.(ap.Accountable)
+	if !ok {
+		return errors.New("updateAccountable: could not convert vocab.Type to Accountable")
+	}
 
-		if requestingAcct.URI != updatedAcct.URI {
-			return fmt.Errorf("UPDATE: update for account %s was requested by account %s, this is not valid", updatedAcct.URI, requestingAcct.URI)
-		}
+	updatedAcct, err := f.typeConverter.ASRepresentationToAccount(ctx, accountable, "")
+	if err != nil {
+		return fmt.Errorf("updateAccountable: error converting to account: %w", err)
+	}
+
+	if updatedAcct.Domain == config.GetHost() || updatedAcct.Domain == config.GetAccountDomain() {
+		// No need to update local accounts; in fact, if we try
+		// this it will break the shit out of things so do NOT.
+		return nil
+	}
 
-		// set some fields here on the updatedAccount representation so we don't run into db issues
-		updatedAcct.CreatedAt = requestingAcct.CreatedAt
-		updatedAcct.ID = requestingAcct.ID
-		updatedAcct.Language = requestingAcct.Language
-
-		// pass to the processor for further updating of eg., avatar/header, emojis
-		// the actual db insert/update will take place a bit later
-		f.state.Workers.EnqueueFederator(ctx, messages.FromFederator{
-			APObjectType:     ap.ObjectProfile,
-			APActivityType:   ap.ActivityUpdate,
-			GTSModel:         updatedAcct,
-			ReceivingAccount: receivingAccount,
-		})
+	if requestingAcct.URI != updatedAcct.URI {
+		return fmt.Errorf("updateAccountable: update for account %s was requested by account %s, this is not valid", updatedAcct.URI, requestingAcct.URI)
 	}
 
+	// Set some basic fields on the updated account
+	// based on what we already know about the requester.
+	updatedAcct.CreatedAt = requestingAcct.CreatedAt
+	updatedAcct.ID = requestingAcct.ID
+	updatedAcct.Language = requestingAcct.Language
+	updatedAcct.AvatarMediaAttachmentID = requestingAcct.AvatarMediaAttachmentID
+	updatedAcct.HeaderMediaAttachmentID = requestingAcct.HeaderMediaAttachmentID
+
+	// Pass to the processor for further updating of eg., avatar/header,
+	// emojis, etc. The actual db insert/update will take place there.
+	f.state.Workers.EnqueueFederator(ctx, messages.FromFederator{
+		APObjectType:     ap.ObjectProfile,
+		APActivityType:   ap.ActivityUpdate,
+		GTSModel:         updatedAcct,
+		APObjectModel:    accountable,
+		ReceivingAccount: receivingAcct,
+	})
+
 	return nil
 }
diff --git a/internal/federation/federatingdb/util.go b/internal/federation/federatingdb/util.go
index 5137145f2..8e9f67c59 100644
--- a/internal/federation/federatingdb/util.go
+++ b/internal/federation/federatingdb/util.go
@@ -325,7 +325,7 @@ func extractFromCtx(ctx context.Context) (receivingAccount, requestingAccount *g
 }
 
 func marshalItem(item vocab.Type) (string, error) {
-	m, err := streams.Serialize(item)
+	m, err := ap.Serialize(item)
 	if err != nil {
 		return "", err
 	}
diff --git a/internal/federation/federatingprotocol.go b/internal/federation/federatingprotocol.go
index 7995faa84..e81a409f0 100644
--- a/internal/federation/federatingprotocol.go
+++ b/internal/federation/federatingprotocol.go
@@ -211,7 +211,7 @@ func (f *federator) AuthenticatePostInbox(ctx context.Context, w http.ResponseWr
 	// dereference the remote account (or just get it
 	// from the db if we already have it).
 	requestingAccount, err := f.GetAccountByURI(
-		gtscontext.SetFastFail(ctx), username, publicKeyOwnerURI, false,
+		gtscontext.SetFastFail(ctx), username, publicKeyOwnerURI,
 	)
 	if err != nil {
 		if gtserror.StatusCode(err) == http.StatusGone {