243 lines
8.0 KiB
Go
243 lines
8.0 KiB
Go
package pathprocessor
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
"strconv"
|
|
"sync"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
ethTypes "github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/status-im/status-go/account"
|
|
"github.com/status-im/status-go/eth-node/types"
|
|
"github.com/status-im/status-go/rpc"
|
|
walletCommon "github.com/status-im/status-go/services/wallet/common"
|
|
"github.com/status-im/status-go/services/wallet/thirdparty/paraswap"
|
|
walletToken "github.com/status-im/status-go/services/wallet/token"
|
|
"github.com/status-im/status-go/transactions"
|
|
)
|
|
|
|
type SwapParaswapTxArgs struct {
|
|
transactions.SendTxArgs
|
|
ChainID uint64 `json:"chainId"`
|
|
ChainIDTo uint64 `json:"chainIdFrom"`
|
|
TokenIDFrom string `json:"tokenIdFrom"`
|
|
TokenIDTo string `json:"tokenIdTo"`
|
|
SlippagePercentage float32 `json:"slippagePercentage"`
|
|
}
|
|
|
|
type SwapParaswapProcessor struct {
|
|
paraswapClient *paraswap.ClientV5
|
|
transactor transactions.TransactorIface
|
|
priceRoute sync.Map // [fromChainName-toChainName-fromTokenSymbol-toTokenSymbol, paraswap.Route]
|
|
}
|
|
|
|
func NewSwapParaswapProcessor(rpcClient *rpc.Client, transactor transactions.TransactorIface, tokenManager *walletToken.Manager) *SwapParaswapProcessor {
|
|
return &SwapParaswapProcessor{
|
|
paraswapClient: paraswap.NewClientV5(walletCommon.EthereumMainnet),
|
|
transactor: transactor,
|
|
priceRoute: sync.Map{},
|
|
}
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) Name() string {
|
|
return ProcessorSwapParaswapName
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) Clear() {
|
|
s.priceRoute = sync.Map{}
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) AvailableFor(params ProcessorInputParams) (bool, error) {
|
|
if params.FromToken == nil || params.ToToken == nil {
|
|
return false, errors.New("token and toToken cannot be nil")
|
|
}
|
|
|
|
if params.FromChain.ChainID != params.ToChain.ChainID {
|
|
return false, nil
|
|
}
|
|
|
|
s.paraswapClient.SetChainID(params.FromChain.ChainID)
|
|
|
|
searchForToken := params.FromToken.Address == ZeroAddress
|
|
searchForToToken := params.ToToken.Address == ZeroAddress
|
|
if searchForToToken || searchForToken {
|
|
tokensList, err := s.paraswapClient.FetchTokensList(context.Background())
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
for _, t := range tokensList {
|
|
if searchForToken && t.Symbol == params.FromToken.Symbol {
|
|
params.FromToken.Address = common.HexToAddress(t.Address)
|
|
params.FromToken.Decimals = t.Decimals
|
|
if !searchForToToken {
|
|
break
|
|
}
|
|
}
|
|
|
|
if searchForToToken && t.Symbol == params.ToToken.Symbol {
|
|
params.ToToken.Address = common.HexToAddress(t.Address)
|
|
params.ToToken.Decimals = t.Decimals
|
|
if !searchForToken {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if params.FromToken.Address == ZeroAddress || params.ToToken.Address == ZeroAddress {
|
|
return false, errors.New("cannot resolve token/s")
|
|
}
|
|
|
|
return true, nil
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
|
|
return ZeroBigIntValue, ZeroBigIntValue, nil
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) PackTxInputData(params ProcessorInputParams) ([]byte, error) {
|
|
// not sure what we can do here since we're using the api to build the transaction
|
|
return []byte{}, nil
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) EstimateGas(params ProcessorInputParams) (uint64, error) {
|
|
swapSide := paraswap.SellSide
|
|
if params.AmountOut != nil && params.AmountOut.Cmp(ZeroBigIntValue) > 0 {
|
|
swapSide = paraswap.BuySide
|
|
}
|
|
|
|
priceRoute, err := s.paraswapClient.FetchPriceRoute(context.Background(), params.FromToken.Address, params.FromToken.Decimals,
|
|
params.ToToken.Address, params.ToToken.Decimals, params.AmountIn, params.FromAddr, params.ToAddr, swapSide)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
key := makeKey(params.FromChain.ChainID, params.ToChain.ChainID, params.FromToken.Symbol, params.ToToken.Symbol)
|
|
s.priceRoute.Store(key, &priceRoute)
|
|
|
|
return priceRoute.GasCost.Uint64(), nil
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) GetContractAddress(params ProcessorInputParams) (address common.Address, err error) {
|
|
if params.FromChain.ChainID == walletCommon.EthereumMainnet {
|
|
address = common.HexToAddress("0x216b4b4ba9f3e719726886d34a177484278bfcae")
|
|
} else if params.FromChain.ChainID == walletCommon.ArbitrumMainnet {
|
|
address = common.HexToAddress("0x216b4b4ba9f3e719726886d34a177484278bfcae")
|
|
} else if params.FromChain.ChainID == walletCommon.OptimismMainnet {
|
|
address = common.HexToAddress("0x216b4b4ba9f3e719726886d34a177484278bfcae")
|
|
} else {
|
|
err = errors.New("unsupported network")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
|
|
toAddr := types.Address(params.ToAddr)
|
|
sendArgs := &MultipathProcessorTxArgs{
|
|
SwapTx: &SwapParaswapTxArgs{
|
|
SendTxArgs: transactions.SendTxArgs{
|
|
From: types.Address(params.FromAddr),
|
|
To: &toAddr,
|
|
Value: (*hexutil.Big)(params.AmountIn),
|
|
Data: types.HexBytes("0x0"),
|
|
Symbol: params.FromToken.Symbol,
|
|
},
|
|
ChainID: params.FromChain.ChainID,
|
|
},
|
|
}
|
|
|
|
return s.BuildTransaction(sendArgs)
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) prepareTransaction(sendArgs *MultipathProcessorTxArgs) error {
|
|
slippageBP := uint(sendArgs.SwapTx.SlippagePercentage * 100) // convert to basis points
|
|
|
|
key := makeKey(sendArgs.SwapTx.ChainID, sendArgs.SwapTx.ChainIDTo, sendArgs.SwapTx.TokenIDFrom, sendArgs.SwapTx.TokenIDTo)
|
|
priceRouteIns, ok := s.priceRoute.Load(key)
|
|
if !ok {
|
|
return errors.New("price route not found")
|
|
}
|
|
priceRoute := priceRouteIns.(*paraswap.Route)
|
|
|
|
tx, err := s.paraswapClient.BuildTransaction(context.Background(), priceRoute.SrcTokenAddress, priceRoute.SrcTokenDecimals, priceRoute.SrcAmount.Int,
|
|
priceRoute.DestTokenAddress, priceRoute.DestTokenDecimals, priceRoute.DestAmount.Int, slippageBP,
|
|
common.Address(sendArgs.SwapTx.From), common.Address(*sendArgs.SwapTx.To),
|
|
priceRoute.RawPriceRoute, priceRoute.Side)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
value, ok := new(big.Int).SetString(tx.Value, 10)
|
|
if !ok {
|
|
return errors.New("error converting amount to big.Int")
|
|
}
|
|
|
|
gas, err := strconv.ParseUint(tx.Gas, 10, 64)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
gasPrice, ok := new(big.Int).SetString(tx.GasPrice, 10)
|
|
if !ok {
|
|
return errors.New("error converting amount to big.Int")
|
|
}
|
|
|
|
sendArgs.ChainID = tx.ChainID
|
|
sendArgs.SwapTx.ChainID = tx.ChainID
|
|
toAddr := types.HexToAddress(tx.To)
|
|
sendArgs.SwapTx.From = types.HexToAddress(tx.From)
|
|
sendArgs.SwapTx.To = &toAddr
|
|
sendArgs.SwapTx.Value = (*hexutil.Big)(value)
|
|
sendArgs.SwapTx.Gas = (*hexutil.Uint64)(&gas)
|
|
sendArgs.SwapTx.GasPrice = (*hexutil.Big)(gasPrice)
|
|
sendArgs.SwapTx.Data = types.Hex2Bytes(tx.Data)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
|
|
err := s.prepareTransaction(sendArgs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return s.transactor.ValidateAndBuildTransaction(sendArgs.ChainID, sendArgs.SwapTx.SendTxArgs)
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (types.Hash, error) {
|
|
|
|
txBridgeArgs := &MultipathProcessorTxArgs{
|
|
SwapTx: &SwapParaswapTxArgs{
|
|
SendTxArgs: transactions.SendTxArgs{
|
|
From: sendArgs.SwapTx.From,
|
|
To: sendArgs.SwapTx.To,
|
|
MultiTransactionID: sendArgs.SwapTx.MultiTransactionID,
|
|
Symbol: sendArgs.SwapTx.Symbol,
|
|
},
|
|
SlippagePercentage: sendArgs.SwapTx.SlippagePercentage,
|
|
},
|
|
}
|
|
|
|
err := s.prepareTransaction(txBridgeArgs)
|
|
if err != nil {
|
|
return types.Hash{}, err
|
|
}
|
|
|
|
return s.transactor.SendTransactionWithChainID(txBridgeArgs.ChainID, txBridgeArgs.SwapTx.SendTxArgs, verifiedAccount)
|
|
}
|
|
|
|
func (s *SwapParaswapProcessor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
|
|
key := makeKey(params.FromChain.ChainID, params.ToChain.ChainID, params.FromToken.Symbol, params.ToToken.Symbol)
|
|
priceRouteIns, ok := s.priceRoute.Load(key)
|
|
if !ok {
|
|
return nil, errors.New("price route not found")
|
|
}
|
|
priceRoute := priceRouteIns.(*paraswap.Route)
|
|
|
|
return priceRoute.DestAmount.Int, nil
|
|
}
|