refactor(accounts): remove duplication for backed up settings

Fixes status-im/status-desktop#18344

Removes the duplication in the accounts service by moving the shared code to the syncing module.

Removes as much as much as possible the use of the Messenger. The signal sending still uses the Messenger for now.

Author: jrainville

api/geth_backend.go

@@ -2362,7 +2362,7 @@ func (b *GethStatusBackend) initProtocol() error {
 	messenger := st.Messenger()
 	// Init public status api
 	b.statusNode.StatusPublicService().Init(messenger)
-	b.statusNode.AccountService().Init(messenger)
+	b.statusNode.AccountService().Init(messenger, acc)
 	// Init chat service
 	accDB, err := accounts.NewDB(b.appDB)
 	if err != nil {

node/status_node_services.go

@@ -189,6 +189,7 @@ func (b *StatusNode) accountsService(accDB *accounts.Database, mediaServer *serv
 			b.config,
 			b.accountsPublisher,
 			mediaServer,
+			b.logger.Named("AccountsService"),
 		)
 	}
 

protocol/messenger_backup_handler.go

@@ -174,53 +174,6 @@ func (m *Messenger) handleBackedUpProfile(message *protobuf.BackedUpProfile, bac
 	return err
 }
 
-// TODO move this to the AccountsService
-func (m *Messenger) HandleBackedUpSettings(message *protobuf.SyncSetting) error {
-	if message == nil {
-		return nil
-	}
-
-	// DisplayName is recovered via `protobuf.BackedUpProfile` message
-	if message.GetType() == protobuf.SyncSetting_DISPLAY_NAME {
-		return nil
-	}
-
-	settingField, err := m.extractAndSaveSyncSetting(message)
-	if err != nil {
-		m.logger.Warn("failed to handle SyncSetting from backed up message", zap.Error(err))
-		return nil
-	}
-
-	if settingField != nil {
-		if message.GetType() == protobuf.SyncSetting_PREFERRED_NAME && message.GetValueString() != "" {
-			displayNameClock, err := m.settings.GetSettingLastSynced(settings.DisplayName)
-			if err != nil {
-				m.logger.Warn("failed to get last synced clock for display name", zap.Error(err))
-				return nil
-			}
-			// there is a race condition between display name and preferred name on updating m.account.Name, so we need to check the clock
-			// there is also a similar check within SaveSyncDisplayName
-			if displayNameClock < message.GetClock() {
-				m.account.Name = message.GetValueString()
-				err = m.multiAccounts.SaveAccount(*m.account)
-				if err != nil {
-					m.logger.Warn("[HandleBackedUpSettings] failed to save account", zap.Error(err))
-					return nil
-				}
-			}
-		}
-
-		if m.config.messengerSignalsHandler != nil {
-			response := wakusync.WakuBackedUpDataResponse{
-				Setting: settingField,
-			}
-			m.config.messengerSignalsHandler.SendWakuBackedUpSettings(&response)
-		}
-	}
-
-	return nil
-}
-
 func syncInstallationCommunitiesSet(communities []*protobuf.SyncInstallationCommunity) map[string]*protobuf.SyncInstallationCommunity {
 	ret := map[string]*protobuf.SyncInstallationCommunity{}
 	for _, c := range communities {
@@ -250,6 +203,15 @@ func (m *Messenger) handleLocalBackupCommunities(state *ReceivedMessageState, co
 	return errors
 }
 
+func (m *Messenger) PublishSettingEvent(settingField *settings.SyncSettingField) {
+	if m.config.messengerSignalsHandler != nil {
+		response := wakusync.WakuBackedUpDataResponse{
+			Setting: settingField,
+		}
+		m.config.messengerSignalsHandler.SendWakuBackedUpSettings(&response)
+	}
+}
+
 func (m *Messenger) requestCommunityKeysAndSharedAddresses(syncCommunity *protobuf.SyncInstallationCommunity) error {
 	if !syncCommunity.Joined {
 		return nil

protocol/messenger_config.go

@@ -54,7 +54,6 @@ type MessengerSignalsHandler interface {
 	DiscordChannelImportProgress(importProgress *discord.ImportProgress)
 	DiscordChannelImportFinished(communityID string, channelID string)
 	DiscordChannelImportCancelled(channelID string)
-	SendWakuFetchingBackupProgress(response *wakusync.WakuBackedUpDataResponse)
 	SendWakuBackedUpProfile(response *wakusync.WakuBackedUpDataResponse)
 	SendWakuBackedUpSettings(response *wakusync.WakuBackedUpDataResponse)
 	SendWakuBackedUpKeypair(response *wakusync.WakuBackedUpDataResponse)

protocol/messenger_handler.go

@@ -2538,7 +2538,7 @@ func (m *Messenger) HandleRequestAddressForTransaction(messageState *ReceivedMes
 }
 
 func (m *Messenger) HandleSyncSetting(messageState *ReceivedMessageState, message *protobuf.SyncSetting, statusMessage *messagingtypes.Message) error {
-	settingField, err := m.extractAndSaveSyncSetting(message)
+	settingField, err := syncing.ExtractAndSaveSyncSetting(m.settings, m.logger, message)
 	if err != nil {
 		return err
 	}

protocol/messenger_sync_settings.go

@@ -2,14 +2,12 @@ package protocol
 
 import (
 	"context"
-	"encoding/json"
 	errorsLib "errors"
 
 	"go.uber.org/zap"
 
 	gocommon "github.com/status-im/status-go/common"
 	messagingtypes "github.com/status-im/status-go/messaging/types"
-	"github.com/status-im/status-go/multiaccounts/errors"
 	"github.com/status-im/status-go/multiaccounts/settings"
 	"github.com/status-im/status-go/protocol/protobuf"
 )
@@ -83,46 +81,6 @@ func (m *Messenger) syncSettings(rawMessageHandler RawMessageHandler) error {
 	return nil
 }
 
-// extractSyncSetting parses incoming *protobuf.SyncSetting and stores the setting data if needed
-func (m *Messenger) extractAndSaveSyncSetting(syncSetting *protobuf.SyncSetting) (*settings.SyncSettingField, error) {
-	sf, err := settings.GetFieldFromProtobufType(syncSetting.Type)
-	if err != nil {
-		m.logger.Error(
-			"extractSyncSetting - settings.GetFieldFromProtobufType",
-			zap.Error(err),
-			zap.Any("syncSetting", syncSetting),
-		)
-		return nil, err
-	}
-
-	spf := sf.SyncProtobufFactory()
-	if spf == nil {
-		m.logger.Warn("extractSyncSetting - received protobuf for setting with no SyncProtobufFactory", zap.Any("SettingField", sf))
-		return nil, nil
-	}
-	if spf.Inactive() {
-		m.logger.Warn("extractSyncSetting - received protobuf for inactive sync setting", zap.Any("SettingField", sf))
-		return nil, nil
-	}
-
-	value := spf.ExtractValueFromProtobuf()(syncSetting)
-
-	err = m.settings.SaveSyncSetting(sf, value, syncSetting.Clock)
-	if err == errors.ErrNewClockOlderThanCurrent {
-		m.logger.Info("extractSyncSetting - SaveSyncSetting :", zap.Error(err))
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	if v, ok := value.([]byte); ok {
-		value = json.RawMessage(v)
-	}
-
-	return &settings.SyncSettingField{SettingField: sf, Value: value}, nil
-}
-
 // startSyncSettingsLoop watches the m.settings.SyncQueue and sends a sync message in response to a settings update
 func (m *Messenger) startSyncSettingsLoop() {
 	go func() {

protocol/messenger_testing_utils.go

@@ -50,14 +50,10 @@ func WaitOnMessengerResponse(m *Messenger, condition func(*MessengerResponse) bo
 type MessengerSignalsHandlerMock struct {
 	MessengerSignalsHandler
 
-	responseChan                 chan *MessengerResponse
-	communityFoundChan           chan *communities.Community
-	wakuBackedUpDataResponseChan chan *wakusync.WakuBackedUpDataResponse
+	responseChan       chan *MessengerResponse
+	communityFoundChan chan *communities.Community
 }
 
-func (m *MessengerSignalsHandlerMock) SendWakuFetchingBackupProgress(response *wakusync.WakuBackedUpDataResponse) {
-	m.wakuBackedUpDataResponseChan <- response
-}
 func (m *MessengerSignalsHandlerMock) SendWakuBackedUpProfile(*wakusync.WakuBackedUpDataResponse)  {}
 func (m *MessengerSignalsHandlerMock) SendWakuBackedUpSettings(*wakusync.WakuBackedUpDataResponse) {}
 func (m *MessengerSignalsHandlerMock) SendWakuBackedUpKeypair(*wakusync.WakuBackedUpDataResponse)  {}
@@ -93,42 +89,6 @@ func (m *MessengerSignalsHandlerMock) CommunityInfoFound(community *communities.
 	}
 }
 
-func WaitOnSignaledSendWakuFetchingBackupProgress(m *Messenger, condition func(*wakusync.WakuBackedUpDataResponse) bool, errorMessage string) (*wakusync.WakuBackedUpDataResponse, error) {
-	interval := 500 * time.Millisecond
-	timeoutChan := time.After(10 * time.Second)
-
-	if m.config.messengerSignalsHandler != nil {
-		return nil, errors.New("messengerSignalsHandler already provided/mocked")
-	}
-
-	responseChan := make(chan *wakusync.WakuBackedUpDataResponse, 1000)
-	m.config.messengerSignalsHandler = &MessengerSignalsHandlerMock{
-		wakuBackedUpDataResponseChan: responseChan,
-	}
-
-	defer func() {
-		m.config.messengerSignalsHandler = nil
-	}()
-
-	for {
-		_, err := m.RetrieveAll()
-		if err != nil {
-			return nil, err
-		}
-
-		select {
-		case r := <-responseChan:
-			if condition(r) {
-				return r, nil
-			}
-		case <-timeoutChan:
-			return nil, errors.New("timed out: " + errorMessage)
-		default: // No immediate response, rest & loop back to retrieve again
-			time.Sleep(interval)
-		}
-	}
-}
-
 func WaitOnSignaledMessengerResponse(m *Messenger, condition func(*MessengerResponse) bool, errorMessage string) (*MessengerResponse, error) {
 	interval := 500 * time.Millisecond
 	timeoutChan := time.After(10 * time.Second)

protocol/syncing/syncing.go

@@ -1,19 +1,27 @@
 package syncing
 
 import (
+	"encoding/json"
 	"errors"
 
+	"go.uber.org/zap"
+
 	gethcommon "github.com/ethereum/go-ethereum/common"
 
 	accsmanagementtypes "github.com/status-im/status-go/accounts-management/types"
 	"github.com/status-im/status-go/crypto/types"
 	"github.com/status-im/status-go/multiaccounts/accounts"
 	multiaccountscommon "github.com/status-im/status-go/multiaccounts/common"
+	maErrors "github.com/status-im/status-go/multiaccounts/errors"
+	"github.com/status-im/status-go/multiaccounts/settings"
 	"github.com/status-im/status-go/pkg/pubsub"
 	"github.com/status-im/status-go/protocol/protobuf"
 	"github.com/status-im/status-go/services/accounts/accountsevent"
 )
 
+// TODO move this code out of the protocol package
+// https://github.com/status-im/status-go/pull/6967#discussion_r2391383496
+
 var (
 	ErrNotWatchOnlyAccount           = errors.New("an account is not a watch only account")
 	ErrTryingToStoreOldWalletAccount = errors.New("trying to store an old wallet account")
@@ -96,3 +104,43 @@ func HandleSyncWatchOnlyAccount(accountsDB *accounts.Database, message *protobuf
 	}
 	return acc, nil
 }
+
+// extractSyncSetting parses incoming *protobuf.SyncSetting and stores the setting data if needed
+func ExtractAndSaveSyncSetting(accountsDB *accounts.Database, logger *zap.Logger, syncSetting *protobuf.SyncSetting) (*settings.SyncSettingField, error) {
+	sf, err := settings.GetFieldFromProtobufType(syncSetting.Type)
+	if err != nil {
+		logger.Error(
+			"extractSyncSetting - settings.GetFieldFromProtobufType",
+			zap.Error(err),
+			zap.Any("syncSetting", syncSetting),
+		)
+		return nil, err
+	}
+
+	spf := sf.SyncProtobufFactory()
+	if spf == nil {
+		logger.Warn("extractSyncSetting - received protobuf for setting with no SyncProtobufFactory")
+		return nil, nil
+	}
+	if spf.Inactive() {
+		logger.Warn("extractSyncSetting - received protobuf for inactive sync setting")
+		return nil, nil
+	}
+
+	value := spf.ExtractValueFromProtobuf()(syncSetting)
+
+	err = accountsDB.SaveSyncSetting(sf, value, syncSetting.Clock)
+	if err == maErrors.ErrNewClockOlderThanCurrent {
+		logger.Info("extractSyncSetting - SaveSyncSetting :", zap.Error(err))
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	if v, ok := value.([]byte); ok {
+		value = json.RawMessage(v)
+	}
+
+	return &settings.SyncSettingField{SettingField: sf, Value: value}, nil
+}