backend: do not re-initialize watch-only accounts

When disconnecting a keystore, previously all accounts were removed,
because we had no watch-only accounts.

When registering, all keystore accounts were (re-)loaded, because they
were the only ones to be shown.

With watch-only, we don't want to reinit accounts that are being
watched. This allows a user to connect a keystore e.g. in the middle
of an action inside an account, like displaying an address, without
being disrupted.

The force flag is needed to reinitialize also watch-only accounts if
e.g. the activeTokens field changes for an ETH account. Ideally we can
always dynamically fix the loaded accounts to match the persisted
config, but that is for the future.

Author: benma

backend/accounts.go

@@ -502,6 +502,10 @@ func (backend *Backend) addAccount(account accounts.Interface) {
 
 // The accountsAndKeystoreLock must be held when calling this function.
 func (backend *Backend) createAndAddAccount(coin coinpkg.Coin, persistedConfig *config.Account) {
+	if backend.accounts.lookup(persistedConfig.Code) != nil {
+		// Do not create/load account if it is already loaded.
+		return
+	}
 	var account accounts.Interface
 	accountConfig := &accounts.AccountConfig{
 		Config:      persistedConfig,
@@ -933,9 +937,10 @@ func (backend *Backend) updatePersistedAccounts(
 }
 
 // The accountsAndKeystoreLock must be held when calling this function.
-func (backend *Backend) initAccounts() {
+// if force is true, all accounts are uninitialized first, even if they are watch-only.
+func (backend *Backend) initAccounts(force bool) {
 	// Since initAccounts replaces all previous accounts, we need to properly close them first.
-	backend.uninitAccounts()
+	backend.uninitAccounts(force)
 
 	backend.initPersistedAccounts()
 
@@ -955,19 +960,26 @@ func (backend *Backend) ReinitializeAccounts() {
 	defer backend.accountsAndKeystoreLock.Lock()()
 
 	backend.log.Info("Reinitializing accounts")
-	backend.initAccounts()
+	backend.initAccounts(true)
 }
 
 // The accountsAndKeystoreLock must be held when calling this function.
-func (backend *Backend) uninitAccounts() {
+// if force is true, all accounts are uninitialized, even if they are watch-only.
+func (backend *Backend) uninitAccounts(force bool) {
+	keep := []accounts.Interface{}
 	for _, account := range backend.accounts {
 		account := account
+		if !force && account.Config().Config.IsWatch() {
+			// Do not uninit/remove account that is being watched.
+			keep = append(keep, account)
+			continue
+		}
 		if backend.onAccountUninit != nil {
 			backend.onAccountUninit(account)
 		}
 		account.Close()
 	}
-	backend.accounts = []accounts.Interface{}
+	backend.accounts = keep
 }
 
 // maybeAddHiddenUnusedAccounts adds a hidden account for scanning to facilitate accounts discovery.

backend/backend.go

@@ -556,7 +556,7 @@ func (backend *Backend) registerKeystore(keystore keystore.Keystore) {
 		log.WithError(err).Error("Could not persist default accounts")
 	}
 
-	backend.initAccounts()
+	backend.initAccounts(false)
 
 	backend.aoppKeystoreRegistered()
 }
@@ -578,7 +578,7 @@ func (backend *Backend) DeregisterKeystore() {
 		Action:  action.Reload,
 	})
 
-	backend.uninitAccounts()
+	backend.uninitAccounts(false)
 	// TODO: classify accounts by keystore, remove only the ones belonging to the deregistered
 	// keystore. For now we just remove all, then re-add the rest.
 	backend.initPersistedAccounts()
@@ -721,7 +721,7 @@ func (backend *Backend) Close() error {
 
 	backend.ratesUpdater.Stop()
 
-	backend.uninitAccounts()
+	backend.uninitAccounts(true)
 
 	for _, coin := range backend.coins {
 		if err := coin.Close(); err != nil {