backend/backend: refactor backend accounts keystores

Author: Beerosagos

backend/accounts.go

@@ -18,6 +18,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"math"
+	"math/big"
 	"sort"
 	"strings"
 	"time"
@@ -28,10 +29,13 @@ import (
 	accountsTypes "github.com/digitalbitbox/bitbox-wallet-app/backend/accounts/types"
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/bitsurance"
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/btc"
+	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/btc/util"
+	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/coin"
 	coinpkg "github.com/digitalbitbox/bitbox-wallet-app/backend/coins/coin"
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/eth"
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/config"
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/keystore"
+	"github.com/digitalbitbox/bitbox-wallet-app/backend/rates"
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/signing"
 	"github.com/digitalbitbox/bitbox-wallet-app/util/errp"
 	"github.com/digitalbitbox/bitbox-wallet-app/util/observable"
@@ -60,7 +64,7 @@ type AccountsList []accounts.Interface
 
 // KeystoresAccountsListMap is a map where keys are keystores' fingerprints and values are
 // AccountsLists of accounts belonging to each keystore.
-type KeystoresAccountsListMap map[*config.Keystore]AccountsList
+type KeystoresAccountsListMap map[string]AccountsList
 
 func (a AccountsList) lookup(code accountsTypes.Code) accounts.Interface {
 	for _, acct := range a {
@@ -205,6 +209,90 @@ func (backend *Backend) SupportedCoins(keystore keystore.Keystore) []coinpkg.Cod
 	return availableCoins
 }
 
+// AccountsByKeystore returns a map of the current accounts of the backend, grouped
+// by keystore.
+func (backend *Backend) AccountsByKeystore() (KeystoresAccountsListMap, error) {
+	defer backend.accountsAndKeystoreLock.RLock()()
+	accountsByKeystore := KeystoresAccountsListMap{}
+	for _, account := range backend.accounts {
+		persistedAccount := account.Config().Config
+		rootFingerprint, err := persistedAccount.SigningConfigurations.RootFingerprint()
+		if err != nil {
+			return nil, err
+		}
+		hexFingerprint := hex.EncodeToString(rootFingerprint)
+		accountsByKeystore[hexFingerprint] = append(accountsByKeystore[hexFingerprint], account)
+	}
+	return accountsByKeystore, nil
+}
+
+// accountFiatBalance returns an account's balance, converted in fiat currency.
+func (backend *Backend) accountFiatBalance(account accounts.Interface, fiat string) (*big.Rat, error) {
+	balance, err := account.Balance()
+	if err != nil {
+		return nil, err
+	}
+
+	coinDecimals := coin.DecimalsExp(account.Coin())
+
+	price, err := backend.RatesUpdater().LatestPriceForPair(account.Coin().Unit(false), fiat)
+	if err != nil {
+		return nil, err
+	}
+	fiatValue := new(big.Rat).Mul(
+		new(big.Rat).SetFrac(
+			balance.Available().BigInt(),
+			coinDecimals,
+		),
+		new(big.Rat).SetFloat64(price),
+	)
+	return fiatValue, nil
+}
+
+// AccountsTotalBalanceByKeystore returns a map of accounts' total balances across coins, grouped by keystore.
+func (backend *Backend) AccountsTotalBalanceByKeystore() (map[string]KeystoreTotalAmount, error) {
+	totalAmounts := make(map[string]KeystoreTotalAmount)
+	fiat := backend.Config().AppConfig().Backend.MainFiat
+	isFiatBtc := fiat == rates.BTC.String()
+	fiatUnit := fiat
+	if isFiatBtc && backend.Config().AppConfig().Backend.BtcUnit == coinpkg.BtcUnitSats {
+		fiatUnit = "sat"
+	}
+
+	formatBtcAsSat := util.FormatBtcAsSat(backend.Config().AppConfig().Backend.BtcUnit)
+
+	accountsByKeystore, err := backend.AccountsByKeystore()
+	if err != nil {
+		return nil, err
+	}
+	for rootFingerprint, accountList := range accountsByKeystore {
+		currentTotal := new(big.Rat)
+		for _, account := range accountList {
+			if account.Config().Config.Inactive {
+				continue
+			}
+			if account.FatalError() {
+				continue
+			}
+			err := account.Initialize()
+			if err != nil {
+				return nil, err
+			}
+
+			fiatValue, err := backend.accountFiatBalance(account, fiat)
+			if err != nil {
+				return nil, err
+			}
+			currentTotal.Add(currentTotal, fiatValue)
+		}
+		totalAmounts[rootFingerprint] = KeystoreTotalAmount{
+			FiatUnit: fiatUnit,
+			Total:    coinpkg.FormatAsCurrency(currentTotal, isFiatBtc, formatBtcAsSat),
+		}
+	}
+	return totalAmounts, nil
+}
+
 // LookupInsuredAccounts queries the insurance status of specified or all active BTC accounts
 // and updates the internal state based on the retrieved information. If the accountCode is
 // provided, it checks the insurance status for that specific account; otherwise, it checks

backend/backend.go

@@ -16,9 +16,7 @@
 package backend
 
 import (
-	"encoding/hex"
 	"fmt"
-	"math/big"
 	"net/http"
 	"net/url"
 	"os"
@@ -34,8 +32,6 @@ import (
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/btc"
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/btc/electrum"
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/btc/types"
-	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/btc/util"
-	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/coin"
 	coinpkg "github.com/digitalbitbox/bitbox-wallet-app/backend/coins/coin"
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/eth"
 	"github.com/digitalbitbox/bitbox-wallet-app/backend/coins/eth/etherscan"
@@ -544,97 +540,14 @@ func (backend *Backend) Accounts() AccountsList {
 	return backend.accounts
 }
 
-// AccountsByKeystore returns a map of the current accounts of the backend, grouped
-// by keystore.
-func (backend *Backend) AccountsByKeystore() (KeystoresAccountsListMap, error) {
-	accountsByKeystore := KeystoresAccountsListMap{}
-	defer backend.accountsAndKeystoreLock.RLock()()
-	for _, account := range backend.accounts {
-		persistedAccount := account.Config().Config
-		rootFingerprint, err := persistedAccount.SigningConfigurations.RootFingerprint()
-		if err != nil {
-			return nil, err
-		}
-		keystore, err := backend.Config().AccountsConfig().LookupKeystore(rootFingerprint)
-		if err != nil {
-			return nil, err
-		}
-		accountsByKeystore[keystore] = append(accountsByKeystore[keystore], account)
-	}
-	return accountsByKeystore, nil
-}
-
-// KeystoreTotalAmount represents the total balance amount of the accounts belongings to a keystore.
+// KeystoreTotalAmount represents the total balance amount of the accounts belonging to a keystore.
 type KeystoreTotalAmount = struct {
 	// FiatUnit is the fiat unit of the total amount
 	FiatUnit string `json:"fiatUnit"`
 	// Total formatted for frontend visualization
 	Total string `json:"total"`
 }
 
-// AccountsTotalBalanceByKeystore returns a map of accounts' total balances across coins, grouped by keystore.
-func (backend *Backend) AccountsTotalBalanceByKeystore() (map[string]KeystoreTotalAmount, error) {
-	totalAmounts := make(map[string]KeystoreTotalAmount)
-	fiat := backend.Config().AppConfig().Backend.MainFiat
-	isFiatBtc := fiat == rates.BTC.String()
-	fiatUnit := fiat
-	if isFiatBtc && backend.Config().AppConfig().Backend.BtcUnit == coin.BtcUnitSats {
-		fiatUnit = "sat"
-	}
-
-	formatBtcAsSat := util.FormatBtcAsSat(backend.Config().AppConfig().Backend.BtcUnit)
-
-	accountsByKeystore, err := backend.AccountsByKeystore()
-	if err != nil {
-		return nil, err
-	}
-	for keystore, accountList := range accountsByKeystore {
-		rootFingerprint := hex.EncodeToString(keystore.RootFingerprint)
-		currentTotal := new(big.Rat)
-		for _, account := range accountList {
-			if account.Config().Config.Inactive {
-				continue
-			}
-			if account.FatalError() {
-				continue
-			}
-			err := account.Initialize()
-			if err != nil {
-				return nil, err
-			}
-			balance, err := account.Balance()
-			if err != nil {
-				return nil, err
-			}
-			// e.g. 1e8 for Bitcoin/Litecoin, 1e18 for Ethereum, etc. Used to convert from the smallest
-			// unit to the standard unit (BTC, LTC; ETH, etc.).
-			coinDecimals := new(big.Int).Exp(
-				big.NewInt(10),
-				big.NewInt(int64(account.Coin().Decimals(false))),
-				nil,
-			)
-
-			price, err := backend.RatesUpdater().LatestPriceForPair(account.Coin().Unit(false), fiat)
-			if err != nil {
-				return nil, err
-			}
-			fiatValue := new(big.Rat).Mul(
-				new(big.Rat).SetFrac(
-					balance.Available().BigInt(),
-					coinDecimals,
-				),
-				new(big.Rat).SetFloat64(price),
-			)
-			currentTotal.Add(currentTotal, fiatValue)
-		}
-		totalAmounts[rootFingerprint] = KeystoreTotalAmount{
-			FiatUnit: fiatUnit,
-			Total:    coin.FormatAsCurrency(currentTotal, isFiatBtc, formatBtcAsSat),
-		}
-	}
-	return totalAmounts, nil
-}
-
 // OnAccountInit installs a callback to be called when an account is initialized.
 func (backend *Backend) OnAccountInit(f func(accounts.Interface)) {
 	backend.onAccountInit = f

backend/chart.go

@@ -148,42 +148,24 @@ func (backend *Backend) ChartData() (*Chart, error) {
 		if err != nil {
 			return nil, err
 		}
-		balance, err := account.Balance()
-		if err != nil {
-			return nil, err
-		}
 		txs, err := account.Transactions()
 		if err != nil {
 			return nil, err
 		}
 		totalNumberOfTransactions += len(txs)
 
-		// e.g. 1e8 for Bitcoin/Litecoin, 1e18 for Ethereum, etc. Used to convert from the smallest
-		// unit to the standard unit (BTC, LTC; ETH, etc.).
-		coinDecimals := new(big.Int).Exp(
-			big.NewInt(10),
-			big.NewInt(int64(account.Coin().Decimals(false))),
-			nil,
-		)
+		coinDecimals := coin.DecimalsExp(account.Coin())
 
 		// HACK: The latest prices might deviate from the latest historical prices (which can lag
 		// behind by many minutes), which results in different total balances in the chart and the
 		// summary table.
 		//
-		// As a workaround, we manually compute the total based on the latest rates.
-		price, err := backend.RatesUpdater().LatestPriceForPair(account.Coin().Unit(false), fiat)
+		// As a workaround, we calls accountFiatBalance, which computes the total based on the latest rates.
+		fiatValue, err := backend.accountFiatBalance(account, fiat)
 		if err != nil {
 			currentTotalMissing = true
-			backend.log.
-				WithField("coin", account.Coin().Code()).WithError(err).Info("currentTotalMissing")
+			return nil, err
 		}
-		fiatValue := new(big.Rat).Mul(
-			new(big.Rat).SetFrac(
-				balance.Available().BigInt(),
-				coinDecimals,
-			),
-			new(big.Rat).SetFloat64(price),
-		)
 		currentTotal.Add(currentTotal, fiatValue)
 
 		// Below here, only chart data is being computed.

backend/coins/coin/coin.go

@@ -82,3 +82,13 @@ type Coin interface {
 	// Close shuts down all resources obtained by the coin (network connections, databases, etc.).
 	Close() error
 }
+
+// DecimalsExp returns the conversion exponential from the smallest unit to the standard unit
+// (BTC, LTC; ETH, etc.). e.g. 1e8 for Bitcoin/Litecoin, 1e18 for Ethereum, etc.
+func DecimalsExp(coin Coin) *big.Int {
+	return new(big.Int).Exp(
+		big.NewInt(10),
+		big.NewInt(int64(coin.Decimals(false))),
+		nil,
+	)
+}

backend/handlers/handlers.go

@@ -18,7 +18,6 @@ package handlers
 import (
 	"bytes"
 	"encoding/base64"
-	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -696,8 +695,7 @@ func (handlers *Handlers) getAccountsBalance(*http.Request) (interface{}, error)
 	if err != nil {
 		return nil, err
 	}
-	for keystore, accountList := range accountsByKeystore {
-		rootFingerprint := hex.EncodeToString(keystore.RootFingerprint)
+	for rootFingerprint, accountList := range accountsByKeystore {
 		totalPerCoin := make(map[coin.Code]*big.Int)
 		conversionsPerCoin := make(map[coin.Code]map[string]string)
 		for _, account := range accountList {