fix(wallet)_: fixed pegged token currency format

Author: dlipicar

services/wallet/currency/currency.go

@@ -1,14 +1,15 @@
 package currency
 
 import (
-	"errors"
 	"math"
 	"strings"
 
+	"go.uber.org/zap"
+
 	iso4217 "github.com/ladydascalie/currency"
 
 	"github.com/status-im/status-go/services/wallet/market"
-	"github.com/status-im/status-go/services/wallet/token"
+	tokentypes "github.com/status-im/status-go/services/wallet/token/types"
 )
 
 const decimalsCalculationCurrency = "USD"
@@ -26,11 +27,13 @@ type FormatPerSymbol = map[string]Format
 
 type Currency struct {
 	marketManager *market.Manager
+	logger        *zap.Logger
 }
 
-func NewCurrency(marketManager *market.Manager) *Currency {
+func NewCurrency(marketManager *market.Manager, logger *zap.Logger) *Currency {
 	return &Currency{
 		marketManager: marketManager,
+		logger:        logger,
 	}
 }
 
@@ -87,17 +90,6 @@ func calculateTokenDisplayDecimals(price float64) uint {
 }
 
 func (cm *Currency) calculateTokenCurrencyFormat(symbol string, price float64) (*Format, error) {
-	pegSymbol := token.GetTokenPegSymbol(symbol)
-
-	if pegSymbol != "" {
-		var currencyFormat, err = calculateFiatCurrencyFormat(pegSymbol)
-		if err != nil {
-			return nil, err
-		}
-		currencyFormat.Symbol = symbol
-		return currencyFormat, nil
-	}
-
 	currencyFormat := &Format{
 		Symbol:              symbol,
 		DisplayDecimals:     calculateTokenDisplayDecimals(price),
@@ -122,29 +114,57 @@ func GetFiatCurrencyFormats(symbols []string) (FormatPerSymbol, error) {
 	return formats, nil
 }
 
-func (cm *Currency) FetchTokenCurrencyFormats(symbols []string) (FormatPerSymbol, error) {
+func (cm *Currency) FetchTokenCurrencyFormats(tokens []*tokentypes.Token) (FormatPerSymbol, error) {
 	formats := make(FormatPerSymbol)
 
-	// Get latest cached price, fetch only if not available
-	prices, err := cm.marketManager.GetOrFetchPrices(symbols, []string{decimalsCalculationCurrency}, math.MaxInt64)
-	if err != nil {
-		return nil, err
-	}
+	peggedTokens := make(map[string]*tokentypes.Token, 0)
+	nonPeggedTokens := make(map[string]*tokentypes.Token, 0)
 
-	for _, symbol := range symbols {
-		priceData, ok := prices[symbol][decimalsCalculationCurrency]
+	for _, token := range tokens {
+		if token.PegSymbol != "" {
+			peggedTokens[token.Symbol] = token
+		} else {
+			nonPeggedTokens[token.Symbol] = token
+		}
+	}
 
-		if !ok {
-			return nil, errors.New("Could not get price for: " + symbol)
+	for _, token := range peggedTokens {
+		var currencyFormat, err = calculateFiatCurrencyFormat(token.PegSymbol)
+		if err != nil {
+			cm.logger.Error("Failed to calculate fiat currency format for pegged token", zap.Error(err))
+			continue
 		}
+		currencyFormat.Symbol = token.Symbol
+		formats[token.Symbol] = *currencyFormat
+	}
 
-		format, err := cm.calculateTokenCurrencyFormat(symbol, priceData.Price)
+	if len(nonPeggedTokens) > 0 {
+		symbols := make([]string, 0, len(nonPeggedTokens))
+		for symbol := range nonPeggedTokens {
+			symbols = append(symbols, symbol)
+		}
 
+		// Get latest cached price, fetch only if not available
+		prices, err := cm.marketManager.GetOrFetchPrices(symbols, []string{decimalsCalculationCurrency}, math.MaxInt64)
 		if err != nil {
 			return nil, err
 		}
 
-		formats[symbol] = *format
+		for _, symbol := range symbols {
+			priceData, ok := prices[symbol][decimalsCalculationCurrency]
+
+			if !ok {
+				cm.logger.Error("Could not get price for: " + symbol)
+				continue
+			}
+
+			format, err := cm.calculateTokenCurrencyFormat(symbol, priceData.Price)
+			if err != nil {
+				return nil, err
+			}
+
+			formats[symbol] = *format
+		}
 	}
 
 	return formats, nil

services/wallet/currency/service.go

@@ -5,10 +5,14 @@ import (
 	"database/sql"
 	"time"
 
+	"go.uber.org/zap"
+
 	"github.com/ethereum/go-ethereum/event"
 	gocommon "github.com/status-im/status-go/common"
+	"github.com/status-im/status-go/logutils"
 	"github.com/status-im/status-go/services/wallet/market"
 	"github.com/status-im/status-go/services/wallet/token"
+	tokentypes "github.com/status-im/status-go/services/wallet/token/types"
 	"github.com/status-im/status-go/services/wallet/walletevent"
 )
 
@@ -24,25 +28,33 @@ type Service struct {
 
 	tokenManager *token.Manager
 	walletFeed   *event.Feed
+
+	logger *zap.Logger
 }
 
 func NewService(db *sql.DB, walletFeed *event.Feed, tokenManager *token.Manager, marketManager *market.Manager) *Service {
+	logger := logutils.ZapLogger().Named("Currency")
 	return &Service{
-		currency:     NewCurrency(marketManager),
+		currency:     NewCurrency(marketManager, logger),
 		db:           NewCurrencyDB(db),
 		tokenManager: tokenManager,
 		walletFeed:   walletFeed,
+		logger:       logger,
 	}
 }
 
 func (s *Service) Start(ctx context.Context) {
 	// Update all fiat currency formats in cache
 	fiatFormats, err := s.getAllFiatCurrencyFormats()
-
 	if err == nil {
 		_ = s.db.UpdateCachedFormats(fiatFormats)
 	}
 
+	fixedTokenFormats, err := s.getAllFixedTokenCurrencyFormats()
+	if err == nil {
+		_ = s.db.UpdateCachedFormats(fixedTokenFormats)
+	}
+
 	go func() {
 		defer gocommon.LogOnPanic()
 		ticker := time.NewTicker(currencyFormatUpdateInterval)
@@ -69,12 +81,14 @@ func (s *Service) FetchAllCurrencyFormats() (FormatPerSymbol, error) {
 	tokenFormats, err := s.fetchAllTokenCurrencyFormats()
 
 	if err != nil {
+		s.logger.Error("Failed to fetch all token currency formats", zap.Error(err))
 		return nil, err
 	}
 
 	err = s.db.UpdateCachedFormats(tokenFormats)
 
 	if err != nil {
+		s.logger.Error("Failed to update cached currency formats", zap.Error(err))
 		return nil, err
 	}
 
@@ -85,31 +99,44 @@ func (s *Service) getAllFiatCurrencyFormats() (FormatPerSymbol, error) {
 	return GetFiatCurrencyFormats(GetAllFiatCurrencySymbols())
 }
 
-func (s *Service) fetchAllTokenCurrencyFormats() (FormatPerSymbol, error) {
+func (s *Service) getAllFixedTokenCurrencyFormats() (FormatPerSymbol, error) {
 	tokens, err := s.tokenManager.GetAllTokens()
 	if err != nil {
 		return nil, err
 	}
 
-	tokenPerSymbolMap := make(map[string]bool)
-	tokenSymbols := make([]string, 0)
-	for _, t := range tokens {
-		symbol := t.Symbol
-		if !tokenPerSymbolMap[symbol] {
-			tokenPerSymbolMap[symbol] = true
-			tokenSymbols = append(tokenSymbols, symbol)
+	peggedTokens := make([]*tokentypes.Token, 0, len(tokens))
+	for _, token := range tokens {
+		if token.PegSymbol != "" {
+			peggedTokens = append(peggedTokens, token)
 		}
 	}
 
-	tokenFormats, err := s.currency.FetchTokenCurrencyFormats(tokenSymbols)
+	tokenFormats, err := s.currency.FetchTokenCurrencyFormats(peggedTokens)
 	if err != nil {
 		return nil, err
 	}
-	gweiSymbol := "Gwei"
+
+	const gweiSymbol = "Gwei"
 	tokenFormats[gweiSymbol] = Format{
 		Symbol:              gweiSymbol,
 		DisplayDecimals:     9,
 		StripTrailingZeroes: true,
 	}
+
+	return tokenFormats, nil
+}
+
+func (s *Service) fetchAllTokenCurrencyFormats() (FormatPerSymbol, error) {
+	tokens, err := s.tokenManager.GetAllTokens()
+	if err != nil {
+		return nil, err
+	}
+
+	tokenFormats, err := s.currency.FetchTokenCurrencyFormats(tokens)
+	if err != nil {
+		return nil, err
+	}
+
 	return tokenFormats, err
 }

services/wallet/reader.go

@@ -415,7 +415,7 @@ func (r *Reader) balancesToTokensByAddress(connectedPerChain map[uint64]bool, ad
 						Name:          tokens[0].Name,
 						Symbol:        symbol,
 						Decimals:      tokens[0].Decimals,
-						PegSymbol:     token.GetTokenPegSymbol(symbol),
+						PegSymbol:     tokenTypes.GetTokenPegSymbol(symbol),
 						Verified:      tokens[0].Verified,
 						CommunityData: tokens[0].CommunityData,
 						Image:         tokens[0].Image,

services/wallet/token/token-lists/builder.go

@@ -11,6 +11,7 @@ import (
 	"github.com/status-im/status-go/multiaccounts/settings"
 	defaulttokenlists "github.com/status-im/status-go/services/wallet/token/token-lists/default-lists"
 	"github.com/status-im/status-go/services/wallet/token/token-lists/fetcher"
+	tokenTypes "github.com/status-im/status-go/services/wallet/token/types"
 )
 
 func (t *TokenLists) rebuildTokensMap(fetchedLists []fetcher.FetchedTokenList) error {
@@ -27,6 +28,8 @@ func (t *TokenLists) rebuildTokensMap(fetchedLists []fetcher.FetchedTokenList) e
 		list.Source = fetchedTokenList.SourceURL
 		list.FetchedTimestamp = fetchedTokenList.Fetched.Format(time.RFC3339)
 
+		processTokenPegs(list.Tokens)
+
 		t.tokensListsMu.Lock()
 		t.tokensLists[fetchedTokenList.ID] = &list
 		t.tokensListsMu.Unlock()
@@ -96,3 +99,9 @@ func (t *TokenLists) rebuildTokensListsMap() error {
 
 	return t.rebuildTokensMap(tokensListsForProcessing)
 }
+
+func processTokenPegs(tokens []*tokenTypes.Token) {
+	for _, token := range tokens {
+		token.PegSymbol = tokenTypes.GetTokenPegSymbol(token.Symbol)
+	}
+}

services/wallet/token/token_peg.go

@@ -0,0 +1,30 @@
+package tokentypes
+
+func getTokenPegMap() map[string]string {
+	return map[string]string{
+		"aUSDC":     "USD",
+		"DAI":       "USD",
+		"EURC":      "EUR",
+		"SAI":       "USD",
+		"sUSD":      "USD",
+		"PAXG":      "XAU",
+		"TCAD":      "CAD",
+		"TUSD":      "USD",
+		"TGBP":      "GBP",
+		"TAUD":      "AUD",
+		"USDC":      "USD",
+		"USDD":      "USD",
+		"USDS":      "USD",
+		"USDT":      "USD",
+		"USDT(6)":   "USD",
+		"USDT(18)":  "USD",
+		"USDP":      "USD",
+		"USDSC":     "USD",
+		"USDSC(6)":  "USD",
+		"USDSC(18)": "USD",
+	}
+}
+
+func GetTokenPegSymbol(symbol string) string {
+	return getTokenPegMap()[symbol]
+}