Merge branch 'accounts-summary'

Author: Beerosagos

backend/accounts.go

@@ -268,19 +268,95 @@ func (backend *Backend) accountFiatBalance(account accounts.Interface, fiat stri
 	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
+type coinFormattedAmount struct {
+	CoinCode        coinpkg.Code                           `json:"coinCode"`
+	CoinName        string                                 `json:"coinName"`
+	FormattedAmount coinpkg.FormattedAmountWithConversions `json:"formattedAmount"`
+}
+
+// getCoinsTotalBalance returns the total balances grouped by coins.
+func (backend *Backend) coinsTotalBalance() ([]coinFormattedAmount, error) {
+	var coinFormattedAmounts []coinFormattedAmount
+	var sortedCoins []coinpkg.Code
+	totalCoinsBalances := make(map[coinpkg.Code]*big.Int)
+
+	for _, account := range backend.Accounts() {
+		if account.Config().Config.Inactive || account.Config().Config.HiddenBecauseUnused {
+			continue
+		}
+		if account.FatalError() {
+			continue
+		}
+		err := account.Initialize()
+		if err != nil {
+			return nil, err
+		}
+		coinCode := account.Coin().Code()
+		b, err := account.Balance()
+		if err != nil {
+			return nil, err
+		}
+		amount := b.Available()
+
+		if totalBalance, exists := totalCoinsBalances[coinCode]; exists {
+			totalBalance.Add(totalBalance, amount.BigInt())
+		} else {
+			totalCoinsBalances[coinCode] = amount.BigInt()
+			sortedCoins = append(sortedCoins, coinCode)
+		}
+	}
+
+	for _, coinCode := range sortedCoins {
+		coin, err := backend.Coin(coinCode)
+		if err != nil {
+			return nil, err
+		}
+		coinAmount := coinpkg.NewAmount(totalCoinsBalances[coinCode])
+		coinFormattedAmounts = append(coinFormattedAmounts, coinFormattedAmount{
+			CoinCode: coinCode,
+			CoinName: coin.Name(),
+			FormattedAmount: coinpkg.FormattedAmountWithConversions{
+				Amount: coin.FormatAmount(coinAmount, false),
+				Unit:   coin.GetFormatUnit(false),
+				Conversions: coinpkg.Conversions(
+					coinAmount,
+					coin,
+					false,
+					backend.RatesUpdater(),
+				),
+			},
+		})
+	}
+	return coinFormattedAmounts, nil
+}
+
+// AmountsByCoin maps the total amount of each coin.
+type AmountsByCoin map[coinpkg.Code]coinpkg.FormattedAmountWithConversions
+
+// KeystoreBalance represents the total balance amount of the accounts belonging to a keystore.
+type KeystoreBalance = struct {
+	// FiatUnit is the fiat unit of the balance
+	FiatUnit string `json:"fiatUnit"`
+	// Fiat total formatted for frontend visualization
+	Total string `json:"total"`
+	// Total amounts for each coin
+	CoinsBalance AmountsByCoin `json:"coinsBalance"`
+}
+
+// keystoresBalance returns a map of accounts' total balances across coins, grouped by keystore.
+func (backend *Backend) keystoresBalance() (map[string]KeystoreBalance, error) {
+	keystoreBalanceMap := make(map[string]KeystoreBalance)
+	fiatUnit := backend.Config().AppConfig().Backend.MainFiat
 
 	accountsByKeystore, err := backend.AccountsByKeystore()
 	if err != nil {
 		return nil, err
 	}
 	for rootFingerprint, accountList := range accountsByKeystore {
-		currentTotal := new(big.Rat)
+		keystoreCoinsBalance := make(map[coinpkg.Code]*big.Int)
+		keystoreTotalBalance := new(big.Rat)
 		for _, account := range accountList {
-			if account.Config().Config.Inactive {
+			if account.Config().Config.Inactive || account.Config().Config.HiddenBecauseUnused {
 				continue
 			}
 			if account.FatalError() {
@@ -291,18 +367,74 @@ func (backend *Backend) AccountsTotalBalanceByKeystore() (map[string]KeystoreTot
 				return nil, err
 			}
 
-			fiatValue, err := backend.accountFiatBalance(account, fiat)
+			accountFiatBalance, err := backend.accountFiatBalance(account, fiatUnit)
+			if err != nil {
+				return nil, err
+			}
+			keystoreTotalBalance.Add(keystoreTotalBalance, accountFiatBalance)
+
+			coinCode := account.Coin().Code()
+			balance, err := account.Balance()
+			if err != nil {
+				return nil, err
+			}
+			accountBalance := balance.Available().BigInt()
+			if _, ok := keystoreCoinsBalance[coinCode]; !ok {
+				keystoreCoinsBalance[coinCode] = accountBalance
+
+			} else {
+				keystoreCoinsBalance[coinCode] = new(big.Int).Add(keystoreCoinsBalance[coinCode], accountBalance)
+			}
+		}
+
+		keystoreCoinsAmount := AmountsByCoin{}
+		for coinCode, coinBalance := range keystoreCoinsBalance {
+			coinAmount := coinpkg.NewAmount(coinBalance)
+			coin, err := backend.Coin(coinCode)
 			if err != nil {
 				return nil, err
 			}
-			currentTotal.Add(currentTotal, fiatValue)
+			keystoreCoinsAmount[coinCode] = coinpkg.FormattedAmountWithConversions{
+				Amount: coin.FormatAmount(coinAmount, false),
+				Unit:   coin.GetFormatUnit(false),
+				Conversions: coinpkg.Conversions(
+					coinAmount,
+					coin,
+					false,
+					backend.ratesUpdater),
+			}
 		}
-		totalAmounts[rootFingerprint] = KeystoreTotalAmount{
-			FiatUnit: fiat,
-			Total:    coinpkg.FormatAsCurrency(currentTotal, fiat),
+
+		keystoreBalanceMap[rootFingerprint] = KeystoreBalance{
+			FiatUnit:     fiatUnit,
+			Total:        coinpkg.FormatAsCurrency(keystoreTotalBalance, fiatUnit),
+			CoinsBalance: keystoreCoinsAmount,
 		}
 	}
-	return totalAmounts, nil
+	return keystoreBalanceMap, nil
+}
+
+// AccountsBalanceSummary holds the total balance for each coin and of each keystore.
+type AccountsBalanceSummary struct {
+	KeystoresBalance  map[string]KeystoreBalance `json:"keystoresBalance"`
+	CoinsTotalBalance []coinFormattedAmount      `json:"coinsTotalBalance"`
+}
+
+// AccountsBalanceSummary returns the total balance for each coin and of each keystore.
+func (backend *Backend) AccountsBalanceSummary() (*AccountsBalanceSummary, error) {
+	keystoresBalance, err := backend.keystoresBalance()
+	if err != nil {
+		return nil, err
+	}
+	coinsTotalBalance, err := backend.coinsTotalBalance()
+	if err != nil {
+		return nil, err
+	}
+
+	return &AccountsBalanceSummary{
+		KeystoresBalance:  keystoresBalance,
+		CoinsTotalBalance: coinsTotalBalance,
+	}, nil
 }
 
 // LookupInsuredAccounts queries the insurance status of specified or all active BTC accounts

backend/accounts_test.go

@@ -1447,22 +1447,22 @@ func TestAccountsByKeystore(t *testing.T) {
 	require.Nil(t, accountsMap[hex.EncodeToString(ks2Fingerprint)])
 }
 
-func TestAccountsTotalBalanceByKeystore(t *testing.T) {
+func TestKeystoresBalance(t *testing.T) {
 	b := newBackend(t, testnetDisabled, regtestDisabled)
 	defer b.Close()
 
 	b.makeBtcAccount = func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(*btc.Account, blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error), log *logrus.Entry) accounts.Interface {
 		accountMock := MockBtcAccount(t, config, coin, gapLimits, log)
 		accountMock.BalanceFunc = func() (*accounts.Balance, error) {
-			return accounts.NewBalance(coinpkg.NewAmountFromInt64(100000), coinpkg.NewAmountFromInt64(0)), nil
+			return accounts.NewBalance(coinpkg.NewAmountFromInt64(1e8), coinpkg.NewAmountFromInt64(0)), nil
 		}
 		return accountMock
 	}
 
 	b.makeEthAccount = func(config *accounts.AccountConfig, coin *eth.Coin, httpClient *http.Client, log *logrus.Entry) accounts.Interface {
 		accountMock := MockEthAccount(config, coin, httpClient, log)
 		accountMock.BalanceFunc = func() (*accounts.Balance, error) {
-			return accounts.NewBalance(coinpkg.NewAmountFromInt64(100000), coinpkg.NewAmountFromInt64(0)), nil
+			return accounts.NewBalance(coinpkg.NewAmountFromInt64(1e18), coinpkg.NewAmountFromInt64(0)), nil
 		}
 		return accountMock
 	}
@@ -1500,12 +1500,78 @@ func TestAccountsTotalBalanceByKeystore(t *testing.T) {
 	b.ratesUpdater = rates.MockRateUpdater()
 	defer b.ratesUpdater.Stop()
 
-	totalBalance, err := b.AccountsTotalBalanceByKeystore()
+	keystoresBalance, err := b.keystoresBalance()
 	require.NoError(t, err)
 
-	require.NotNil(t, totalBalance[hex.EncodeToString(ks1Fingerprint)])
-	require.Equal(t, "0.02", totalBalance[hex.EncodeToString(ks1Fingerprint)].Total)
+	require.NotNil(t, keystoresBalance[hex.EncodeToString(ks1Fingerprint)])
+	require.Equal(t, "1.00000000", keystoresBalance[hex.EncodeToString(ks1Fingerprint)].CoinsBalance[coinpkg.CodeBTC].Amount)
+	require.Equal(t, "21.00", keystoresBalance[hex.EncodeToString(ks1Fingerprint)].CoinsBalance[coinpkg.CodeBTC].Conversions["USD"])
+	require.Equal(t, "1.00000000", keystoresBalance[hex.EncodeToString(ks1Fingerprint)].CoinsBalance[coinpkg.CodeLTC].Amount)
+	require.Equal(t, "", keystoresBalance[hex.EncodeToString(ks1Fingerprint)].CoinsBalance[coinpkg.CodeLTC].Conversions["USD"])
+	require.Equal(t, "1", keystoresBalance[hex.EncodeToString(ks1Fingerprint)].CoinsBalance[coinpkg.CodeETH].Amount)
+	require.Equal(t, "1.00", keystoresBalance[hex.EncodeToString(ks1Fingerprint)].CoinsBalance[coinpkg.CodeETH].Conversions["USD"])
+	require.Equal(t, "22.00", keystoresBalance[hex.EncodeToString(ks1Fingerprint)].Total)
+
+	require.NotNil(t, keystoresBalance[hex.EncodeToString(ks2Fingerprint)])
+	require.Equal(t, "22.00", keystoresBalance[hex.EncodeToString(ks2Fingerprint)].Total)
+}
+
+func TestCoinsTotalBalance(t *testing.T) {
+	b := newBackend(t, testnetDisabled, regtestDisabled)
+	defer b.Close()
 
-	require.NotNil(t, totalBalance[hex.EncodeToString(ks2Fingerprint)])
-	require.Equal(t, "0.13", totalBalance[hex.EncodeToString(ks2Fingerprint)].Total)
+	b.makeBtcAccount = func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(*btc.Account, blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error), log *logrus.Entry) accounts.Interface {
+		accountMock := MockBtcAccount(t, config, coin, gapLimits, log)
+		accountMock.BalanceFunc = func() (*accounts.Balance, error) {
+			return accounts.NewBalance(coinpkg.NewAmountFromInt64(1e8), coinpkg.NewAmountFromInt64(0)), nil
+		}
+		return accountMock
+	}
+
+	b.makeEthAccount = func(config *accounts.AccountConfig, coin *eth.Coin, httpClient *http.Client, log *logrus.Entry) accounts.Interface {
+		accountMock := MockEthAccount(config, coin, httpClient, log)
+		accountMock.BalanceFunc = func() (*accounts.Balance, error) {
+			return accounts.NewBalance(coinpkg.NewAmountFromInt64(2e18), coinpkg.NewAmountFromInt64(0)), nil
+		}
+		return accountMock
+	}
+
+	ks1 := makeBitBox02Multi()
+	ks2 := makeBitBox02Multi()
+
+	ks2.RootFingerprintFunc = keystoreHelper2().RootFingerprint
+	ks2.ExtendedPublicKeyFunc = keystoreHelper2().ExtendedPublicKey
+
+	ks1Fingerprint, err := ks1.RootFingerprint()
+	require.NoError(t, err)
+
+	b.registerKeystore(ks1)
+	require.NoError(t, b.SetWatchonly(ks1Fingerprint, true))
+
+	// Up to 6 hidden accounts for BTC/LTC are added to be scanned even if the accounts are all
+	// empty. Calling this function too many times does not add more than that.
+	for i := 1; i <= 10; i++ {
+		b.maybeAddHiddenUnusedAccounts()
+	}
+
+	b.DeregisterKeystore()
+	b.registerKeystore(ks2)
+
+	for i := 1; i <= 10; i++ {
+		b.maybeAddHiddenUnusedAccounts()
+	}
+
+	// This needs to be after all changes in accounts, otherwise it will try to fetch
+	// new values and fail.
+	b.ratesUpdater = rates.MockRateUpdater()
+	defer b.ratesUpdater.Stop()
+
+	coinsTotalBalance, err := b.coinsTotalBalance()
+	require.NoError(t, err)
+	require.Equal(t, coinpkg.CodeBTC, coinsTotalBalance[0].CoinCode)
+	require.Equal(t, "2.00000000", coinsTotalBalance[0].FormattedAmount.Amount)
+	require.Equal(t, coinpkg.CodeLTC, coinsTotalBalance[1].CoinCode)
+	require.Equal(t, "2.00000000", coinsTotalBalance[1].FormattedAmount.Amount)
+	require.Equal(t, coinpkg.CodeETH, coinsTotalBalance[2].CoinCode)
+	require.Equal(t, "4", coinsTotalBalance[2].FormattedAmount.Amount)
 }

backend/backend.go

@@ -610,14 +610,6 @@ func (backend *Backend) Accounts() AccountsList {
 	return slices.Clone(backend.accounts)
 }
 
-// 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"`
-}
-
 // OnAccountInit installs a callback to be called when an account is initialized.
 func (backend *Backend) OnAccountInit(f func(accounts.Interface)) {
 	backend.onAccountInit = f

backend/coins/coin/amount.go

@@ -81,9 +81,9 @@ func (amount Amount) BigInt() *big.Int {
 
 // FormattedAmountWithConversions and json tags.
 type FormattedAmountWithConversions struct {
-	Amount      string            `json:"amount"`
-	Unit        string            `json:"unit"`
-	Conversions map[string]string `json:"conversions"`
+	Amount      string         `json:"amount"`
+	Unit        string         `json:"unit"`
+	Conversions ConversionsMap `json:"conversions"`
 	// Estimated flag is enabled if the Conversions map was expected to
 	// be calculated using historical rates, but latest rates have been used instead.
 	Estimated bool `json:"estimated"`

backend/coins/coin/conversions.go

@@ -47,14 +47,16 @@ func FormatAsCurrency(amount *big.Rat, currency string) string {
 	return formatted
 }
 
+// ConversionsMap maps formmatted conversions of a coin amount into fiat currencies.
+type ConversionsMap map[string]string
+
 // Conversions handles fiat conversions.
-func Conversions(amount Amount, coin Coin, isFee bool, ratesUpdater *ratesPkg.RateUpdater) map[string]string {
-	conversions := map[string]string{}
+func Conversions(amount Amount, coin Coin, isFee bool, ratesUpdater *ratesPkg.RateUpdater) ConversionsMap {
+	conversions := ConversionsMap{}
 	rates := ratesUpdater.LatestPrice()
 	if rates != nil {
 		unit := coin.Unit(isFee)
 
-		conversions = map[string]string{}
 		for key, value := range rates[unit] {
 			convertedAmount := new(big.Rat).Mul(new(big.Rat).SetFloat64(coin.ToUnit(amount, isFee)), new(big.Rat).SetFloat64(value))
 			conversions[key] = FormatAsCurrency(convertedAmount, key)
@@ -66,14 +68,14 @@ func Conversions(amount Amount, coin Coin, isFee bool, ratesUpdater *ratesPkg.Ra
 // ConversionsAtTime handles fiat conversions at a specific time.
 // It returns the map of conversions and a bool indicating if the rates have been estimated
 // using the latest instead of the historical rates for recent transactions.
-func ConversionsAtTime(amount Amount, coin Coin, isFee bool, ratesUpdater *ratesPkg.RateUpdater, timeStamp *time.Time) (map[string]string, bool) {
+func ConversionsAtTime(amount Amount, coin Coin, isFee bool, ratesUpdater *ratesPkg.RateUpdater, timeStamp *time.Time) (ConversionsMap, bool) {
 	latestRatesTime := ratesUpdater.HistoryLatestTimestampCoin(string(coin.Code()))
 	historicalRatesNotAvailable := latestRatesTime.IsZero() || latestRatesTime.Before(*timeStamp)
 	if historicalRatesNotAvailable && time.Since(*timeStamp) < 2*time.Hour {
 		return Conversions(amount, coin, isFee, ratesUpdater), true
 	}
 
-	conversions := map[string]string{}
+	conversions := ConversionsMap{}
 	lastRates := ratesUpdater.LatestPrice()
 	if lastRates != nil {
 		unit := coin.Unit(isFee)