profile

dao/db.go

@@ -285,6 +285,52 @@ func (d *Dao) GetBridgeTokenBalance(chainId int64, user string) (balances apiMod
 	return balances, nil
 }
 
+func (d *Dao) GetTokenBalance(chainId int64, user string, tokens []string) (balances apiModel.TokenBalances, err error) {
+	balances = apiModel.TokenBalances{
+		Balances: make([]apiModel.TokenBalance, 0),
+	}
+
+	chainClient := d.ChainClient(chainId)
+	if chainClient == nil {
+		log.Error("not found chain client for chain id:", chainId)
+		return balances, nil
+	}
+
+	var innerBalance = make([]tokenBalance, 0)
+	for _, token := range tokens {
+		tokenInfo, balance, err := d.tokenRepo.RetriveTokenInfoAndBalance(chainClient, token, user)
+		if err != nil {
+			log.WithFields(log.Fields{
+				"chain_id": chainId,
+				"token":    token,
+				"error":    err,
+			}).Error("get token balance failed, skip this token")
+			continue
+		}
+		innerBalance = append(innerBalance, tokenBalance{
+			Name:     tokenInfo.Symbol,
+			Decimals: int(tokenInfo.Decimals),
+			Balance:  balance,
+			Contract: token,
+		})
+	}
+	// sort balances by Balance desc
+	sort.Slice(innerBalance, func(i, j int) bool {
+		return innerBalance[i].Balance.Cmp(innerBalance[j].Balance) > 0
+	})
+
+	for _, b := range innerBalance {
+		balances.Balances = append(balances.Balances, apiModel.TokenBalance{
+			Name:     b.Name,
+			Decimals: b.Decimals,
+			Balance:  b.Balance.String(),
+			Contract: b.Contract,
+		})
+	}
+
+	return balances, nil
+}
+
 func (d *Dao) buildBridgePayload(token common.Address, amount *big.Int, toChainID *big.Int, receiver common.Address) ([]byte, error) {
 	contractAbi, _ := bridge.BridgeContractMetaData.GetAbi()
 	return contractAbi.Pack("outTransfer", token, amount, toChainID, receiver)
@@ -440,10 +486,17 @@ func (d *Dao) GetSwapConfig(chainId int64) (*apiModel.ChainSwapConfig, error) {
 			SwapFromToken:   bridgeToken.Token,
 			BridgeFromToken: bridgeToken.Token,
 		})
+		tokenInfo, err := d.tokenRepo.RetriveTokenInfo(chainId, bridgeToken.Token)
+		if err != nil {
+			log.WithFields(log.Fields{
+				"chain_id": chainId,
+				"token":    bridgeToken.Token,
+			}).Warning("get token info failed")
+		}
 		if len(toChains) > 0 {
 			config.SupportTokens[bridgeToken.Token] = apiModel.SupportSwapTokenInfo{
 				TokenContract: bridgeToken.Token,
-				TokenSymbol:   bridgeToken.TokenName,
+				TokenSymbol:   tokenInfo.Symbol,
 				SwapTokens:    toChains,
 			}
 		}
@@ -460,6 +513,14 @@ func (d *Dao) GetSwapConfig(chainId int64) (*apiModel.ChainSwapConfig, error) {
 			return config, err
 		}
 
+		tokenInfo, err := d.tokenRepo.RetriveTokenInfo(chainId, swap.Token)
+		if err != nil {
+			log.WithFields(log.Fields{
+				"chain_id": chainId,
+				"token":    swap.Token,
+			}).Warning("get token info failed")
+		}
+
 		toChains := d.getTargetChainSwapTokens(swapChains, apiModel.SwapPath{
 			SwapFromToken:   swap.Token,
 			BridgeFromToken: swap.ToToken,
@@ -467,7 +528,7 @@ func (d *Dao) GetSwapConfig(chainId int64) (*apiModel.ChainSwapConfig, error) {
 		if len(toChains) > 0 {
 			config.SupportTokens[swap.Token] = apiModel.SupportSwapTokenInfo{
 				TokenContract: swap.Token,
-				TokenSymbol:   swap.TokenName,
+				TokenSymbol:   tokenInfo.Symbol,
 				SwapTokens:    toChains,
 			}
 		}
@@ -689,17 +750,17 @@ func (d *Dao) getSupportedBridgeChains(fromChain int64, token string) (configs [
 	return configs, err
 }
 
+func (d *Dao) justABridgePair(path apiModel.SwapPath) bool {
+	return path.SwapFromToken == path.BridgeFromToken && path.BridgeToToken == path.SwapToToken
+}
+
 func (d *Dao) getTargetChainSwapTokens(targetChains []dbModel.BridgeTokenInfo, fromPath apiModel.SwapPath) map[int64]map[string]apiModel.ToSwapToken {
 	toChains := make(map[int64]map[string]apiModel.ToSwapToken)
 	for _, sc := range targetChains {
 		if !sc.Enabled {
 			continue
 		}
-		tokens, exist := toChains[sc.ToChainId]
-		if !exist {
-			tokens = make(map[string]apiModel.ToSwapToken)
-			toChains[sc.ToChainId] = tokens
-		}
+
 		toTokenInfo, err := d.tokenRepo.RetriveTokenInfo(sc.ToChainId, sc.ToToken)
 		if err != nil {
 			log.WithFields(log.Fields{
@@ -708,17 +769,27 @@ func (d *Dao) getTargetChainSwapTokens(targetChains []dbModel.BridgeTokenInfo, f
 			}).Error("get token info failed")
 			continue
 		}
-		tokens[sc.ToToken] = apiModel.ToSwapToken{
-			ToChainId:     sc.ToChainId,
-			ToToken:       sc.ToToken,
-			ToTokenSymbol: toTokenInfo.Symbol,
-			Path: apiModel.SwapPath{
+		path := apiModel.SwapPath{
 			SwapFromToken:   fromPath.SwapFromToken,
 			BridgeFromToken: fromPath.BridgeFromToken,
 			BridgeToToken:   sc.ToToken,
 			SwapToToken:     sc.ToToken,
-			},
 		}
+
+		if !d.justABridgePair(path) {
+			tokens, exist := toChains[sc.ToChainId]
+			if !exist {
+				tokens = make(map[string]apiModel.ToSwapToken)
+				toChains[sc.ToChainId] = tokens
+			}
+			tokens[sc.ToToken] = apiModel.ToSwapToken{
+				ToChainId:     sc.ToChainId,
+				ToToken:       sc.ToToken,
+				ToTokenSymbol: toTokenInfo.Symbol,
+				Path:          path,
+			}
+		}
+
 		// get all supported swap tokens for toChainId
 		targetChainSwapTokens, err := d.getSupportedSwapTokens(sc.ToChainId)
 		if err != nil {
@@ -730,22 +801,33 @@ func (d *Dao) getTargetChainSwapTokens(targetChains []dbModel.BridgeTokenInfo, f
 				if err != nil {
 					continue
 				}
+				path := apiModel.SwapPath{
+					SwapFromToken:   fromPath.SwapFromToken,
+					BridgeFromToken: fromPath.BridgeFromToken,
+					BridgeToToken:   sc.ToToken,
+					SwapToToken:     targetSwap.ToToken,
+				}
+
+				if !d.justABridgePair(path) {
+					tokens, exist := toChains[sc.ToChainId]
+					if !exist {
+						tokens = make(map[string]apiModel.ToSwapToken)
+						toChains[sc.ToChainId] = tokens
+					}
 					// add targetSwap.ToToken to toChains
 					tokens[targetSwap.ToToken] = apiModel.ToSwapToken{
 						ToChainId:     targetSwap.ChainId,
 						ToToken:       targetSwap.ToToken,
 						ToTokenSymbol: tokenInfo.Symbol,
-					Path: apiModel.SwapPath{
-						SwapFromToken:   fromPath.SwapFromToken,
-						BridgeFromToken: fromPath.BridgeFromToken,
-						BridgeToToken:   sc.ToToken,
-						SwapToToken:     targetSwap.ToToken,
-					},
+						Path:          path,
+					}
 				}
 			}
 		}
+		if tokens, exist := toChains[sc.ToChainId]; exist && len(tokens) > 0 {
 			toChains[sc.ToChainId] = tokens
 		}
+	}
 	return toChains
 }
 

model/api/model.go

@@ -87,6 +87,12 @@ type RouterQuery struct {
 	User    string `json:"user"`
 }
 
+type TokenBalanceQuery struct {
+	ChainId  int64    `json:"chain_id"`
+	User     string   `json:"user"`
+	TokeList []string `json:"toke_list"`
+}
+
 type QuoteBridgeParam struct {
 	FromChainId int64  `json:"from_chain_id"`
 	ToChainId   int64  `json:"to_chain_id"`
@@ -128,6 +134,7 @@ type Querier interface {
 	GetAllChainSwapConfig() (map[int64]*ChainSwapConfig, error)
 	GetSwapConfig(int64) (*ChainSwapConfig, error)
 	GetHistoryInfo(user string) (history History, err error)
+	GetTokenBalance(chainId int64, user string, tokens []string) (balances TokenBalances, err error)
 	GetBridgeTokenBalance(chainId int64, user string) (balances TokenBalances, err error)
 	QuoteBridge(param QuoteBridgeParam) (quote QuoteResult, err error)
 	GetSwapTokenBalance(chainId int64, user string) (balances TokenBalances, err error)

server/controller.go

@@ -54,12 +54,7 @@ func bridgeRouters(c *gin.Context) {
 		c.JSON(500, withError(constant.InternalError))
 		return
 	}
-	var queryParam apiModel.RouterQuery
-	if err := c.ShouldBindQuery(&queryParam); err != nil {
-		log.Errorf("bind query param error: %v", err)
-		c.JSON(200, withError(constant.InvalidParam))
-		return
-	}
+
 	config, err := _querier.GetBridgeConfig()
 	if err != nil {
 		log.Errorf("get bridge config error: %v", err)
@@ -75,7 +70,7 @@ func bridgeBalance(c *gin.Context) {
 		c.JSON(500, withError(constant.InternalError))
 		return
 	}
-	var queryParam apiModel.RouterQuery
+	var queryParam apiModel.TokenBalanceQuery
 	if err := c.ShouldBindQuery(&queryParam); err != nil {
 		log.Errorf("bind query param error: %v", err)
 		c.JSON(200, withError(constant.InvalidParam))
@@ -86,7 +81,7 @@ func bridgeBalance(c *gin.Context) {
 		c.JSON(200, withError(constant.InvalidParam))
 	}
 	// get all tokens
-	balances, err := _querier.GetBridgeTokenBalance(queryParam.ChainId, queryParam.User)
+	balances, err := _querier.GetTokenBalance(queryParam.ChainId, queryParam.User, queryParam.TokeList)
 	if err != nil {
 		log.Errorf("get bridge balance error: %v", err)
 		c.JSON(500, withError(constant.InternalError))
@@ -126,28 +121,6 @@ func bridgeQuote(c *gin.Context) {
 	c.JSON(200, withSuccess(quote))
 }
 
-func getSwapRouters(c *gin.Context) {
-	if _querier == nil {
-		log.Error("querier is nil")
-		c.JSON(500, withError(constant.InternalError))
-		return
-	}
-
-	var queryParam apiModel.RouterQuery
-	if err := c.ShouldBindQuery(&queryParam); err != nil {
-		log.Errorf("bind query param error: %v", err)
-		c.JSON(200, withError(constant.InvalidParam))
-		return
-	}
-	configs, err := _querier.GetSwapConfig(queryParam.ChainId)
-	if err != nil {
-		log.Errorf("get swap config error: %v", err)
-		c.JSON(500, withError(constant.InternalError))
-		return
-	}
-	c.JSON(200, withSuccess(configs))
-}
-
 func getAllSwapRouters(c *gin.Context) {
 	if _querier == nil {
 		log.Error("querier is nil")
@@ -169,7 +142,7 @@ func swapBalance(c *gin.Context) {
 		c.JSON(500, withError(constant.InternalError))
 		return
 	}
-	var queryParam apiModel.RouterQuery
+	var queryParam apiModel.TokenBalanceQuery
 	if err := c.ShouldBindQuery(&queryParam); err != nil {
 		log.Errorf("bind query param error: %v", err)
 		c.JSON(200, withError(constant.InvalidParam))
@@ -180,7 +153,7 @@ func swapBalance(c *gin.Context) {
 		c.JSON(200, withError(constant.InvalidParam))
 	}
 	// get all tokens
-	balances, err := _querier.GetSwapTokenBalance(queryParam.ChainId, queryParam.User)
+	balances, err := _querier.GetTokenBalance(queryParam.ChainId, queryParam.User, queryParam.TokeList)
 	if err != nil {
 		log.Errorf("get swap balance error: %v", err)
 		c.JSON(500, withError(constant.InternalError))

server/router.go

@@ -20,13 +20,13 @@ func initRouter(conf *config.Config, e *gin.Engine) {
 	}
 	{
 		bridge := v1.Group("/bridge")
-		bridge.POST("/routers", bridgeRouters)
+		bridge.GET("/routers", bridgeRouters)
 		bridge.POST("/balance", bridgeBalance)
 		bridge.POST("/quote", bridgeQuote)
 	}
 	{
 		swap := v1.Group("/swap")
-		swap.GET("/routers", getSwapRouters)
+		swap.GET("/routers", getAllSwapRouters)
 		swap.GET("/routers/:chain", getSwapRoutersByChainId)
 		swap.POST("/balance", swapBalance)
 		swap.POST("/quote", swapQuote)