Error handling for wrong dc output

Author: harsh-98

core/gear.go

@@ -44,7 +44,7 @@ type RepositoryI interface {
 	AddAllowedToken(atoken *AllowedToken)
 	AddTokenObj(token *Token)
 	GetToken(addr string) *Token
-	ConvertToBalanceWithMask(balances []mainnet.DataTypesTokenBalance, mask *big.Int) *JsonBalance
+	ConvertToBalanceWithMask(balances []mainnet.DataTypesTokenBalance, mask *big.Int) (*JsonBalance, error)
 	// credit session funcs
 	AddCreditSession(session *CreditSession, loadedFromDB bool)
 	GetCreditSession(sessionId string) *CreditSession

core/token.go

@@ -1,10 +1,8 @@
 package core
 
 import (
-	"fmt"
 	"github.com/Gearbox-protocol/third-eye/artifacts/eRC20"
 	"github.com/Gearbox-protocol/third-eye/ethclient"
-	"github.com/Gearbox-protocol/third-eye/log"
 	"github.com/Gearbox-protocol/third-eye/utils"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -21,31 +19,31 @@ func (Token) TableName() string {
 	return "tokens"
 }
 
-func NewToken(addr string, client *ethclient.Client) *Token {
+func NewToken(addr string, client *ethclient.Client) (*Token, error) {
 	token := &Token{
 		Address: addr,
 		client:  client,
 	}
-	token.init()
-	return token
+	err := token.init()
+	return token, err
 }
 
-func (t *Token) init() {
+func (t *Token) init() error {
 	contract, err := eRC20.NewERC20(common.HexToAddress(t.Address), t.client)
 	if err != nil {
-		log.Fatal(err, t.Address)
+		return err
 	}
 	if symbol, err := contract.Symbol(&bind.CallOpts{}); err != nil {
-		log.Error(fmt.Sprintf("%s %s", err, t.Address))
-		panic("")
+		return err
 	} else {
 		t.Symbol = symbol
 	}
 	if decimals, err := contract.Decimals(&bind.CallOpts{}); err != nil {
-		log.Fatal(err, t.Address)
+		return err
 	} else {
 		t.Decimals = int8(decimals)
 	}
+	return nil
 }
 
 type AllowedToken struct {

debts/engine.go

@@ -192,23 +192,25 @@ func (eng *DebtEngine) CalculateSessionDebt(blockNum int64, sessionId string, cm
 	// profiling
 	tokenDetails := map[string]core.TokenDetails{}
 	for tokenAddr, balance := range *sessionSnapshot.Balances {
-		if !balance.Linked {
-			continue
-		}
 		decimal := eng.repo.GetToken(tokenAddr).Decimals
 		price := eng.GetTokenLastPrice(tokenAddr)
-		tokenValue := new(big.Int).Mul(price, balance.BI.Convert())
-		tokenValueInDecimal := utils.GetInt64Decimal(tokenValue, decimal-underlyingtoken.Decimals)
 		tokenLiquidityThreshold := eng.allowedTokensThreshold[cmAddr][tokenAddr]
-		tokenThresholdValue := new(big.Int).Mul(tokenValueInDecimal, tokenLiquidityThreshold.Convert())
-		calThresholdValue = new(big.Int).Add(calThresholdValue, tokenThresholdValue)
-		calTotalValue = new(big.Int).Add(calTotalValue, tokenValueInDecimal)
 		// profiling
 		tokenDetails[tokenAddr] = core.TokenDetails{
 			Price:             price,
 			Decimals:          decimal,
 			TokenLiqThreshold: tokenLiquidityThreshold,
 			Symbol:            eng.repo.GetToken(tokenAddr).Symbol}
+		// token not linked continue
+		if !balance.Linked {
+			continue
+		}
+		tokenValue := new(big.Int).Mul(price, balance.BI.Convert())
+		tokenValueInDecimal := utils.GetInt64Decimal(tokenValue, decimal-underlyingtoken.Decimals)
+		tokenThresholdValue := new(big.Int).Mul(tokenValueInDecimal, tokenLiquidityThreshold.Convert())
+		calThresholdValue = new(big.Int).Add(calThresholdValue, tokenThresholdValue)
+		calTotalValue = new(big.Int).Add(calTotalValue, tokenValueInDecimal)
+
 	}
 	// the value of credit account is in terms of underlying asset
 	underlyingPrice := eng.GetTokenLastPrice(cumIndexAndUToken.Token)
@@ -242,7 +244,11 @@ func (eng *DebtEngine) CalculateSessionDebt(blockNum int64, sessionId string, cm
 			!core.CompareBalance(debt.CalBorrowedAmountPlusInterestBI, debt.BorrowedAmountPlusInterestBI, underlyingtoken) ||
 			core.ValueDifferSideOf10000(debt.CalHealthFactor, debt.HealthFactor) {
 			mask := eng.repo.GetMask(blockNum, cmAddr, accountAddr)
-			profile.RPCBalances = eng.repo.ConvertToBalanceWithMask(data.Balances, mask)
+			var err error
+			profile.RPCBalances, err = eng.repo.ConvertToBalanceWithMask(data.Balances, mask)
+			if err != nil {
+				log.Fatalf("DC wrong token values block:%d dc:%s", blockNum, utils.ToJson(eng.repo.GetDCWrapper()))
+			}
 			notMatched = true
 		}
 		// even if data compressor matching is disabled check the values  with values at which last credit snapshot was taken
@@ -300,7 +306,6 @@ func (eng *DebtEngine) requestPriceFeed(blockNum int64, feed, token string) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	log.Info(token, roundData.Answer.String(), utils.GetFloat64Decimal(roundData.Answer, 18))
 	eng.AddTokenLastPrice(&core.PriceFeed{
 		BlockNumber: blockNum,
 		Token:       token,

models/credit_manager/credit_session_state.go

@@ -87,7 +87,11 @@ func (mdl *CreditManager) closeSession(sessionId string, blockNum int64, closeDe
 	css.TotalValueBI = core.NewBigInt(session.TotalValueBI)
 	css.TotalValue = utils.GetFloat64Decimal(data.TotalValue, mdl.GetUnderlyingDecimal())
 	mask := mdl.Repo.GetMask(blockNum, mdl.GetAddress(), session.Account)
-	css.Balances = mdl.Repo.ConvertToBalanceWithMask(data.Balances, mask)
+	var err error
+	css.Balances, err = mdl.Repo.ConvertToBalanceWithMask(data.Balances, mask)
+	if err != nil {
+		log.Fatalf("DC wrong token values block:%d dc:%s", blockNum, utils.ToJson(mdl.Repo.GetDCWrapper()))
+	}
 	css.BorrowedAmountBI = core.NewBigInt(session.BorrowedAmount)
 	css.BorrowedAmount = utils.GetFloat64Decimal(data.BorrowedAmount, mdl.GetUnderlyingDecimal())
 	css.СumulativeIndexAtOpen = core.NewBigInt((*core.BigInt)(data.CumulativeIndexAtOpen))
@@ -115,7 +119,11 @@ func (mdl *CreditManager) updateSession(sessionId string, blockNum int64) {
 	css.TotalValueBI = core.NewBigInt(session.TotalValueBI)
 	css.TotalValue = utils.GetFloat64Decimal(data.TotalValue, mdl.GetUnderlyingDecimal())
 	mask := mdl.Repo.GetMask(blockNum, mdl.GetAddress(), session.Account)
-	css.Balances = mdl.Repo.ConvertToBalanceWithMask(data.Balances, mask)
+	var err error
+	css.Balances, err = mdl.Repo.ConvertToBalanceWithMask(data.Balances, mask)
+	if err != nil {
+		log.Fatalf("DC wrong token values block:%d dc:%s", blockNum, utils.ToJson(mdl.Repo.GetDCWrapper()))
+	}
 	css.BorrowedAmountBI = core.NewBigInt(session.BorrowedAmount)
 	css.BorrowedAmount = utils.GetFloat64Decimal(data.BorrowedAmount, mdl.GetUnderlyingDecimal())
 	css.СumulativeIndexAtOpen = core.NewBigInt((*core.BigInt)(data.CumulativeIndexAtOpen))

repository/credit_session_snapshot.go

@@ -15,18 +15,23 @@ func (repo *Repository) AddCreditSessionSnapshot(css *core.CreditSessionSnapshot
 	repo.blocks[css.BlockNum].AddCreditSessionSnapshot(css)
 }
 
-func (repo *Repository) ConvertToBalanceWithMask(balances []mainnet.DataTypesTokenBalance, mask *big.Int) *core.JsonBalance {
+func (repo *Repository) ConvertToBalanceWithMask(balances []mainnet.DataTypesTokenBalance, mask *big.Int) (*core.JsonBalance, error) {
 	jsonBalance := core.JsonBalance{}
 	maskInBits := fmt.Sprintf("%b", mask)
+	maskLen := len(maskInBits)
 	for i, token := range balances {
 		tokenAddr := token.Token.Hex()
 		if token.Balance.Sign() != 0 {
+			tokenObj, err := repo.getTokenWithError(tokenAddr)
+			if err != nil {
+				return nil, err
+			}
 			jsonBalance[tokenAddr] = &core.BalanceType{
 				BI:     (*core.BigInt)(token.Balance),
-				F:      utils.GetFloat64Decimal(token.Balance, repo.GetToken(tokenAddr).Decimals),
-				Linked: maskInBits[i] == '1',
+				F:      utils.GetFloat64Decimal(token.Balance, tokenObj.Decimals),
+				Linked: maskInBits[maskLen-i-1] == '1',
 			}
 		}
 	}
-	return &jsonBalance
+	return &jsonBalance, nil
 }

repository/token.go

@@ -7,20 +7,38 @@ import (
 
 // For token with symbol/decimals
 func (repo *Repository) AddToken(addr string) *core.Token {
+	token, err := repo.addToken(addr)
+	if err != nil {
+		log.Fatal("Adding token failed for", token)
+	}
+	return token
+}
+
+func (repo *Repository) addToken(addr string) (*core.Token, error) {
 	repo.mu.Lock()
 	defer repo.mu.Unlock()
 	if repo.tokens[addr] == nil {
-		repo.tokens[addr] = core.NewToken(addr, repo.client)
+		var err error
+		repo.tokens[addr], err = core.NewToken(addr, repo.client)
+		if err != nil {
+			return nil, err
+		}
 	}
-	return repo.tokens[addr]
+	return repo.tokens[addr], nil
 }
 
 func (repo *Repository) GetToken(addr string) *core.Token {
+	token, err := repo.getTokenWithError(addr)
+	log.CheckFatal(err)
+	return token
+}
+
+func (repo *Repository) getTokenWithError(addr string) (*core.Token, error) {
 	token := repo.tokens[addr]
 	if token == nil {
-		return repo.AddToken(addr)
+		return repo.addToken(addr)
 	}
-	return token
+	return token, nil
 }
 
 func (repo *Repository) loadToken() {

utils/index.go

@@ -157,8 +157,8 @@ func IntDiffMoreThanFraction(oldValue, newValue, diff int64) bool {
 	return absInt64((newValue-oldValue)/oldValue) > diff
 }
 
-func ToJson(obj interface{}) {
+func ToJson(obj interface{}) string {
 	str, err := json.Marshal(obj)
 	log.CheckFatal(err)
-	log.Info(string(str))
+	return string(str)
 }