backend/coins: refactor formatted amounts and add unit tests

This refactors the code to format amounts with fiat conversions,
removing it from handlers into the coin package, and adds some
tests.

Author: Beerosagos

backend/accounts.go

@@ -875,7 +875,6 @@ func (backend *Backend) createAndAddAccount(coin coinpkg.Coin, persistedConfig *
 		},
 		GetSaveFilename:  backend.environment.GetSaveFilename,
 		UnsafeSystemOpen: backend.environment.SystemOpen,
-		BtcCurrencyUnit:  backend.config.AppConfig().Backend.BtcUnit,
 	}
 
 	// This function is passed as a callback to the BTC account constructor. It is called when the

backend/accounts/baseaccount.go

@@ -56,8 +56,6 @@ type AccountConfig struct {
 	GetSaveFilename func(suggestedFilename string) string
 	// Opens a file in a default application. The filename is not checked.
 	UnsafeSystemOpen func(filename string) error
-	// BtcCurrencyUnit is the unit which should be used to format fiat amounts values expressed in BTC..
-	BtcCurrencyUnit coin.BtcUnit
 }
 
 // BaseAccount is an account struct with common functionality to all coin accounts.

backend/coins/btc/handlers/handlers.go

@@ -94,90 +94,27 @@ func (handlers *Handlers) Uninit() {
 	handlers.account = nil
 }
 
-// FormattedAmount with unit and conversions.
-type FormattedAmount struct {
-	Amount      string            `json:"amount"`
-	Unit        string            `json:"unit"`
-	Conversions map[string]string `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"`
-}
-
-func (handlers *Handlers) formatAmountAsJSON(amount coin.Amount, isFee bool) FormattedAmount {
-	accountCoin := handlers.account.Coin()
-	return FormattedAmount{
-		Amount: accountCoin.FormatAmount(amount, isFee),
-		Unit:   accountCoin.GetFormatUnit(isFee),
-		Conversions: coin.Conversions(
-			amount,
-			accountCoin,
-			isFee,
-			handlers.account.Config().RateUpdater,
-			util.FormatBtcAsSat(handlers.account.Config().BtcCurrencyUnit),
-		),
-	}
-}
-
-func (handlers *Handlers) formatAmountAtTimeAsJSON(amount coin.Amount, timeStamp *time.Time) FormattedAmount {
-	accountCoin := handlers.account.Coin()
-	rateUpdater := handlers.account.Config().RateUpdater
-	formatBtcAsSat := util.FormatBtcAsSat(handlers.account.Config().BtcCurrencyUnit)
-	var conversions map[string]string
-	var estimated bool
-
-	if timeStamp == nil {
-		conversions = coin.Conversions(
-			amount,
-			accountCoin,
-			false,
-			rateUpdater,
-			formatBtcAsSat,
-		)
-		estimated = true
-	} else {
-		conversions, estimated = coin.ConversionsAtTime(
-			amount,
-			accountCoin,
-			false,
-			rateUpdater,
-			formatBtcAsSat,
-			timeStamp,
-		)
-	}
-	return FormattedAmount{
-		Amount:      accountCoin.FormatAmount(amount, false),
-		Unit:        accountCoin.GetFormatUnit(false),
-		Conversions: conversions,
-		Estimated:   estimated,
-	}
-}
-
-func (handlers *Handlers) formatBTCAmountAsJSON(amount btcutil.Amount, isFee bool) FormattedAmount {
-	return handlers.formatAmountAsJSON(coin.NewAmountFromInt64(int64(amount)), isFee)
-}
-
 // Transaction is the info returned per transaction by the /transactions and /transaction endpoint.
 type Transaction struct {
-	TxID                     string            `json:"txID"`
-	InternalID               string            `json:"internalID"`
-	NumConfirmations         int               `json:"numConfirmations"`
-	NumConfirmationsComplete int               `json:"numConfirmationsComplete"`
-	Type                     string            `json:"type"`
-	Status                   accounts.TxStatus `json:"status"`
-	Amount                   FormattedAmount   `json:"amount"`
-	AmountAtTime             FormattedAmount   `json:"amountAtTime"`
-	DeductedAmountAtTime     FormattedAmount   `json:"deductedAmountAtTime"`
-	Fee                      FormattedAmount   `json:"fee"`
-	Time                     *string           `json:"time"`
-	Addresses                []string          `json:"addresses"`
-	Note                     string            `json:"note"`
+	TxID                     string                              `json:"txID"`
+	InternalID               string                              `json:"internalID"`
+	NumConfirmations         int                                 `json:"numConfirmations"`
+	NumConfirmationsComplete int                                 `json:"numConfirmationsComplete"`
+	Type                     string                              `json:"type"`
+	Status                   accounts.TxStatus                   `json:"status"`
+	Amount                   coin.FormattedAmountWithConversions `json:"amount"`
+	AmountAtTime             coin.FormattedAmountWithConversions `json:"amountAtTime"`
+	DeductedAmountAtTime     coin.FormattedAmountWithConversions `json:"deductedAmountAtTime"`
+	Fee                      coin.FormattedAmountWithConversions `json:"fee"`
+	Time                     *string                             `json:"time"`
+	Addresses                []string                            `json:"addresses"`
+	Note                     string                              `json:"note"`
 
 	// BTC specific fields.
-	VSize        int64           `json:"vsize"`
-	Size         int64           `json:"size"`
-	Weight       int64           `json:"weight"`
-	FeeRatePerKb FormattedAmount `json:"feeRatePerKb"`
+	VSize        int64                               `json:"vsize"`
+	Size         int64                               `json:"size"`
+	Weight       int64                               `json:"weight"`
+	FeeRatePerKb coin.FormattedAmountWithConversions `json:"feeRatePerKb"`
 
 	// ETH specific fields
 	Gas   uint64  `json:"gas"`
@@ -196,19 +133,20 @@ func (handlers *Handlers) ensureAccountInitialized(h func(*http.Request) (interf
 // getTxInfoJSON encodes a given transaction in JSON.
 // If `detail` is false, Coin related details, fees and historical fiat amount won't be included.
 func (handlers *Handlers) getTxInfoJSON(txInfo *accounts.TransactionData, detail bool) Transaction {
-	var feeString FormattedAmount
+	accountConfig := handlers.account.Config()
+	var feeString coin.FormattedAmountWithConversions
 	if txInfo.Fee != nil {
-		feeString = handlers.formatAmountAsJSON(*txInfo.Fee, true)
+		feeString = txInfo.Fee.FormatWithConversions(handlers.account.Coin(), true, accountConfig.RateUpdater)
 	}
-	amount := handlers.formatAmountAsJSON(txInfo.Amount, false)
+	amount := txInfo.Amount.FormatWithConversions(handlers.account.Coin(), false, accountConfig.RateUpdater)
 	var formattedTime *string
 	timestamp := txInfo.Timestamp
 	if timestamp == nil {
 		timestamp = txInfo.CreatedTimestamp
 	}
 
-	deductedAmountAtTime := handlers.formatAmountAtTimeAsJSON(txInfo.DeductedAmount, timestamp)
-	amountAtTime := handlers.formatAmountAtTimeAsJSON(txInfo.Amount, timestamp)
+	deductedAmountAtTime := txInfo.DeductedAmount.FormatWithConversionsAtTime(handlers.account.Coin(), timestamp, accountConfig.RateUpdater)
+	amountAtTime := txInfo.Amount.FormatWithConversionsAtTime(handlers.account.Coin(), timestamp, accountConfig.RateUpdater)
 
 	if timestamp != nil {
 		t := timestamp.Format(time.RFC3339)
@@ -247,7 +185,7 @@ func (handlers *Handlers) getTxInfoJSON(txInfo *accounts.TransactionData, detail
 			txInfoJSON.Weight = txInfo.Weight
 			feeRatePerKb := txInfo.FeeRatePerKb
 			if feeRatePerKb != nil {
-				txInfoJSON.FeeRatePerKb = handlers.formatBTCAmountAsJSON(*feeRatePerKb, true)
+				txInfoJSON.FeeRatePerKb = coin.ConvertBTCAmount(handlers.account.Coin(), *feeRatePerKb, true, accountConfig.RateUpdater)
 			}
 		case *eth.Coin:
 			txInfoJSON.Gas = txInfo.Gas
@@ -344,6 +282,7 @@ func (handlers *Handlers) getAccountInfo(*http.Request) (interface{}, error) {
 }
 
 func (handlers *Handlers) getUTXOs(*http.Request) (interface{}, error) {
+	accountConfig := handlers.account.Config()
 	result := []map[string]interface{}{}
 
 	t, ok := handlers.account.(*btc.Account)
@@ -378,7 +317,7 @@ func (handlers *Handlers) getUTXOs(*http.Request) (interface{}, error) {
 				"outPoint":      output.OutPoint.String(),
 				"txId":          output.OutPoint.Hash.String(),
 				"txOutput":      output.OutPoint.Index,
-				"amount":        handlers.formatBTCAmountAsJSON(btcutil.Amount(output.TxOut.Value), false),
+				"amount":        coin.ConvertBTCAmount(handlers.account.Coin(), btcutil.Amount(output.TxOut.Value), false, accountConfig.RateUpdater),
 				"address":       address,
 				"scriptType":    output.Address.AccountConfiguration.ScriptType(),
 				"note":          handlers.account.TxNote(output.OutPoint.Hash.String()),
@@ -391,11 +330,12 @@ func (handlers *Handlers) getUTXOs(*http.Request) (interface{}, error) {
 }
 
 func (handlers *Handlers) getAccountBalance(*http.Request) (interface{}, error) {
+	accountConfig := handlers.account.Config()
 	type balance struct {
-		HasAvailable bool            `json:"hasAvailable"`
-		Available    FormattedAmount `json:"available"`
-		HasIncoming  bool            `json:"hasIncoming"`
-		Incoming     FormattedAmount `json:"incoming"`
+		HasAvailable bool                                `json:"hasAvailable"`
+		Available    coin.FormattedAmountWithConversions `json:"available"`
+		HasIncoming  bool                                `json:"hasIncoming"`
+		Incoming     coin.FormattedAmountWithConversions `json:"incoming"`
 	}
 
 	type result struct {
@@ -410,9 +350,9 @@ func (handlers *Handlers) getAccountBalance(*http.Request) (interface{}, error)
 		Success: true,
 		Balance: balance{
 			HasAvailable: accountBalance.Available().BigInt().Sign() > 0,
-			Available:    handlers.formatAmountAsJSON(accountBalance.Available(), false),
+			Available:    accountBalance.Available().FormatWithConversions(handlers.account.Coin(), false, accountConfig.RateUpdater),
 			HasIncoming:  accountBalance.Incoming().BigInt().Sign() > 0,
-			Incoming:     handlers.formatAmountAsJSON(accountBalance.Incoming(), false),
+			Incoming:     accountBalance.Incoming().FormatWithConversions(handlers.account.Coin(), false, accountConfig.RateUpdater),
 		},
 	}, nil
 }
@@ -551,6 +491,7 @@ func txProposalError(err error) (interface{}, error) {
 }
 
 func (handlers *Handlers) postAccountTxProposal(r *http.Request) (interface{}, error) {
+	accountConfig := handlers.account.Config()
 	var input sendTxInput
 	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
 		return txProposalError(errp.WithStack(err))
@@ -561,9 +502,9 @@ func (handlers *Handlers) postAccountTxProposal(r *http.Request) (interface{}, e
 	}
 	return map[string]interface{}{
 		"success": true,
-		"amount":  handlers.formatAmountAsJSON(outputAmount, false),
-		"fee":     handlers.formatAmountAsJSON(fee, true),
-		"total":   handlers.formatAmountAsJSON(total, false),
+		"amount":  outputAmount.FormatWithConversions(handlers.account.Coin(), false, accountConfig.RateUpdater),
+		"fee":     fee.FormatWithConversions(handlers.account.Coin(), true, accountConfig.RateUpdater),
+		"total":   total.FormatWithConversions(handlers.account.Coin(), false, accountConfig.RateUpdater),
 	}, nil
 }
 

backend/coins/btc/util/util.go

@@ -18,7 +18,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/coins/coin"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/coins/ltc"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/errp"
 	"github.com/btcsuite/btcd/btcutil"
@@ -69,8 +68,3 @@ func AddressFromPkScript(pkScript []byte, net *chaincfg.Params) (btcutil.Address
 	}
 	return addresses[0], nil
 }
-
-// FormatBtcAsSat returns true if the btcUnit param is `[t]sat`.
-func FormatBtcAsSat(btcUnit coin.BtcUnit) bool {
-	return btcUnit == coin.BtcUnitSats
-}

backend/coins/coin/amount.go

@@ -17,9 +17,12 @@ package coin
 import (
 	"math/big"
 	"strings"
+	"time"
 
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/accounts/errors"
+	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/rates"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/errp"
+	"github.com/btcsuite/btcd/btcutil"
 )
 
 // Amount represents an amount in the smallest coin unit (e.g. satoshi).
@@ -76,6 +79,64 @@ func (amount Amount) BigInt() *big.Int {
 	return new(big.Int).Set(amount.n)
 }
 
+// FormattedAmountWithConversions and json tags.
+type FormattedAmountWithConversions struct {
+	Amount      string            `json:"amount"`
+	Unit        string            `json:"unit"`
+	Conversions map[string]string `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"`
+}
+
+// FormatWithConversions formats the Amount and adds fiat conversions.
+func (amount Amount) FormatWithConversions(accountCoin Coin, isFee bool, rateUpdater *rates.RateUpdater) FormattedAmountWithConversions {
+	return FormattedAmountWithConversions{
+		Amount: accountCoin.FormatAmount(amount, isFee),
+		Unit:   accountCoin.GetFormatUnit(isFee),
+		Conversions: Conversions(
+			amount,
+			accountCoin,
+			isFee,
+			rateUpdater),
+	}
+}
+
+// FormatWithConversionsAtTime formats the Amount and adds fiat conversions at a given timestamp.
+func (amount Amount) FormatWithConversionsAtTime(accountCoin Coin, timeStamp *time.Time, rateUpdater *rates.RateUpdater) FormattedAmountWithConversions {
+	var conversions map[string]string
+	var estimated bool
+
+	if timeStamp == nil {
+		conversions = Conversions(
+			amount,
+			accountCoin,
+			false,
+			rateUpdater,
+		)
+		estimated = true
+	} else {
+		conversions, estimated = ConversionsAtTime(
+			amount,
+			accountCoin,
+			false,
+			rateUpdater,
+			timeStamp,
+		)
+	}
+	return FormattedAmountWithConversions{
+		Amount:      accountCoin.FormatAmount(amount, false),
+		Unit:        accountCoin.GetFormatUnit(false),
+		Conversions: conversions,
+		Estimated:   estimated,
+	}
+}
+
+// ConvertBTCAmount formats a btcUtil.Amount and its fiat conversions into a FiatConvertedAmount.
+func ConvertBTCAmount(accountCoin Coin, amount btcutil.Amount, isFee bool, rateUpdater *rates.RateUpdater) FormattedAmountWithConversions {
+	return NewAmountFromInt64(int64(amount)).FormatWithConversions(accountCoin, isFee, rateUpdater)
+}
+
 // SendAmount is either a concrete amount, or "all"/"max". The concrete amount is user input and is
 // parsed/validated in Amount().
 type SendAmount struct {

backend/coins/coin/amount_test.go

@@ -22,6 +22,7 @@ import (
 	"testing/quick"
 
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/coins/coin"
+	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/rates"
 	"github.com/stretchr/testify/require"
 )
 
@@ -101,3 +102,13 @@ func TestSendAmount(t *testing.T) {
 	require.Equal(t, int64(0), amount.BigInt().Int64())
 
 }
+
+func TestFormatWithConversionsAtTime(t *testing.T) {
+	testCoin := mockCoin(t)
+	rateUpdater := rates.MockRateUpdater()
+
+	amount := coin.NewAmountFromInt64(12345678)
+	formattedAmount := amount.FormatWithConversionsAtTime(&testCoin, nil, rateUpdater)
+	// conversions are tested separately, we just check for the estimated flag when timestamp is nil.
+	require.True(t, formattedAmount.Estimated)
+}

backend/coins/coin/conversions.go

@@ -48,7 +48,7 @@ func FormatAsCurrency(amount *big.Rat, currency string) string {
 }
 
 // Conversions handles fiat conversions.
-func Conversions(amount Amount, coin Coin, isFee bool, ratesUpdater *ratesPkg.RateUpdater, formatBtcAsSats bool) map[string]string {
+func Conversions(amount Amount, coin Coin, isFee bool, ratesUpdater *ratesPkg.RateUpdater) map[string]string {
 	conversions := map[string]string{}
 	rates := ratesUpdater.LatestPrice()
 	if rates != nil {
@@ -66,11 +66,11 @@ 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, formatBtcAsSats bool, timeStamp *time.Time) (map[string]string, bool) {
+func ConversionsAtTime(amount Amount, coin Coin, isFee bool, ratesUpdater *ratesPkg.RateUpdater, timeStamp *time.Time) (map[string]string, 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, formatBtcAsSats), true
+		return Conversions(amount, coin, isFee, ratesUpdater), true
 	}
 
 	conversions := map[string]string{}