status-go/services/wallet/router/pathprocessor/processor_erc721.go

226 lines
6.7 KiB
Go
Raw Normal View History

package pathprocessor
2023-08-24 08:45:14 +00:00
import (
"context"
"fmt"
2023-08-24 08:45:14 +00:00
"math/big"
"strings"
2023-08-24 08:45:14 +00:00
"github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/accounts/abi"
"github.com/ethereum/go-ethereum/accounts/abi/bind"
2023-08-24 08:45:14 +00:00
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
ethTypes "github.com/ethereum/go-ethereum/core/types"
2023-08-24 08:45:14 +00:00
"github.com/status-im/status-go/account"
"github.com/status-im/status-go/contracts/community-tokens/collectibles"
"github.com/status-im/status-go/contracts/erc721"
2023-08-24 08:45:14 +00:00
"github.com/status-im/status-go/eth-node/types"
"github.com/status-im/status-go/rpc"
"github.com/status-im/status-go/services/wallet/token"
2023-08-24 08:45:14 +00:00
"github.com/status-im/status-go/transactions"
)
const (
functionNameSafeTransferFrom = "safeTransferFrom"
functionNameTransferFrom = "transferFrom"
)
type ERC721TxArgs struct {
2023-08-24 08:45:14 +00:00
transactions.SendTxArgs
TokenID *hexutil.Big `json:"tokenId"`
Recipient common.Address `json:"recipient"`
}
type ERC721Processor struct {
2023-08-24 08:45:14 +00:00
rpcClient *rpc.Client
transactor transactions.TransactorIface
2023-08-24 08:45:14 +00:00
}
func NewERC721Processor(rpcClient *rpc.Client, transactor transactions.TransactorIface) *ERC721Processor {
return &ERC721Processor{rpcClient: rpcClient, transactor: transactor}
2023-08-24 08:45:14 +00:00
}
func createERC721ErrorResponse(err error) error {
return createErrorResponse(ProcessorERC721Name, err)
}
func (s *ERC721Processor) Name() string {
return ProcessorERC721Name
2023-08-24 08:45:14 +00:00
}
func (s *ERC721Processor) AvailableFor(params ProcessorInputParams) (bool, error) {
2024-06-05 07:56:02 +00:00
return params.FromChain.ChainID == params.ToChain.ChainID && params.ToToken == nil, nil
2023-08-24 08:45:14 +00:00
}
func (s *ERC721Processor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
return ZeroBigIntValue, ZeroBigIntValue, nil
2023-08-24 08:45:14 +00:00
}
func (s *ERC721Processor) packTxInputDataInternally(params ProcessorInputParams, functionName string) ([]byte, error) {
abi, err := abi.JSON(strings.NewReader(erc721.Erc721MetaData.ABI))
if err != nil {
return []byte{}, createERC721ErrorResponse(err)
}
2024-06-05 07:56:02 +00:00
id, success := big.NewInt(0).SetString(params.FromToken.Symbol, 0)
if !success {
return []byte{}, createERC721ErrorResponse(fmt.Errorf("failed to convert %s to big.Int", params.FromToken.Symbol))
}
return abi.Pack(functionName,
2024-06-05 07:56:02 +00:00
params.FromAddr,
params.ToAddr,
id,
)
}
func (s *ERC721Processor) checkIfFunctionExists(params ProcessorInputParams, functionName string) error {
data, err := s.packTxInputDataInternally(params, functionName)
if err != nil {
return createERC721ErrorResponse(err)
}
ethClient, err := s.rpcClient.EthClient(params.FromChain.ChainID)
if err != nil {
return createERC721ErrorResponse(err)
}
value := new(big.Int)
msg := ethereum.CallMsg{
From: params.FromAddr,
To: &params.FromToken.Address,
Value: value,
Data: data,
}
_, err = ethClient.CallContract(context.Background(), msg, nil)
return err
}
func (s *ERC721Processor) PackTxInputData(params ProcessorInputParams) ([]byte, error) {
err := s.checkIfFunctionExists(params, functionNameSafeTransferFrom)
if err == nil {
return s.packTxInputDataInternally(params, functionNameSafeTransferFrom)
}
return s.packTxInputDataInternally(params, functionNameTransferFrom)
}
func (s *ERC721Processor) EstimateGas(params ProcessorInputParams) (uint64, error) {
if params.TestsMode {
if params.TestEstimationMap != nil {
if val, ok := params.TestEstimationMap[s.Name()]; ok {
return val, nil
}
}
return 0, ErrNoEstimationFound
}
2024-06-05 07:56:02 +00:00
ethClient, err := s.rpcClient.EthClient(params.FromChain.ChainID)
if err != nil {
return 0, createERC721ErrorResponse(err)
}
value := new(big.Int)
input, err := s.PackTxInputData(params)
if err != nil {
return 0, createERC721ErrorResponse(err)
}
msg := ethereum.CallMsg{
2024-06-05 07:56:02 +00:00
From: params.FromAddr,
To: &params.FromToken.Address,
Value: value,
Data: input,
}
2024-05-30 13:03:28 +00:00
estimation, err := ethClient.EstimateGas(context.Background(), msg)
if err != nil {
return 0, createERC721ErrorResponse(err)
}
2024-06-05 07:56:02 +00:00
increasedEstimation := float64(estimation) * IncreaseEstimatedGasFactor
return uint64(increasedEstimation), nil
2023-08-24 08:45:14 +00:00
}
func (s *ERC721Processor) sendOrBuild(sendArgs *MultipathProcessorTxArgs, signerFn bind.SignerFn, lastUsedNonce int64) (tx *ethTypes.Transaction, err error) {
from := common.Address(sendArgs.ERC721TransferTx.From)
useSafeTransferFrom := true
inputParams := ProcessorInputParams{
FromAddr: from,
ToAddr: sendArgs.ERC721TransferTx.Recipient,
FromToken: &token.Token{
Symbol: sendArgs.ERC721TransferTx.TokenID.String(),
},
}
err = s.checkIfFunctionExists(inputParams, functionNameSafeTransferFrom)
if err != nil {
useSafeTransferFrom = false
}
2023-08-24 08:45:14 +00:00
ethClient, err := s.rpcClient.EthClient(sendArgs.ChainID)
if err != nil {
return tx, createERC721ErrorResponse(err)
2023-08-24 08:45:14 +00:00
}
2023-08-24 08:45:14 +00:00
contract, err := collectibles.NewCollectibles(common.Address(*sendArgs.ERC721TransferTx.To), ethClient)
if err != nil {
return tx, createERC721ErrorResponse(err)
2023-08-24 08:45:14 +00:00
}
var nonce uint64
if lastUsedNonce < 0 {
nonce, err = s.transactor.NextNonce(s.rpcClient, sendArgs.ChainID, sendArgs.ERC721TransferTx.From)
if err != nil {
return tx, createERC721ErrorResponse(err)
}
} else {
nonce = uint64(lastUsedNonce) + 1
2023-08-24 08:45:14 +00:00
}
2023-08-24 08:45:14 +00:00
argNonce := hexutil.Uint64(nonce)
sendArgs.ERC721TransferTx.Nonce = &argNonce
txOpts := sendArgs.ERC721TransferTx.ToTransactOpts(signerFn)
if useSafeTransferFrom {
tx, err = contract.SafeTransferFrom(txOpts, from,
sendArgs.ERC721TransferTx.Recipient,
sendArgs.ERC721TransferTx.TokenID.ToInt())
} else {
tx, err = contract.TransferFrom(txOpts, from,
sendArgs.ERC721TransferTx.Recipient,
sendArgs.ERC721TransferTx.TokenID.ToInt())
}
if err != nil {
return tx, createERC721ErrorResponse(err)
}
2024-07-08 09:02:06 +00:00
err = s.transactor.StoreAndTrackPendingTx(from, sendArgs.ERC721TransferTx.Symbol, sendArgs.ChainID, sendArgs.ERC721TransferTx.MultiTransactionID, tx)
if err != nil {
return tx, createERC721ErrorResponse(err)
2024-07-08 09:02:06 +00:00
}
return tx, nil
}
func (s *ERC721Processor) Send(sendArgs *MultipathProcessorTxArgs, lastUsedNonce int64, verifiedAccount *account.SelectedExtKey) (hash types.Hash, usedNonce uint64, err error) {
tx, err := s.sendOrBuild(sendArgs, getSigner(sendArgs.ChainID, sendArgs.ERC721TransferTx.From, verifiedAccount), lastUsedNonce)
2023-08-24 08:45:14 +00:00
if err != nil {
return hash, 0, createERC721ErrorResponse(err)
2023-08-24 08:45:14 +00:00
}
return types.Hash(tx.Hash()), tx.Nonce(), nil
2023-08-24 08:45:14 +00:00
}
func (s *ERC721Processor) BuildTransaction(sendArgs *MultipathProcessorTxArgs, lastUsedNonce int64) (*ethTypes.Transaction, uint64, error) {
tx, err := s.sendOrBuild(sendArgs, nil, lastUsedNonce)
return tx, tx.Nonce(), err
}
func (s *ERC721Processor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
2024-06-05 07:56:02 +00:00
return params.AmountIn, nil
2023-08-24 08:45:14 +00:00
}
func (s *ERC721Processor) GetContractAddress(params ProcessorInputParams) (common.Address, error) {
2024-06-05 07:56:02 +00:00
return params.FromToken.Address, nil
2023-08-24 08:45:14 +00:00
}