fix bug

contract/router/method.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"math/big"
@@ -52,19 +52,31 @@ func GetAmountsOut(
 		addrPath = append(addrPath, common.HexToAddress(addrStr))
 	}
 
-	contract := bind.NewBoundContract(router, parsedRouterABI, client, client, client)
+	method := parsedRouterABI.Methods["getAmountsOut"]
+	packedArgs, err := method.Inputs.Pack(amountIn, addrPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to pack arguments: %w", err)
+	}
+
+	callData := append(method.ID, packedArgs...)
 
-	callOpts := &bind.CallOpts{
-		Context: context.Background(),
-		From:    user, // optional; included for completeness (some routers ignore).
+	res, err := client.CallContract(context.Background(), ethereum.CallMsg{
+		From: user,
+		To:   &router,
+		Data: callData,
+	}, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to call contract: %w", err)
 	}
 
-	var amounts = make([]interface{}, len(path))
-	if err := contract.Call(callOpts, &amounts, "getAmountsOut", amountIn, addrPath); err != nil {
-		return nil, fmt.Errorf("call getAmountsOut (amountIn=%s pathLen=%d): %w", amountIn.String(), len(path), err)
+	var amounts []*big.Int
+	if err := parsedRouterABI.UnpackIntoInterface(&amounts, "getAmountsOut", res); err != nil {
+		return nil, fmt.Errorf("failed to unpack results: %w", err)
 	}
 
-	amountOut := *abi.ConvertType(amounts[len(path)-1], new(*big.Int)).(**big.Int)
+	if len(amounts) == 0 {
+		return nil, errors.New("getAmountsOut returned no amounts")
+	}
 
-	return amountOut, nil
+	return amounts[len(amounts)-1], nil
 }

dao/db.go

@@ -588,13 +588,18 @@ func (d *Dao) GetSwapTokenBalance(chainId int64, user string) (balances apiModel
 }
 
 func (d *Dao) QuoteSwap(param apiModel.QuoteSwapParam) (quote apiModel.QuoteResult, err error) {
-	chainInfo, err := d.GetChainConfig(param.FromChainId)
+	fromChainInfo, err := d.GetChainConfig(param.FromChainId)
 	if err != nil {
 		log.Error("not found chain config for chain id:", param.FromChainId)
 		return quote, fmt.Errorf("not found chain for chain id")
 	}
+	toChainInfo, err := d.GetChainConfig(param.ToChainId)
+	if err != nil {
+		log.Error("not found chain config for chain id:", param.ToChainId)
+		return quote, fmt.Errorf("not found chain for chain id")
+	}
 
-	_, balance, err := d.tokenRepo.RetriveTokenInfoAndBalance(chainInfo.cli, param.Path.SwapFromToken, param.User)
+	_, balance, err := d.tokenRepo.RetriveTokenInfoAndBalance(fromChainInfo.cli, param.Path.SwapFromToken, param.User)
 	if err != nil {
 		log.WithFields(log.Fields{
 			"chain_id": param.FromChainId,
@@ -624,7 +629,7 @@ func (d *Dao) QuoteSwap(param apiModel.QuoteSwapParam) (quote apiModel.QuoteResu
 	}
 
 	quote = apiModel.QuoteResult{
-		ToContract: chainInfo.conf.BridgeContract,
+		ToContract: fromChainInfo.conf.BridgeContract,
 		OutAmount:  inputAmount.String(),
 	}
 
@@ -641,13 +646,14 @@ func (d *Dao) QuoteSwap(param apiModel.QuoteSwapParam) (quote apiModel.QuoteResu
 			}).Error("not found swap config for swap from token to bridge from token")
 			return quote, err
 		}
-		swapFromAmount, err := router.GetAmountsOut(chainInfo.cli, common.HexToAddress(param.User), common.HexToAddress(swapConfig.SwapContract), inputAmount, swapConfig.SwapPath)
+		swapFromAmount, err := router.GetAmountsOut(fromChainInfo.cli, common.HexToAddress(param.User), common.HexToAddress(swapConfig.SwapContract), inputAmount, swapConfig.SwapPath)
 		if err != nil {
 			log.WithFields(log.Fields{
 				"chain_id":          param.FromChainId,
 				"swap_from_token":   param.Path.SwapFromToken,
 				"bridge_from_token": param.Path.BridgeFromToken,
 				"input_amount":      inputAmount.String(),
+				"swap_contract":     swapConfig.SwapContract,
 				"error":             err,
 			}).Error("get swap amounts out failed")
 			return quote, fmt.Errorf("internal error")
@@ -701,13 +707,14 @@ func (d *Dao) QuoteSwap(param apiModel.QuoteSwapParam) (quote apiModel.QuoteResu
 			}).Error("not found swap config for bridge to token to swap to token")
 			return quote, fmt.Errorf("internal error")
 		}
-		swapToAmount, err := router.GetAmountsOut(chainInfo.cli, common.HexToAddress(param.User), common.HexToAddress(swapConfig.SwapContract), outAmount, swapConfig.SwapPath)
+		swapToAmount, err := router.GetAmountsOut(toChainInfo.cli, common.HexToAddress(param.User), common.HexToAddress(swapConfig.SwapContract), outAmount, swapConfig.SwapPath)
 		if err != nil {
 			log.WithFields(log.Fields{
 				"chain_id":        param.ToChainId,
 				"bridge_to_token": param.Path.BridgeToToken,
 				"swap_to_token":   param.Path.SwapToToken,
 				"input_amount":    outAmount.String(),
+				"swap_contract":   swapConfig.SwapContract,
 				"error":           err,
 			}).Error("get swap amounts out failed")
 			return quote, fmt.Errorf("internal error")